@zenstackhq/cli 3.0.0-beta.2 → 3.0.0-beta.20

package/src/actions/init.ts

@@ -13,7 +13,7 @@ import { STARTER_ZMODEL } from './templates';
 export async function run(projectPath: string) {
     const packages = [
         { name: '@zenstackhq/cli@next', dev: true },
-        { name: '@zenstackhq/runtime@next', dev: false },
+        { name: '@zenstackhq/orm@next', dev: false },
     ];
     let pm = await detect();
     if (!pm) {

package/src/actions/migrate.ts

@@ -82,9 +82,12 @@ async function runDev(prismaSchemaFile: string, options: DevOptions) {
 
 async function runReset(prismaSchemaFile: string, options: ResetOptions) {
     try {
-        const cmd = ['prisma migrate reset', ` --schema "${prismaSchemaFile}"`, options.force ? ' --force' : ''].join(
-            '',
-        );
+        const cmd = [
+            'prisma migrate reset',
+            ` --schema "${prismaSchemaFile}"`,
+            ' --skip-generate',
+            options.force ? ' --force' : '',
+        ].join('');
 
         await execPackage(cmd);
     } catch (err) {

package/src/actions/templates.ts

@@ -26,7 +26,7 @@ model Post {
 }
 `;
 
-export const STARTER_MAIN_TS = `import { ZenStackClient } from '@zenstackhq/runtime';
+export const STARTER_MAIN_TS = `import { ZenStackClient } from '@zenstackhq/orm';
 import SQLite from 'better-sqlite3';
 import { SqliteDialect } from 'kysely';
 import { schema } from './zenstack/schema';

package/src/constants.ts

@@ -1,2 +1,5 @@
 // replaced at build time
 export const TELEMETRY_TRACKING_TOKEN = '<TELEMETRY_TRACKING_TOKEN>';
+
+// plugin-contributed model file name
+export const PLUGIN_MODULE_NAME = 'plugin.zmodel';

package/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);
 

package/src/plugins/prisma.ts

@@ -5,10 +5,10 @@ import path from 'node:path';
 const plugin: CliPlugin = {
     name: 'Prisma Schema Generator',
     statusText: 'Generating Prisma schema',
-    async generate({ model, schemaFile, defaultOutputPath, pluginOptions }) {
+    async generate({ model, defaultOutputPath, pluginOptions }) {
         let outFile = path.join(defaultOutputPath, 'schema.prisma');
         if (typeof pluginOptions['output'] === 'string') {
-            outFile = path.resolve(path.dirname(schemaFile), pluginOptions['output']);
+            outFile = path.resolve(defaultOutputPath, pluginOptions['output']);
             if (!fs.existsSync(path.dirname(outFile))) {
                 fs.mkdirSync(path.dirname(outFile), { recursive: true });
             }

package/src/plugins/typescript.ts

@@ -7,6 +7,7 @@ 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']);
@@ -14,7 +15,14 @@ const plugin: CliPlugin = {
                 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 });
     },
 };
 

package/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);
+    });
 });

package/test/plugins/prisma-plugin.test.ts

@@ -57,4 +57,25 @@ model User {
         runCli('generate', workDir);
         expect(fs.existsSync(path.join(workDir, 'prisma/schema.prisma'))).toBe(true);
     });
+
+    it('can generate a Prisma schema with custom output relative to zenstack.output', () => {
+        const workDir = createProject(`
+plugin prisma {
+    provider = '@core/prisma'
+    output = './schema.prisma'
+}
+
+model User {
+    id String @id @default(cuid())
+}
+`);
+
+        const pkgJson = JSON.parse(fs.readFileSync(path.join(workDir, 'package.json'), 'utf8'));
+        pkgJson.zenstack = {
+            output: './relative',
+        };
+        fs.writeFileSync(path.join(workDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+        runCli('generate', workDir);
+        expect(fs.existsSync(path.join(workDir, 'relative/schema.prisma'))).toBe(true);
+    });
 });

package/test/ts-schema-gen.test.ts

@@ -1,4 +1,4 @@
-import { ExpressionUtils } from '@zenstackhq/runtime/schema';
+import { ExpressionUtils } from '@zenstackhq/orm/schema';
 import { createTestProject, generateTsSchema, generateTsSchemaInPlace } from '@zenstackhq/testtools';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -360,4 +360,86 @@ model User extends Base {
         expect(schema.enums).toMatchObject({ Role: expect.any(Object) });
         expect(schema.models).toMatchObject({ User: expect.any(Object) });
     });
+
+    it('generates correct default literal function arguments', async () => {
+        const { schema } = await generateTsSchema(`
+model User {
+    id String @id @default(uuid(7))
+}
+        `);
+
+        expect(schema.models).toMatchObject({
+            User: {
+                name: 'User',
+                fields: {
+                    id: {
+                        name: 'id',
+                        type: 'String',
+                        id: true,
+                        attributes: [
+                            {
+                                name: '@id',
+                            },
+                            {
+                                name: '@default',
+                                args: [
+                                    {
+                                        name: 'value',
+                                        value: {
+                                            kind: 'call',
+                                            function: 'uuid',
+                                            args: [
+                                                {
+                                                    kind: 'literal',
+                                                    value: 7,
+                                                },
+                                            ],
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                        default: {
+                            kind: 'call',
+                            function: 'uuid',
+                            args: [
+                                {
+                                    kind: 'literal',
+                                    value: 7,
+                                },
+                            ],
+                        },
+                    },
+                },
+                idFields: ['id'],
+                uniqueFields: {
+                    id: {
+                        type: 'String',
+                    },
+                },
+            },
+        });
+    });
+
+    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();
+    });
 });

package/tsup.config.ts

@@ -1,5 +1,3 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import { defineConfig } from 'tsup';
 
 export default defineConfig({
@@ -12,19 +10,4 @@ export default defineConfig({
     clean: true,
     dts: true,
     format: ['esm', 'cjs'],
-    onSuccess: async () => {
-        if (!process.env['TELEMETRY_TRACKING_TOKEN']) {
-            return;
-        }
-        const filesToProcess = ['dist/index.js', 'dist/index.cjs'];
-        for (const file of filesToProcess) {
-            console.log(`Processing ${file} for telemetry token...`);
-            const content = fs.readFileSync(path.join(__dirname, file), 'utf-8');
-            const updatedContent = content.replace(
-                '<TELEMETRY_TRACKING_TOKEN>',
-                process.env['TELEMETRY_TRACKING_TOKEN'],
-            );
-            fs.writeFileSync(file, updatedContent, 'utf-8');
-        }
-    },
 });