feat(schema): add option for generating lite schema

packages/cli/src/actions/generate.ts

@@ -13,6 +13,8 @@ type Options = {
     schema?: string;
     output?: string;
     silent: boolean;
+    lite: boolean;
+    liteOnly: boolean;
 };
 
 /**
@@ -88,10 +90,15 @@ async function runPlugins(schemaFile: string, model: Model, outputPath: string,
         }
     }
 
-    const defaultPlugins = [corePlugins['typescript']].reverse();
-    defaultPlugins.forEach((d) => {
-        if (!processedPlugins.some((p) => p.cliPlugin === d)) {
-            processedPlugins.push({ cliPlugin: d, pluginOptions: {} });
+    const defaultPlugins = [
+        {
+            plugin: corePlugins['typescript'],
+            options: { lite: options.lite, liteOnly: options.liteOnly },
+        },
+    ];
+    defaultPlugins.forEach(({ plugin, options }) => {
+        if (!processedPlugins.some((p) => p.cliPlugin === plugin)) {
+            processedPlugins.push({ cliPlugin: plugin, pluginOptions: options });
         }
     });
 

packages/cli/src/index.ts

@@ -59,6 +59,8 @@ function createProgram() {
         .addOption(schemaOption)
         .addOption(noVersionCheckOption)
         .addOption(new Option('-o, --output <path>', 'default output directory for code generation'))
+        .addOption(new Option('--lite', 'also generate a lite version of schema without attributes').default(false))
+        .addOption(new Option('--lite-only', 'only generate lite version of schema without attributes').default(false))
         .addOption(new Option('--silent', 'suppress all output except errors').default(false))
         .action(generateAction);
 

packages/cli/src/plugins/typescript.ts

@@ -7,14 +7,22 @@ const plugin: CliPlugin = {
     name: 'TypeScript Schema Generator',
     statusText: 'Generating TypeScript schema',
     async generate({ model, defaultOutputPath, pluginOptions }) {
+        // output path
         let outDir = defaultOutputPath;
         if (typeof pluginOptions['output'] === 'string') {
             outDir = path.resolve(defaultOutputPath, pluginOptions['output']);
             if (!fs.existsSync(outDir)) {
                 fs.mkdirSync(outDir, { recursive: true });
             }
         }
-        await new TsSchemaGenerator().generate(model, outDir);
+
+        // lite mode
+        const lite = pluginOptions['lite'] === true;
+
+        // liteOnly mode
+        const liteOnly = pluginOptions['liteOnly'] === true;
+
+        await new TsSchemaGenerator().generate(model, { outDir, lite, liteOnly });
     },
 };
 

packages/cli/test/generate.test.ts

@@ -44,4 +44,18 @@ describe('CLI generate command test', () => {
         runCli('generate', workDir);
         expect(fs.existsSync(path.join(workDir, 'bar/schema.ts'))).toBe(true);
     });
+
+    it('should respect lite option', () => {
+        const workDir = createProject(model);
+        runCli('generate --lite', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/schema-lite.ts'))).toBe(true);
+    });
+
+    it('should respect liteOnly option', () => {
+        const workDir = createProject(model);
+        runCli('generate --lite-only', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.ts'))).toBe(false);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/schema-lite.ts'))).toBe(true);
+    });
 });

packages/cli/test/ts-schema-gen.test.ts

@@ -420,4 +420,26 @@ model User {
             },
         });
     });
+
+    it('supports lite schema generation', async () => {
+        const { schemaLite } = await generateTsSchema(
+            `
+model User {
+    id String @id @default(uuid())
+    name String
+    email String @unique
+
+    @@map('users')
+}
+        `,
+            undefined,
+            undefined,
+            undefined,
+            true,
+        );
+
+        expect(schemaLite!.models.User.attributes).toBeUndefined();
+        expect(schemaLite!.models.User.fields.id.attributes).toBeUndefined();
+        expect(schemaLite!.models.User.fields.email.attributes).toBeUndefined();
+    });
 });

packages/clients/tanstack-query/package.json

@@ -6,12 +6,13 @@
     "type": "module",
     "private": true,
     "scripts": {
-        "build": "tsc --noEmit && tsup-node",
+        "build": "tsc --noEmit && tsup-node && pnpm test:generate && pnpm test:typecheck",
         "watch": "tsup-node --watch",
         "lint": "eslint src --ext ts",
         "test": "vitest run",
         "pack": "pnpm pack",
-        "test:generate": "tsx scripts/generate.ts"
+        "test:generate": "tsx scripts/generate.ts",
+        "test:typecheck": "tsc --noEmit --project tsconfig.test.json"
     },
     "keywords": [
         "tanstack-query",

packages/clients/tanstack-query/scripts/generate.ts

@@ -16,12 +16,12 @@ async function main() {
 
 async function generate(schemaPath: string) {
     const generator = new TsSchemaGenerator();
-    const outputDir = path.dirname(schemaPath);
+    const outDir = path.dirname(schemaPath);
     const result = await loadDocument(schemaPath);
     if (!result.success) {
         throw new Error(`Failed to load schema from ${schemaPath}: ${result.errors}`);
     }
-    await generator.generate(result.model, outputDir);
+    await generator.generate(result.model, { outDir, liteOnly: true });
 }
 
 main();