feat(schema): add option for generating lite schema

Author: ymc9

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,19 @@ 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;
+
+        await new TsSchemaGenerator().generate(model, { outDir, lite });
     },
 };
 

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();