@zenstackhq/cli 3.0.0-beta.8 → 3.0.0

package/test/db.test.ts

@@ -15,4 +15,47 @@ describe('CLI db commands test', () => {
         runCli('db push', workDir);
         expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
     });
+
+    it('should seed the database with db seed with seed script', () => {
+        const workDir = createProject(model);
+        const pkgJson = JSON.parse(fs.readFileSync(path.join(workDir, 'package.json'), 'utf8'));
+        pkgJson.zenstack = {
+            seed: 'node seed.js',
+        };
+        fs.writeFileSync(path.join(workDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+        fs.writeFileSync(
+            path.join(workDir, 'seed.js'),
+            `
+import fs from 'node:fs';
+fs.writeFileSync('seed.txt', 'success');
+        `,
+        );
+
+        runCli('db seed', workDir);
+        expect(fs.readFileSync(path.join(workDir, 'seed.txt'), 'utf8')).toBe('success');
+    });
+
+    it('should seed the database after migrate reset', () => {
+        const workDir = createProject(model);
+        const pkgJson = JSON.parse(fs.readFileSync(path.join(workDir, 'package.json'), 'utf8'));
+        pkgJson.zenstack = {
+            seed: 'node seed.js',
+        };
+        fs.writeFileSync(path.join(workDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+        fs.writeFileSync(
+            path.join(workDir, 'seed.js'),
+            `
+import fs from 'node:fs';
+fs.writeFileSync('seed.txt', 'success');
+        `,
+        );
+
+        runCli('migrate reset --force', workDir);
+        expect(fs.readFileSync(path.join(workDir, 'seed.txt'), 'utf8')).toBe('success');
+    });
+
+    it('should skip seeding the database without seed script', () => {
+        const workDir = createProject(model);
+        runCli('db seed', workDir);
+    });
 });

package/test/format.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { createProject, runCli } from './utils';
+import fs from 'node:fs';
+
+const model = `
+model User {
+  id String @id @default(cuid())
+    email String @unique
+}
+`;
+
+describe('CLI format command test', () => {
+    it('should format a valid schema successfully', () => {
+        const workDir = createProject(model);
+        expect(() => runCli('format', workDir)).not.toThrow();
+        const updatedContent = fs.readFileSync(`${workDir}/zenstack/schema.zmodel`, 'utf-8');
+        expect(
+            updatedContent.includes(`model User {
+    id    String @id @default(cuid())
+    email String @unique
+}`),
+        ).toBeTruthy();
+    });
+
+    it('should silently ignore invalid schema', () => {
+        const invalidModel = `
+model User {
+  id String @id @default(cuid())
+`;
+        const workDir = createProject(invalidModel);
+        expect(() => runCli('format', workDir)).not.toThrow();
+    });
+});

package/test/generate.test.ts

@@ -44,4 +44,33 @@ describe('CLI generate command test', () => {
         runCli('generate', workDir);
         expect(fs.existsSync(path.join(workDir, 'bar/schema.ts'))).toBe(true);
     });
+
+    it('should respect package.json schema dir config', () => {
+        const workDir = createProject(model);
+        fs.mkdirSync(path.join(workDir, 'foo'));
+        fs.renameSync(path.join(workDir, 'zenstack/schema.zmodel'), path.join(workDir, 'foo/schema.zmodel'));
+        fs.rmdirSync(path.join(workDir, 'zenstack'));
+        const pkgJson = JSON.parse(fs.readFileSync(path.join(workDir, 'package.json'), 'utf8'));
+        pkgJson.zenstack = {
+            schema: './foo',
+            output: './bar',
+        };
+        fs.writeFileSync(path.join(workDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+        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/migrate.test.ts

@@ -9,8 +9,7 @@ model User {
 }
 `;
 
-// skip due to timeout in CI
-describe.skip('CLI migrate commands test', () => {
+describe('CLI migrate commands test', () => {
     it('should generate a database with migrate dev', () => {
         const workDir = createProject(model);
         runCli('migrate dev --name init', workDir);

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