@zenstackhq/cli 3.0.0-alpha.2 → 3.0.0-alpha.21

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

@@ -1,5 +1,7 @@
 import { ExpressionUtils } from '@zenstackhq/runtime/schema';
-import { generateTsSchema } from '@zenstackhq/testtools';
+import { createTestProject, generateTsSchema, generateTsSchemaInPlace } from '@zenstackhq/testtools';
+import fs from 'node:fs';
+import path from 'node:path';
 import { describe, expect, it } from 'vitest';
 
 describe('TypeScript schema generation tests', () => {
@@ -27,7 +29,6 @@ model Post {
 
         expect(schema.provider).toMatchObject({
             type: 'sqlite',
-            dialectConfigProvider: expect.any(Function),
         });
 
         expect(schema.models).toMatchObject({
@@ -182,4 +183,181 @@ model Post {
             },
         });
     });
+
+    it('merges fields and attributes from mixins', async () => {
+        const { schema } = await generateTsSchema(`
+type Timestamped {
+    createdAt DateTime @default(now())
+    updatedAt DateTime @updatedAt
+}
+
+type Named {
+    name String
+    @@unique([name])
+}
+    
+model User with Timestamped Named {
+    id String @id @default(uuid())
+    email String @unique
+}
+        `);
+        expect(schema).toMatchObject({
+            models: {
+                User: {
+                    fields: {
+                        id: { type: 'String' },
+                        email: { type: 'String' },
+                        createdAt: {
+                            type: 'DateTime',
+                            default: expect.objectContaining({ function: 'now', kind: 'call' }),
+                        },
+                        updatedAt: { type: 'DateTime', updatedAt: true },
+                        name: { type: 'String' },
+                    },
+                    uniqueFields: expect.objectContaining({
+                        name: { type: 'String' },
+                    }),
+                },
+            },
+        });
+    });
+
+    it('generates type definitions', async () => {
+        const { schema } = await generateTsSchema(`
+type Base {
+    name String
+    @@meta('foo', 'bar')
+}
+
+type Address with Base {
+    street String
+    city String
+}
+    `);
+        expect(schema).toMatchObject({
+            typeDefs: {
+                Base: {
+                    fields: {
+                        name: { type: 'String' },
+                    },
+                    attributes: [
+                        {
+                            name: '@@meta',
+                            args: [
+                                { name: 'name', value: { kind: 'literal', value: 'foo' } },
+                                { name: 'value', value: { kind: 'literal', value: 'bar' } },
+                            ],
+                        },
+                    ],
+                },
+                Address: {
+                    fields: {
+                        street: { type: 'String' },
+                        city: { type: 'String' },
+                    },
+                    attributes: [
+                        {
+                            name: '@@meta',
+                            args: [
+                                { name: 'name', value: { kind: 'literal', value: 'foo' } },
+                                { name: 'value', value: { kind: 'literal', value: 'bar' } },
+                            ],
+                        },
+                    ],
+                },
+            },
+        });
+    });
+
+    it('merges fields and attributes from base models', async () => {
+        const { schema } = await generateTsSchema(`
+model Base {
+    id String @id @default(uuid())
+    createdAt DateTime @default(now())
+    updatedAt DateTime @updatedAt
+    type String
+    @@delegate(type)
+}
+
+model User extends Base {
+    email String @unique
+}
+        `);
+        expect(schema).toMatchObject({
+            models: {
+                Base: {
+                    fields: {
+                        id: {
+                            type: 'String',
+                            id: true,
+                            default: expect.objectContaining({ function: 'uuid', kind: 'call' }),
+                        },
+                        createdAt: {
+                            type: 'DateTime',
+                            default: expect.objectContaining({ function: 'now', kind: 'call' }),
+                        },
+                        updatedAt: { type: 'DateTime', updatedAt: true },
+                        type: { type: 'String' },
+                    },
+                    attributes: [
+                        {
+                            name: '@@delegate',
+                            args: [{ name: 'discriminator', value: { kind: 'field', field: 'type' } }],
+                        },
+                    ],
+                    isDelegate: true,
+                },
+                User: {
+                    baseModel: 'Base',
+                    fields: {
+                        id: { type: 'String' },
+                        createdAt: {
+                            type: 'DateTime',
+                            default: expect.objectContaining({ function: 'now', kind: 'call' }),
+                            originModel: 'Base',
+                        },
+                        updatedAt: { type: 'DateTime', updatedAt: true, originModel: 'Base' },
+                        type: { type: 'String', originModel: 'Base' },
+                        email: { type: 'String' },
+                    },
+                    uniqueFields: expect.objectContaining({
+                        email: { type: 'String' },
+                    }),
+                },
+            },
+        });
+    });
+
+    it('merges all declarations from imported modules', async () => {
+        const workDir = createTestProject();
+        fs.writeFileSync(
+            path.join(workDir, 'a.zmodel'),
+            `
+        enum Role {
+          Admin
+          User
+        }
+          `,
+        );
+        fs.writeFileSync(
+            path.join(workDir, 'b.zmodel'),
+            `
+        import './a'
+
+        datasource db {
+            provider = 'sqlite'
+            url = 'file:./test.db'
+        }
+
+        model User {
+          id Int @id
+          role Role
+        }
+        `,
+        );
+
+        const { schema } = await generateTsSchemaInPlace(path.join(workDir, 'b.zmodel'));
+        expect(schema.enums).toMatchObject({ Role: expect.any(Object) });
+        expect(schema.models).toMatchObject({ User: expect.any(Object) });
+    });
 });

