@zenstackhq/cli 3.0.0-alpha.4 → 3.0.0-alpha.7

package/src/actions/action-utils.ts

@@ -1,7 +1,9 @@
-import fs from 'node:fs';
-import { CliError } from '../cli-error';
 import { loadDocument } from '@zenstackhq/language';
+import { PrismaSchemaGenerator } from '@zenstackhq/sdk';
 import colors from 'colors';
+import fs from 'node:fs';
+import path from 'node:path';
+import { CliError } from '../cli-error';
 
 export function getSchemaFile(file?: string) {
     if (file) {
@@ -17,7 +19,7 @@ export function getSchemaFile(file?: string) {
         return './schema.zmodel';
     } else {
         throw new CliError(
-            'Schema file not found in default locations ("./zenstack/schema.zmodel" or "./schema.zmodel").'
+            'Schema file not found in default locations ("./zenstack/schema.zmodel" or "./schema.zmodel").',
         );
     }
 }
@@ -35,13 +37,17 @@ export async function loadSchemaDocument(schemaFile: string) {
 }
 
 export function handleSubProcessError(err: unknown) {
-    if (
-        err instanceof Error &&
-        'status' in err &&
-        typeof err.status === 'number'
-    ) {
+    if (err instanceof Error && 'status' in err && typeof err.status === 'number') {
         process.exit(err.status);
     } else {
         process.exit(1);
     }
 }
+
+export async function generateTempPrismaSchema(zmodelPath: string) {
+    const model = await loadSchemaDocument(zmodelPath);
+    const prismaSchema = await new PrismaSchemaGenerator(model).generate();
+    const prismaSchemaFile = path.resolve(path.dirname(zmodelPath), '~schema.prisma');
+    fs.writeFileSync(prismaSchemaFile, prismaSchema);
+    return prismaSchemaFile;
+}

package/src/actions/db.ts

@@ -1,46 +1,44 @@
-import path from 'node:path';
+import fs from 'node:fs';
 import { execPackage } from '../utils/exec-utils';
-import { getSchemaFile, handleSubProcessError } from './action-utils';
-import { run as runGenerate } from './generate';
+import { generateTempPrismaSchema, getSchemaFile, handleSubProcessError } from './action-utils';
 
-type CommonOptions = {
+type Options = {
     schema?: string;
-    name?: string;
+    acceptDataLoss?: boolean;
+    forceReset?: boolean;
 };
 
 /**
  * CLI action for db related commands
  */
-export async function run(command: string, options: CommonOptions) {
-    const schemaFile = getSchemaFile(options.schema);
-
-    // run generate first
-    await runGenerate({
-        schema: schemaFile,
-        silent: true,
-    });
-
-    const prismaSchemaFile = path.join(
-        path.dirname(schemaFile),
-        'schema.prisma'
-    );
-
+export async function run(command: string, options: Options) {
     switch (command) {
         case 'push':
-            await runPush(prismaSchemaFile, options);
+            await runPush(options);
             break;
     }
 }
 
-async function runPush(prismaSchemaFile: string, options: any) {
-    const cmd = `prisma db push --schema "${prismaSchemaFile}"${
-        options.acceptDataLoss ? ' --accept-data-loss' : ''
-    }${options.forceReset ? ' --force-reset' : ''} --skip-generate`;
+async function runPush(options: Options) {
+    // generate a temp prisma schema file
+    const schemaFile = getSchemaFile(options.schema);
+    const prismaSchemaFile = await generateTempPrismaSchema(schemaFile);
+
     try {
-        await execPackage(cmd, {
-            stdio: 'inherit',
-        });
-    } catch (err) {
-        handleSubProcessError(err);
+        // run prisma db push
+        const cmd = `prisma db push --schema "${prismaSchemaFile}"${
+            options.acceptDataLoss ? ' --accept-data-loss' : ''
+        }${options.forceReset ? ' --force-reset' : ''} --skip-generate`;
+        try {
+            await execPackage(cmd, {
+                stdio: 'inherit',
+            });
+        } catch (err) {
+            handleSubProcessError(err);
+        }
+    } finally {
+        if (fs.existsSync(prismaSchemaFile)) {
+            fs.unlinkSync(prismaSchemaFile);
+        }
     }
 }

package/src/actions/generate.ts

@@ -1,16 +1,16 @@
+import { invariant } from '@zenstackhq/common-helpers';
 import { isPlugin, LiteralExpr, type Model } from '@zenstackhq/language/ast';
-import type { CliGenerator } from '@zenstackhq/runtime/client';
-import { PrismaSchemaGenerator, TsSchemaGenerator } from '@zenstackhq/sdk';
+import { PrismaSchemaGenerator, TsSchemaGenerator, type CliGenerator } from '@zenstackhq/sdk';
 import colors from 'colors';
 import fs from 'node:fs';
 import path from 'node:path';
-import invariant from 'tiny-invariant';
 import { getSchemaFile, loadSchemaDocument } from './action-utils';
 
 type Options = {
     schema?: string;
     output?: string;
     silent?: boolean;
+    savePrismaSchema?: string | boolean;
 };
 
 /**
@@ -29,8 +29,15 @@ export async function run(options: Options) {
     await runPlugins(model, outputPath, tsSchemaFile);
 
     // generate Prisma schema
-    const prismaSchema = await new PrismaSchemaGenerator(model).generate();
-    fs.writeFileSync(path.join(outputPath, 'schema.prisma'), prismaSchema);
+    if (options.savePrismaSchema) {
+        const prismaSchema = await new PrismaSchemaGenerator(model).generate();
+        let prismaSchemaFile = path.join(outputPath, 'schema.prisma');
+        if (typeof options.savePrismaSchema === 'string') {
+            prismaSchemaFile = path.resolve(outputPath, options.savePrismaSchema);
+            fs.mkdirSync(path.dirname(prismaSchemaFile), { recursive: true });
+        }
+        fs.writeFileSync(prismaSchemaFile, prismaSchema);
+    }
 
     if (!options.silent) {
         console.log(colors.green('Generation completed successfully.'));
@@ -41,25 +48,18 @@ import { ZenStackClient } from '@zenstackhq/runtime';
 import { schema } from '${outputPath}/schema';
 
 const client = new ZenStackClient(schema, {
-    dialectConfig: { ... } 
+    dialectConfig: { ... }
 });
 \`\`\`
 `);
     }
 }
 
-async function runPlugins(
-    model: Model,
-    outputPath: string,
-    tsSchemaFile: string
-) {
+async function runPlugins(model: Model, outputPath: string, tsSchemaFile: string) {
     const plugins = model.declarations.filter(isPlugin);
     for (const plugin of plugins) {
         const providerField = plugin.fields.find((f) => f.name === 'provider');
-        invariant(
-            providerField,
-            `Plugin ${plugin.name} does not have a provider field`
-        );
+        invariant(providerField, `Plugin ${plugin.name} does not have a provider field`);
         const provider = (providerField.value as LiteralExpr).value as string;
         let useProvider = provider;
         if (useProvider.startsWith('@core/')) {

package/src/actions/info.ts

@@ -7,9 +7,7 @@ import path from 'node:path';
 export async function run(projectPath: string) {
     const packages = await getZenStackPackages(projectPath);
     if (!packages) {
-        console.error(
-            'Unable to locate package.json. Are you in a valid project directory?'
-        );
+        console.error('Unable to locate package.json. Are you in a valid project directory?');
         return;
     }
 
@@ -23,17 +21,11 @@ export async function run(projectPath: string) {
     }
 
     if (versions.size > 1) {
-        console.warn(
-            colors.yellow(
-                'WARNING: Multiple versions of Zenstack packages detected. This may cause issues.'
-            )
-        );
+        console.warn(colors.yellow('WARNING: Multiple versions of Zenstack packages detected. This may cause issues.'));
     }
 }
 
-async function getZenStackPackages(
-    projectPath: string
-): Promise<Array<{ pkg: string; version: string | undefined }>> {
+async function getZenStackPackages(projectPath: string): Promise<Array<{ pkg: string; version: string | undefined }>> {
     let pkgJson: {
         dependencies: Record<string, unknown>;
         devDependencies: Record<string, unknown>;
@@ -45,17 +37,16 @@ async function getZenStackPackages(
                 with: { type: 'json' },
             })
         ).default;
-    } catch (err) {
+    } catch {
         return [];
     }
 
     const packages = Array.from(
         new Set(
-            [
-                ...Object.keys(pkgJson.dependencies ?? {}),
-                ...Object.keys(pkgJson.devDependencies ?? {}),
-            ].filter((p) => p.startsWith('@zenstackhq/') || p === 'zenstack')
-        )
+            [...Object.keys(pkgJson.dependencies ?? {}), ...Object.keys(pkgJson.devDependencies ?? {})].filter(
+                (p) => p.startsWith('@zenstackhq/') || p === 'zenstack',
+            ),
+        ),
     ).sort();
 
     const result = await Promise.all(
@@ -70,7 +61,7 @@ async function getZenStackPackages(
             } catch {
                 return { pkg, version: undefined };
             }
-        })
+        }),
     );
 
     return result;

package/src/actions/init.ts

@@ -28,9 +28,7 @@ export async function run(projectPath: string) {
             ...(pkg.dev ? [pm.agent === 'yarn' ? '--dev' : '--save-dev'] : []),
         ]);
         if (!resolved) {
-            throw new CliError(
-                `Unable to determine how to install package "${pkg.name}". Please install it manually.`
-            );
+            throw new CliError(`Unable to determine how to install package "${pkg.name}". Please install it manually.`);
         }
 
         const spinner = ora(`Installing "${pkg.name}"`).start();
@@ -51,32 +49,13 @@ export async function run(projectPath: string) {
         fs.mkdirSync(path.join(projectPath, generationFolder));
     }
 
-    if (
-        !fs.existsSync(
-            path.join(projectPath, generationFolder, 'schema.zmodel')
-        )
-    ) {
-        fs.writeFileSync(
-            path.join(projectPath, generationFolder, 'schema.zmodel'),
-            STARTER_ZMODEL
-        );
+    if (!fs.existsSync(path.join(projectPath, generationFolder, 'schema.zmodel'))) {
+        fs.writeFileSync(path.join(projectPath, generationFolder, 'schema.zmodel'), STARTER_ZMODEL);
     } else {
-        console.log(
-            colors.yellow(
-                'Schema file already exists. Skipping generation of sample.'
-            )
-        );
+        console.log(colors.yellow('Schema file already exists. Skipping generation of sample.'));
     }
 
     console.log(colors.green('ZenStack project initialized successfully!'));
-    console.log(
-        colors.gray(
-            `See "${generationFolder}/schema.zmodel" for your database schema.`
-        )
-    );
-    console.log(
-        colors.gray(
-            'Run `zenstack generate` to compile the the schema into a TypeScript file.'
-        )
-    );
+    console.log(colors.gray(`See "${generationFolder}/schema.zmodel" for your database schema.`));
+    console.log(colors.gray('Run `zenstack generate` to compile the the schema into a TypeScript file.'));
 }

package/src/actions/migrate.ts

@@ -1,109 +1,101 @@
-import path from 'node:path';
+import fs from 'node:fs';
 import { execPackage } from '../utils/exec-utils';
-import { getSchemaFile } from './action-utils';
-import { run as runGenerate } from './generate';
+import { generateTempPrismaSchema, getSchemaFile } from './action-utils';
 
 type CommonOptions = {
     schema?: string;
+};
+
+type DevOptions = CommonOptions & {
     name?: string;
+    createOnly?: boolean;
+};
+
+type ResetOptions = CommonOptions & {
+    force?: boolean;
 };
 
+type DeployOptions = CommonOptions;
+
+type StatusOptions = CommonOptions;
+
 /**
  * CLI action for migration-related commands
  */
 export async function run(command: string, options: CommonOptions) {
     const schemaFile = getSchemaFile(options.schema);
+    const prismaSchemaFile = await generateTempPrismaSchema(schemaFile);
 
-    // run generate first
-    await runGenerate({
-        schema: schemaFile,
-        silent: true,
-    });
-
-    const prismaSchemaFile = path.join(
-        path.dirname(schemaFile),
-        'schema.prisma'
-    );
-
-    switch (command) {
-        case 'dev':
-            await runDev(prismaSchemaFile, options);
-            break;
+    try {
+        switch (command) {
+            case 'dev':
+                await runDev(prismaSchemaFile, options as DevOptions);
+                break;
 
-        case 'reset':
-            await runReset(prismaSchemaFile, options as any);
-            break;
+            case 'reset':
+                await runReset(prismaSchemaFile, options as ResetOptions);
+                break;
 
-        case 'deploy':
-            await runDeploy(prismaSchemaFile, options);
-            break;
+            case 'deploy':
+                await runDeploy(prismaSchemaFile, options as DeployOptions);
+                break;
 
-        case 'status':
-            await runStatus(prismaSchemaFile, options);
-            break;
+            case 'status':
+                await runStatus(prismaSchemaFile, options as StatusOptions);
+                break;
+        }
+    } finally {
+        if (fs.existsSync(prismaSchemaFile)) {
+            fs.unlinkSync(prismaSchemaFile);
+        }
     }
 }
 
-async function runDev(prismaSchemaFile: string, _options: unknown) {
+async function runDev(prismaSchemaFile: string, options: DevOptions) {
     try {
         await execPackage(
-            `prisma migrate dev --schema "${prismaSchemaFile}" --skip-generate`,
+            `prisma migrate dev --schema "${prismaSchemaFile}" --skip-generate${options.name ? ` --name ${options.name}` : ''}${options.createOnly ? ' --create-only' : ''}`,
             {
                 stdio: 'inherit',
-            }
+            },
         );
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
-async function runReset(prismaSchemaFile: string, options: { force: boolean }) {
+async function runReset(prismaSchemaFile: string, options: ResetOptions) {
     try {
-        await execPackage(
-            `prisma migrate reset --schema "${prismaSchemaFile}"${
-                options.force ? ' --force' : ''
-            }`,
-            {
-                stdio: 'inherit',
-            }
-        );
+        await execPackage(`prisma migrate reset --schema "${prismaSchemaFile}"${options.force ? ' --force' : ''}`, {
+            stdio: 'inherit',
+        });
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
-async function runDeploy(prismaSchemaFile: string, _options: unknown) {
+async function runDeploy(prismaSchemaFile: string, _options: DeployOptions) {
     try {
-        await execPackage(
-            `prisma migrate deploy --schema "${prismaSchemaFile}"`,
-            {
-                stdio: 'inherit',
-            }
-        );
+        await execPackage(`prisma migrate deploy --schema "${prismaSchemaFile}"`, {
+            stdio: 'inherit',
+        });
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
-async function runStatus(prismaSchemaFile: string, _options: unknown) {
+async function runStatus(prismaSchemaFile: string, _options: StatusOptions) {
     try {
-        await execPackage(
-            `prisma migrate status --schema "${prismaSchemaFile}"`,
-            {
-                stdio: 'inherit',
-            }
-        );
+        await execPackage(`prisma migrate status --schema "${prismaSchemaFile}"`, {
+            stdio: 'inherit',
+        });
     } catch (err) {
         handleSubProcessError(err);
     }
 }
 
 function handleSubProcessError(err: unknown) {
-    if (
-        err instanceof Error &&
-        'status' in err &&
-        typeof err.status === 'number'
-    ) {
+    if (err instanceof Error && 'status' in err && typeof err.status === 'number') {
         process.exit(err.status);
     } else {
         process.exit(1);

package/src/index.ts

@@ -4,9 +4,7 @@ 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> => {
+const generateAction = async (options: Parameters<typeof actions.generate>[0]): Promise<void> => {
     await actions.generate(options);
 };
 
@@ -36,60 +34,52 @@ export function createProgram() {
     program
         .description(
             `${colors.bold.blue(
-                'ζ'
-            )} ZenStack is a Prisma power pack for building full-stack apps.\n\nDocumentation: https://zenstack.dev.`
+                'ζ',
+            )} 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.`
+        `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('--silent', 'do not print any output'))
         .addOption(
             new Option(
-                '-o, --output <path>',
-                'default output directory for core plugins'
-            )
+                '--save-prisma-schema [path]',
+                'save a Prisma schema file, by default into the output directory',
+            ),
         )
+        .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.');
+    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.'
-        )
+        .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.'
-        )
+        .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.'
-        )
+        .description('Deploy your pending migrations to your production/staging database.')
         .action((options) => migrateAction('deploy', options));
 
     migrateCommand
@@ -98,30 +88,19 @@ export function createProgram() {
         .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.');
+    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'
-            )
-        )
+        .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.'
-        )
+        .description('Get information of installed ZenStack and related packages.')
         .argument('[path]', 'project path', '.')
         .action(infoAction);
 

package/src/utils/exec-utils.ts

@@ -3,10 +3,7 @@ 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 {
+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, {
@@ -22,7 +19,7 @@ export function execSync(
  */
 export function execPackage(
     cmd: string,
-    options?: Omit<ExecSyncOptions, 'env'> & { env?: Record<string, 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

@@ -1,13 +1,13 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-export function getVersion(): string | undefined {
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function getVersion() {
     try {
-        return require('../package.json').version;
+        // isomorphic __dirname
+        const _dirname = typeof __dirname !== 'undefined' ? __dirname : path.dirname(fileURLToPath(import.meta.url));
+        return JSON.parse(fs.readFileSync(path.join(_dirname, '../package.json'), 'utf8')).version;
     } catch {
-        try {
-            // dev environment
-            return require('../../package.json').version;
-        } catch {
-            return undefined;
-        }
+        return undefined;
     }
 }

package/test/db.test.ts

@@ -0,0 +1,18 @@
+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 db commands test', () => {
+    it('should generate a database with db push', () => {
+        const workDir = createProject(model);
+        runCli('db push', workDir);
+        expect(fs.existsSync(path.join(workDir, 'zenstack/dev.db'))).toBe(true);
+    });
+});