@zenstackhq/cli 3.0.0-alpha.0

package/src/index.ts

@@ -0,0 +1,138 @@
+import { ZModelLanguageMetaData } from '@zenstackhq/language';
+import colors from 'colors';
+import { Command, Option } from 'commander';
+import * as actions from './actions';
+import { getVersion } from './utils/version-utils';
+
+const generateAction = async (
+    options: Parameters<typeof actions.generate>[0]
+): Promise<void> => {
+    await actions.generate(options);
+};
+
+const migrateAction = async (command: string, options: any): Promise<void> => {
+    await actions.migrate(command, options);
+};
+
+const dbAction = async (command: string, options: any): Promise<void> => {
+    await actions.db(command, options);
+};
+
+const infoAction = async (projectPath: string): Promise<void> => {
+    await actions.info(projectPath);
+};
+
+const initAction = async (projectPath: string): Promise<void> => {
+    await actions.init(projectPath);
+};
+
+export function createProgram() {
+    const program = new Command('zenstack');
+
+    program.version(getVersion()!, '-v --version', 'display CLI version');
+
+    const schemaExtensions = ZModelLanguageMetaData.fileExtensions.join(', ');
+
+    program
+        .description(
+            `${colors.bold.blue(
+                'ζ'
+            )} ZenStack is a Prisma power pack for building full-stack apps.\n\nDocumentation: https://zenstack.dev.`
+        )
+        .showHelpAfterError()
+        .showSuggestionAfterError();
+
+    const schemaOption = new Option(
+        '--schema <file>',
+        `schema file (with extension ${schemaExtensions}). Defaults to "schema.zmodel" unless specified in package.json.`
+    );
+
+    program
+        .command('generate')
+        .description('Run code generation.')
+        .addOption(schemaOption)
+        .addOption(
+            new Option(
+                '-o, --output <path>',
+                'default output directory for core plugins'
+            )
+        )
+        .action(generateAction);
+
+    const migrateCommand = program
+        .command('migrate')
+        .description('Update the database schema with migrations.');
+
+    migrateCommand
+        .command('dev')
+        .addOption(schemaOption)
+        .addOption(new Option('-n, --name <name>', 'migration name'))
+        .addOption(
+            new Option('--create-only', 'only create migration, do not apply')
+        )
+        .description(
+            'Create a migration from changes in schema and apply it to the database.'
+        )
+        .action((options) => migrateAction('dev', options));
+
+    migrateCommand
+        .command('reset')
+        .addOption(schemaOption)
+        .addOption(new Option('--force', 'skip the confirmation prompt'))
+        .description(
+            'Reset your database and apply all migrations, all data will be lost.'
+        )
+        .action((options) => migrateAction('reset', options));
+
+    migrateCommand
+        .command('deploy')
+        .addOption(schemaOption)
+        .description(
+            'Deploy your pending migrations to your production/staging database.'
+        )
+        .action((options) => migrateAction('deploy', options));
+
+    migrateCommand
+        .command('status')
+        .addOption(schemaOption)
+        .description('check the status of your database migrations.')
+        .action((options) => migrateAction('status', options));
+
+    const dbCommand = program
+        .command('db')
+        .description('Manage your database schema during development.');
+
+    dbCommand
+        .command('push')
+        .description('Push the state from your schema to your database')
+        .addOption(schemaOption)
+        .addOption(
+            new Option('--accept-data-loss', 'ignore data loss warnings')
+        )
+        .addOption(
+            new Option(
+                '--force-reset',
+                'force a reset of the database before push'
+            )
+        )
+        .action((options) => dbAction('push', options));
+
+    program
+        .command('info')
+        .description(
+            'Get information of installed ZenStack and related packages.'
+        )
+        .argument('[path]', 'project path', '.')
+        .action(infoAction);
+
+    program
+        .command('init')
+        .description('Initialize an existing project for ZenStack.')
+        .argument('[path]', 'project path', '.')
+        .action(initAction);
+
+    return program;
+}
+
+const program = createProgram();
+program.parse(process.argv);

package/src/utils/exec-utils.ts

@@ -0,0 +1,29 @@
+import { execSync as _exec, type ExecSyncOptions } from 'child_process';
+
+/**
+ * Utility for executing command synchronously and prints outputs on current console
+ */
+export function execSync(
+    cmd: string,
+    options?: Omit<ExecSyncOptions, 'env'> & { env?: Record<string, string> }
+): void {
+    const { env, ...restOptions } = options ?? {};
+    const mergedEnv = env ? { ...process.env, ...env } : undefined;
+    _exec(cmd, {
+        encoding: 'utf-8',
+        stdio: options?.stdio ?? 'inherit',
+        env: mergedEnv,
+        ...restOptions,
+    });
+}
+
+/**
+ * Utility for running package commands through npx/bunx
+ */
+export function execPackage(
+    cmd: string,
+    options?: Omit<ExecSyncOptions, 'env'> & { env?: Record<string, string> }
+): void {
+    const packageManager = process?.versions?.['bun'] ? 'bunx' : 'npx';
+    execSync(`${packageManager} ${cmd}`, options);
+}

package/src/utils/version-utils.ts

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+export function getVersion(): string | undefined {
+    try {
+        return require('../package.json').version;
+    } catch {
+        try {
+            // dev environment
+            return require('../../package.json').version;
+        } catch {
+            return undefined;
+        }
+    }
+}

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

@@ -0,0 +1,185 @@
+import { ExpressionUtils } from '@zenstackhq/runtime/schema';
+import { generateTsSchema } from '@zenstackhq/testtools';
+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',
+            dialectConfigProvider: expect.any(Function),
+        });
+
+        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' },
+                },
+            },
+        });
+    });
+});

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "dist"
+    },
+    "include": ["src/**/*.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: {
+        index: 'src/index.ts',
+    },
+    outDir: 'dist',
+    splitting: false,
+    sourcemap: true,
+    clean: true,
+    dts: true,
+    format: ['esm', 'cjs'],
+});

package/vitest.config.ts

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