@zenstackhq/cli 3.1.0 → 3.2.0

package/test/init.test.ts

@@ -1,14 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import tmp from 'tmp';
-import { describe, expect, it } from 'vitest';
-import { runCli } from './utils';
-
-// skipping due to timeout during CI
-describe.skip('Cli init command tests', () => {
-    it('should create a new project', () => {
-        const { name: workDir } = tmp.dirSync({ unsafeCleanup: true });
-        runCli('init', workDir);
-        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.zmodel'))).toBe(true);
-    });
-});

package/test/migrate.test.ts

@@ -1,72 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { createProject, runCli } from './utils';
-
-const model = `
-model User {
-    id String @id @default(cuid())
-}
-`;
-
-describe('CLI migrate commands test', () => {
-    it('should generate a database with migrate dev', () => {
-        const workDir = createProject(model);
-        runCli('migrate dev --name init', workDir);
-        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
-        expect(fs.existsSync(path.join(workDir, 'zenstack/migrations'))).toBe(true);
-    });
-
-    it('should reset the database with migrate reset', () => {
-        const workDir = createProject(model);
-        runCli('db push', workDir);
-        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
-        runCli('migrate reset --force', workDir);
-        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
-    });
-
-    it('should reset the database with migrate deploy', () => {
-        const workDir = createProject(model);
-        runCli('migrate dev --name init', workDir);
-        fs.rmSync(path.join(workDir, 'zenstack/dev.db'));
-        runCli('migrate deploy', workDir);
-        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
-    });
-
-    it('supports migrate status', () => {
-        const workDir = createProject(model);
-        runCli('migrate dev --name init', workDir);
-        runCli('migrate status', workDir);
-    });
-
-    it('supports migrate resolve', () => {
-        const workDir = createProject(model);
-        runCli('migrate dev --name init', workDir);
-
-        // find the migration record "timestamp_init"
-        const migrationRecords = fs.readdirSync(path.join(workDir, 'zenstack/migrations'));
-        const migration = migrationRecords.find((f) => f.endsWith('_init'));
-
-        // force a migration failure
-        fs.writeFileSync(path.join(workDir, 'zenstack/migrations', migration!, 'migration.sql'), 'invalid content');
-
-        // redeploy the migration, which will fail
-        fs.rmSync(path.join(workDir, 'zenstack/dev.db'), { force: true });
-        try {
-            runCli('migrate deploy', workDir);
-        } catch {
-            // noop
-        }
-
-        // --rolled-back
-        runCli(`migrate resolve --rolled-back ${migration}`, workDir);
-
-        // --applied
-        runCli(`migrate resolve --applied ${migration}`, workDir);
-    });
-
-    it('should throw error when neither applied nor rolled-back is provided', () => {
-        const workDir = createProject(model);
-        expect(() => runCli('migrate resolve', workDir)).toThrow();
-    });
-});

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

@@ -1,50 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { createProject, runCli } from '../utils';
-import { execSync } from 'node:child_process';
-
-describe('Custom plugins tests', () => {
-    it('runs custom plugin generator', () => {
-        const workDir = createProject(`
-plugin custom {
-    provider = '../my-plugin.js'
-    output = '../custom-output'
-}
-
-model User {
-    id String @id @default(cuid())
-}
-`);
-
-        fs.writeFileSync(
-            path.join(workDir, 'my-plugin.ts'),
-            `
-import type { CliPlugin } from '@zenstackhq/sdk';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const plugin: CliPlugin = {
-    name: 'Custom Generator',
-    statusText: 'Generating foo.txt',
-    async generate({ model, defaultOutputPath, pluginOptions }) {
-        let outDir = defaultOutputPath;
-        if (typeof pluginOptions['output'] === 'string') {
-            outDir = path.resolve(defaultOutputPath, pluginOptions['output']);
-            if (!fs.existsSync(outDir)) {
-                fs.mkdirSync(outDir, { recursive: true });
-            }
-        }
-        fs.writeFileSync(path.join(outDir, 'foo.txt'), 'from my plugin');
-    },
-};
-
-export default plugin;
-`,
-        );
-
-        execSync('npx tsc', { cwd: workDir });
-        runCli('generate', workDir);
-        expect(fs.existsSync(path.join(workDir, 'custom-output/foo.txt'))).toBe(true);
-    });
-});

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

