@zenstackhq/cli 3.0.0-alpha.8 → 3.0.0-beta.1

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', () => {
@@ -181,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/tsconfig.json

@@ -1,7 +1,4 @@
 {
     "extends": "@zenstackhq/typescript-config/base.json",
-    "compilerOptions": {
-        "outDir": "dist"
-    },
     "include": ["src/**/*.ts"]
 }

package/tsup.config.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import { defineConfig } from 'tsup';
 
 export default defineConfig({
@@ -10,4 +12,19 @@ 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');
+        }
+    },
 });

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