package/test/utils.ts

@@ -0,0 +1,23 @@
+import { createTestProject } from '@zenstackhq/testtools';
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const ZMODEL_PRELUDE = `datasource db {
+    provider = "sqlite"
+    url = "file:./dev.db"
+}
+`;
+
+export function createProject(zmodel: string, addPrelude = true) {
+    const workDir = createTestProject();
+    fs.mkdirSync(path.join(workDir, 'zenstack'), { recursive: true });
+    const schemaPath = path.join(workDir, 'zenstack/schema.zmodel');
+    fs.writeFileSync(schemaPath, addPrelude ? `${ZMODEL_PRELUDE}\n\n${zmodel}` : zmodel);
+    return workDir;
+}
+
+export function runCli(command: string, cwd: string) {
+    const cli = path.join(__dirname, '../dist/index.js');
+    execSync(`node ${cli} ${command}`, { cwd });
+}

package/test/validate.test.ts

@@ -0,0 +1,101 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { createProject, runCli } from './utils';
+
+const validModel = `
+model User {
+    id String @id @default(cuid())
+    email String @unique
+    name String?
+    posts Post[]
+}
+
+model Post {
+    id String @id @default(cuid())
+    title String
+    content String?
+    author User @relation(fields: [authorId], references: [id])
+    authorId String
+}
+`;
+
+const invalidModel = `
+model User {
+    id String @id @default(cuid())
+    email String @unique
+    posts Post[]
+}
+
+model Post {
+    id String @id @default(cuid())
+    title String
+    author User @relation(fields: [authorId], references: [id])
+    // Missing authorId field - should cause validation error
+}
+`;
+
+describe('CLI validate command test', () => {
+    it('should validate a valid schema successfully', () => {
+        const workDir = createProject(validModel);
+
+        // Should not throw an error
+        expect(() => runCli('validate', workDir)).not.toThrow();
+    });
+
+    it('should fail validation for invalid schema', () => {
+        const workDir = createProject(invalidModel);
+
+        // Should throw an error due to validation failure
+        expect(() => runCli('validate', workDir)).toThrow();
+    });
+
+    it('should respect custom schema location', () => {
+        const workDir = createProject(validModel);
+        fs.renameSync(path.join(workDir, 'zenstack/schema.zmodel'), path.join(workDir, 'zenstack/custom.zmodel'));
+
+        // Should not throw an error when using custom schema path
+        expect(() => runCli('validate --schema ./zenstack/custom.zmodel', workDir)).not.toThrow();
+    });
+
+    it('should fail when schema file does not exist', () => {
+        const workDir = createProject(validModel);
+
+        // Should throw an error when schema file doesn't exist
+        expect(() => runCli('validate --schema ./nonexistent.zmodel', workDir)).toThrow();
+    });
+
+    it('should respect package.json config', () => {
+        const workDir = createProject(validModel);
+        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/schema.zmodel',
+        };
+        fs.writeFileSync(path.join(workDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+
+        // Should not throw an error when using package.json config
+        expect(() => runCli('validate', workDir)).not.toThrow();
+    });
+
+    it('should validate schema with syntax errors', () => {
+        const modelWithSyntaxError = `
+datasource db {
+    provider = "sqlite"
+    url = "file:./dev.db"
+}
+
+model User {
+    id String @id @default(cuid())
+    email String @unique
+    // Missing closing brace - syntax error
+        `;
+        const workDir = createProject(modelWithSyntaxError, false);
+
+        // Should throw an error due to syntax error
+        expect(() => runCli('validate', workDir)).toThrow();
+    });
+});

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-    "extends": "../../tsconfig.json",
+    "extends": "@zenstackhq/typescript-config/base.json",
     "compilerOptions": {
         "outDir": "dist"
     },

package/vitest.config.ts

@@ -1,4 +1,4 @@
+import base from '@zenstackhq/vitest-config/base';
 import { defineConfig, mergeConfig } from 'vitest/config';
-import base from '../../vitest.base.config';
 
 export default mergeConfig(base, defineConfig({}));

package/.turbo/turbo-lint.log

@@ -1,18 +0,0 @@
-
-
-> zenstack@3.0.0-alpha.1 lint /Users/yiming/git/zenstack/zenstack-v3/packages/cli
-> eslint src --ext ts
-
-=============
-
-WARNING: You are currently running a version of TypeScript which is not officially supported by @typescript-eslint/typescript-estree.
-
-You may find that it works just fine, or you may not.
-
-SUPPORTED TYPESCRIPT VERSIONS: >=4.7.4 <5.5.0
-
-YOUR TYPESCRIPT VERSION: 5.7.3
-
-Please only submit bug reports when using the officially supported version.
-
-=============