@@ -1,81 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { createProject, runCli } from '../utils';
-
-describe('Core plugins tests', () => {
-    it('can automatically generate a TypeScript schema with default output', () => {
-        const workDir = createProject(`
-model User {
-    id String @id @default(cuid())
-}
-`);
-        runCli('generate', workDir);
-        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.ts'))).toBe(true);
-    });
-
-    it('can automatically generate a TypeScript schema with custom output', () => {
-        const workDir = createProject(`
-plugin typescript {
-    provider = '@core/typescript'
-    output = '../generated-schema'
-}
-
-model User {
-    id String @id @default(cuid())
-}
-`);
-        runCli('generate', workDir);
-        expect(fs.existsSync(path.join(workDir, 'generated-schema/schema.ts'))).toBe(true);
-    });
-
-    it('can generate a Prisma schema with default output', () => {
-        const workDir = createProject(`
-plugin prisma {
-    provider = '@core/prisma'
-}
-
-model User {
-    id String @id @default(cuid())
-}
-`);
-        runCli('generate', workDir);
-        expect(fs.existsSync(path.join(workDir, 'zenstack/schema.prisma'))).toBe(true);
-    });
-
-    it('can generate a Prisma schema with custom output', () => {
-        const workDir = createProject(`
-plugin prisma {
-    provider = '@core/prisma'
-    output = '../prisma/schema.prisma'
-}
-
-model User {
-    id String @id @default(cuid())
-}
-`);
-        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,445 +0,0 @@
-import { ExpressionUtils } from '@zenstackhq/orm/schema';
-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', () => {
-    it('generates correct data models', async () => {
-        const { schema } = await generateTsSchema(`
-model User {
-    id String @id @default(uuid())
-    name String
-    email String @unique
-    createdAt DateTime @default(now())
-    updatedAt DateTime @updatedAt
-    posts Post[]
-
-    @@map('users')
-}
-
-model Post {
-    id String @id @default(cuid())
-    title String
-    published Boolean @default(false)
-    author User @relation(fields: [authorId], references: [id], onDelete: Cascade)
-    authorId String
-}
-            `);
-
-        expect(schema.provider).toMatchObject({
-            type: 'sqlite',
-        });
-
-        expect(schema.models).toMatchObject({
-            User: {
-                fields: {
-                    id: {
-                        type: 'String',
-                        id: true,
-                        default: ExpressionUtils.call('uuid'),
-                        attributes: [
-                            { name: '@id' },
-                            {
-                                name: '@default',
-                                args: [
-                                    {
-                                        value: {
-                                            kind: 'call',
-                                            function: 'uuid',
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                    name: { type: 'String' },
-                    email: { type: 'String', unique: true },
-                    createdAt: {
-                        type: 'DateTime',
-                        default: ExpressionUtils.call('now'),
-                        attributes: [
-                            {
-                                name: '@default',
-                                args: [
-                                    {
-                                        value: {
-                                            kind: 'call',
-                                            function: 'now',
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                    updatedAt: {
-                        type: 'DateTime',
-                        attributes: [
-                            {
-                                name: '@updatedAt',
-                            },
-                        ],
-                        updatedAt: true,
-                    },
-                    posts: {
-                        type: 'Post',
-                        array: true,
-                        relation: {
-                            opposite: 'author',
-                        },
-                    },
-                },
-                attributes: [
-                    {
-                        name: '@@map',
-                        args: [{ name: 'name', value: { kind: 'literal' } }],
-                    },
-                ],
-                idFields: ['id'],
-                uniqueFields: {
-                    id: { type: 'String' },
-                    email: { type: 'String' },
-                },
-            },
-            Post: {
-                fields: {
-                    id: {
-                        type: 'String',
-                        id: true,
-                        default: ExpressionUtils.call('cuid'),
-                        attributes: [
-                            { name: '@id' },
-                            {
-                                name: '@default',
-                                args: [
-                                    {
-                                        value: {
-                                            kind: 'call',
-                                            function: 'cuid',
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                    title: { type: 'String' },
-                    published: {
-                        type: 'Boolean',
-                        default: false,
-                    },
-                    authorId: { type: 'String' },
-                    author: {
-                        type: 'User',
-                        relation: {
-                            fields: ['authorId'],
-                            references: ['id'],
-                            onDelete: 'Cascade',
-                            opposite: 'posts',
-                        },
-                        attributes: [
-                            {
-                                name: '@relation',
-                                args: [
-                                    {
-                                        name: 'fields',
-                                        value: {
-                                            kind: 'array',
-                                            items: [
-                                                {
-                                                    kind: 'field',
-                                                    field: 'authorId',
-                                                },
-                                            ],
-                                        },
-                                    },
-                                    {
-                                        name: 'references',
-                                        value: {
-                                            kind: 'array',
-                                            items: [
-                                                {
-                                                    kind: 'field',
-                                                    field: 'id',
-                                                },
-                                            ],
-                                        },
-                                    },
-                                    {
-                                        name: 'onDelete',
-                                        value: {
-                                            kind: 'literal',
-                                            value: 'Cascade',
-                                        },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                },
-                idFields: ['id'],
-                uniqueFields: {
-                    id: { type: 'String' },
-                },
-            },
-        });
-    });
-
-    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) });
-    });
-
-    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/test/utils.ts

@@ -1,23 +0,0 @@
-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/tsconfig.json

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