@zenstackhq/cli 3.1.1 → 3.2.0

package/src/actions/migrate.ts

@@ -1,149 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { CliError } from '../cli-error';
-import { execPrisma } from '../utils/exec-utils';
-import { generateTempPrismaSchema, getSchemaFile, requireDataSourceUrl } from './action-utils';
-import { run as runSeed } from './seed';
-
-type CommonOptions = {
-    schema?: string;
-    migrations?: string;
-    skipSeed?: boolean;
-};
-
-type DevOptions = CommonOptions & {
-    name?: string;
-    createOnly?: boolean;
-};
-
-type ResetOptions = CommonOptions & {
-    force?: boolean;
-};
-
-type DeployOptions = CommonOptions;
-
-type StatusOptions = CommonOptions;
-
-type ResolveOptions = CommonOptions & {
-    applied?: string;
-    rolledBack?: string;
-};
-
-/**
- * CLI action for migration-related commands
- */
-export async function run(command: string, options: CommonOptions) {
-    const schemaFile = getSchemaFile(options.schema);
-
-    // validate datasource url exists
-    await requireDataSourceUrl(schemaFile);
-
-    const prismaSchemaDir = options.migrations ? path.dirname(options.migrations) : undefined;
-    const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
-
-    try {
-        switch (command) {
-            case 'dev':
-                await runDev(prismaSchemaFile, options as DevOptions);
-                break;
-
-            case 'reset':
-                await runReset(prismaSchemaFile, options as ResetOptions);
-                break;
-
-            case 'deploy':
-                await runDeploy(prismaSchemaFile, options as DeployOptions);
-                break;
-
-            case 'status':
-                await runStatus(prismaSchemaFile, options as StatusOptions);
-                break;
-
-            case 'resolve':
-                await runResolve(prismaSchemaFile, options as ResolveOptions);
-                break;
-        }
-    } finally {
-        if (fs.existsSync(prismaSchemaFile)) {
-            fs.unlinkSync(prismaSchemaFile);
-        }
-    }
-}
-
-function runDev(prismaSchemaFile: string, options: DevOptions) {
-    try {
-        const cmd = [
-            'migrate dev',
-            ` --schema "${prismaSchemaFile}"`,
-            ' --skip-generate',
-            ' --skip-seed',
-            options.name ? ` --name "${options.name}"` : '',
-            options.createOnly ? ' --create-only' : '',
-        ].join('');
-        execPrisma(cmd);
-    } catch (err) {
-        handleSubProcessError(err);
-    }
-}
-
-async function runReset(prismaSchemaFile: string, options: ResetOptions) {
-    try {
-        const cmd = [
-            'migrate reset',
-            ` --schema "${prismaSchemaFile}"`,
-            ' --skip-generate',
-            ' --skip-seed',
-            options.force ? ' --force' : '',
-        ].join('');
-        execPrisma(cmd);
-    } catch (err) {
-        handleSubProcessError(err);
-    }
-
-    if (!options.skipSeed) {
-        await runSeed({ noWarnings: true, printStatus: true }, []);
-    }
-}
-
-function runDeploy(prismaSchemaFile: string, _options: DeployOptions) {
-    try {
-        const cmd = ['migrate deploy', ` --schema "${prismaSchemaFile}"`].join('');
-        execPrisma(cmd);
-    } catch (err) {
-        handleSubProcessError(err);
-    }
-}
-
-function runStatus(prismaSchemaFile: string, _options: StatusOptions) {
-    try {
-        execPrisma(`migrate status --schema "${prismaSchemaFile}"`);
-    } catch (err) {
-        handleSubProcessError(err);
-    }
-}
-
-function runResolve(prismaSchemaFile: string, options: ResolveOptions) {
-    if (!options.applied && !options.rolledBack) {
-        throw new CliError('Either --applied or --rolled-back option must be provided');
-    }
-
-    try {
-        const cmd = [
-            'migrate resolve',
-            ` --schema "${prismaSchemaFile}"`,
-            options.applied ? ` --applied "${options.applied}"` : '',
-            options.rolledBack ? ` --rolled-back "${options.rolledBack}"` : '',
-        ].join('');
-        execPrisma(cmd);
-    } catch (err) {
-        handleSubProcessError(err);
-    }
-}
-
-function handleSubProcessError(err: unknown) {
-    if (err instanceof Error && 'status' in err && typeof err.status === 'number') {
-        process.exit(err.status);
-    } else {
-        process.exit(1);
-    }
-}

package/src/actions/seed.ts

@@ -1,38 +0,0 @@
-import colors from 'colors';
-import { execaCommand } from 'execa';
-import { CliError } from '../cli-error';
-import { getPkgJsonConfig } from './action-utils';
-
-type Options = {
-    noWarnings?: boolean;
-    printStatus?: boolean;
-};
-
-/**
- * CLI action for seeding the database.
- */
-export async function run(options: Options, args: string[]) {
-    const pkgJsonConfig = getPkgJsonConfig(process.cwd());
-    if (!pkgJsonConfig.seed) {
-        if (!options.noWarnings) {
-            console.warn(colors.yellow('No seed script defined in package.json. Skipping seeding.'));
-        }
-        return;
-    }
-
-    const command = `${pkgJsonConfig.seed}${args.length > 0 ? ' ' + args.join(' ') : ''}`;
-
-    if (options.printStatus) {
-        console.log(colors.gray(`Running seed script "${command}"...`));
-    }
-
-    try {
-        await execaCommand(command, {
-            stdout: 'inherit',
-            stderr: 'inherit',
-        });
-    } catch (err) {
-        console.error(colors.red(err instanceof Error ? err.message : String(err)));
-        throw new CliError('Failed to seed the database. Please check the error message above for details.');
-    }
-}

package/src/actions/templates.ts

@@ -1,58 +0,0 @@
-export const STARTER_ZMODEL = `// This is a sample model to get you started.
-
-/// A sample data source using local sqlite db.
-datasource db {
-    provider = 'sqlite'
-    url = 'file:./dev.db'
-}
-
-/// User model
-model User {
-    id       String @id @default(cuid())
-    email    String @unique @email @length(6, 32)
-    posts    Post[]
-}
-
-/// Post model
-model Post {
-    id        String   @id @default(cuid())
-    createdAt DateTime @default(now())
-    updatedAt DateTime @updatedAt
-    title     String   @length(1, 256)
-    content   String
-    published Boolean  @default(false)
-    author    User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
-    authorId  String
-}
-`;
-
-export const STARTER_MAIN_TS = `import { ZenStackClient } from '@zenstackhq/orm';
-import { SqliteDialect } from '@zenstackhq/orm/dialects/sqlite';
-import SQLite from 'better-sqlite3';
-import { schema } from './zenstack/schema';
-
-async function main() {
-    const db = new ZenStackClient(schema, {
-        dialect: new SqliteDialect({
-            database: new SQLite('./zenstack/dev.db'),
-        }),
-    });
-    const user = await db.user.create({
-        data: {
-            email: 'test@zenstack.dev',
-            posts: {
-                create: [
-                    {
-                        title: 'Hello World',
-                        content: 'This is a test post',
-                    },
-                ],
-            },
-        },
-        include: { posts: true }
-    });
-    console.log('User created:', user);
-}
-
-main();
-`;

package/src/cli-error.ts

@@ -1,4 +0,0 @@
-/**
- * Indicating an error during CLI execution
- */
-export class CliError extends Error {}

package/src/constants.ts

@@ -1,5 +0,0 @@
-// replaced at build time
-export const TELEMETRY_TRACKING_TOKEN = '<TELEMETRY_TRACKING_TOKEN>';
-
-// plugin-contributed model file name
-export const PLUGIN_MODULE_NAME = 'plugin.zmodel';

package/src/index.ts

@@ -1,233 +0,0 @@
-import { ZModelLanguageMetaData } from '@zenstackhq/language';
-import colors from 'colors';
-import { Command, CommanderError, Option } from 'commander';
-import * as actions from './actions';
-import { CliError } from './cli-error';
-import { telemetry } from './telemetry';
-import { checkNewVersion, getVersion } from './utils/version-utils';
-
-const generateAction = async (options: Parameters<typeof actions.generate>[0]): Promise<void> => {
-    await telemetry.trackCommand('generate', () => actions.generate(options));
-};
-
-const migrateAction = async (subCommand: string, options: any): Promise<void> => {
-    await telemetry.trackCommand(`migrate ${subCommand}`, () => actions.migrate(subCommand, options));
-};
-
-const dbAction = async (subCommand: string, options: any): Promise<void> => {
-    await telemetry.trackCommand(`db ${subCommand}`, () => actions.db(subCommand, options));
-};
-
-const infoAction = async (projectPath: string): Promise<void> => {
-    await telemetry.trackCommand('info', () => actions.info(projectPath));
-};
-
-const initAction = async (projectPath: string): Promise<void> => {
-    await telemetry.trackCommand('init', () => actions.init(projectPath));
-};
-
-const checkAction = async (options: Parameters<typeof actions.check>[0]): Promise<void> => {
-    await telemetry.trackCommand('check', () => actions.check(options));
-};
-
-const formatAction = async (options: Parameters<typeof actions.format>[0]): Promise<void> => {
-    await telemetry.trackCommand('format', () => actions.format(options));
-};
-
-const seedAction = async (options: Parameters<typeof actions.seed>[0], args: string[]): Promise<void> => {
-    await telemetry.trackCommand('db seed', () => actions.seed(options, args));
-};
-
-function createProgram() {
-    const program = new Command('zen')
-        .alias('zenstack')
-        .helpOption('-h, --help', 'Show this help message')
-        .version(getVersion()!, '-v --version', 'Show CLI version');
-
-    const schemaExtensions = ZModelLanguageMetaData.fileExtensions.join(', ');
-
-    program
-        .description(
-            `${colors.bold.blue(
-                'ζ',
-            )} ZenStack is the modern data layer for TypeScript apps.\n\nDocumentation: https://zenstack.dev/docs`,
-        )
-        .showHelpAfterError()
-        .showSuggestionAfterError();
-
-    const schemaOption = new Option(
-        '--schema <file>',
-        `schema file (with extension ${schemaExtensions}). Defaults to "zenstack/schema.zmodel" unless specified in package.json.`,
-    );
-
-    const noVersionCheckOption = new Option('--no-version-check', 'do not check for new version');
-
-    program
-        .command('generate')
-        .description('Run code generation plugins')
-        .addOption(schemaOption)
-        .addOption(noVersionCheckOption)
-        .addOption(new Option('-o, --output <path>', 'default output directory for code generation'))
-        .addOption(new Option('--lite', 'also generate a lite version of schema without attributes').default(false))
-        .addOption(new Option('--lite-only', 'only generate lite version of schema without attributes').default(false))
-        .addOption(new Option('--silent', 'suppress all output except errors').default(false))
-        .action(generateAction);
-
-    const migrateCommand = program.command('migrate').description('Run database schema migration related tasks.');
-    const migrationsOption = new Option('--migrations <path>', 'path that contains the "migrations" directory');
-
-    migrateCommand
-        .command('dev')
-        .addOption(schemaOption)
-        .addOption(noVersionCheckOption)
-        .addOption(new Option('-n, --name <name>', 'migration name'))
-        .addOption(new Option('--create-only', 'only create migration, do not apply'))
-        .addOption(migrationsOption)
-        .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'))
-        .addOption(migrationsOption)
-        .addOption(new Option('--skip-seed', 'skip seeding the database after reset'))
-        .addOption(noVersionCheckOption)
-        .description('Reset your database and apply all migrations, all data will be lost')
-        .addHelpText(
-            'after',
-            '\nIf there is a seed script defined in package.json, it will be run after the reset. Use --skip-seed to skip it.',
-        )
-        .action((options) => migrateAction('reset', options));
-
-    migrateCommand
-        .command('deploy')
-        .addOption(schemaOption)
-        .addOption(noVersionCheckOption)
-        .addOption(migrationsOption)
-        .description('Deploy your pending migrations to your production/staging database')
-        .action((options) => migrateAction('deploy', options));
-
-    migrateCommand
-        .command('status')
-        .addOption(schemaOption)
-        .addOption(noVersionCheckOption)
-        .addOption(migrationsOption)
-        .description('Check the status of your database migrations')
-        .action((options) => migrateAction('status', options));
-
-    migrateCommand
-        .command('resolve')
-        .addOption(schemaOption)
-        .addOption(noVersionCheckOption)
-        .addOption(migrationsOption)
-        .addOption(new Option('--applied <migration>', 'record a specific migration as applied'))
-        .addOption(new Option('--rolled-back <migration>', 'record a specific migration as rolled back'))
-        .description('Resolve issues with database migrations in deployment databases')
-        .action((options) => migrateAction('resolve', 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(noVersionCheckOption)
-        .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));
-
-    dbCommand
-        .command('seed')
-        .description('Seed the database')
-        .allowExcessArguments(true)
-        .addHelpText(
-            'after',
-            `
-Seed script is configured under the "zenstack.seed" field in package.json.
-E.g.:
-{
-    "zenstack": {
-        "seed": "ts-node ./zenstack/seed.ts"
-    }
-}
-
-Arguments following -- are passed to the seed script. E.g.: "zen db seed -- --users 10"`,
-        )
-        .addOption(noVersionCheckOption)
-        .action((options, command) => seedAction(options, command.args));
-
-    program
-        .command('info')
-        .description('Get information of installed ZenStack packages')
-        .argument('[path]', 'project path', '.')
-        .addOption(noVersionCheckOption)
-        .action(infoAction);
-
-    program
-        .command('init')
-        .description('Initialize an existing project for ZenStack')
-        .argument('[path]', 'project path', '.')
-        .addOption(noVersionCheckOption)
-        .action(initAction);
-
-    program
-        .command('check')
-        .description('Check a ZModel schema for syntax or semantic errors')
-        .addOption(schemaOption)
-        .addOption(noVersionCheckOption)
-        .action(checkAction);
-
-    program
-        .command('format')
-        .description('Format a ZModel schema file')
-        .addOption(schemaOption)
-        .addOption(noVersionCheckOption)
-        .action(formatAction);
-
-    program.addHelpCommand('help [command]', 'Display help for a command');
-
-    program.hook('preAction', async (_thisCommand, actionCommand) => {
-        if (actionCommand.getOptionValue('versionCheck') !== false) {
-            await checkNewVersion();
-        }
-    });
-
-    return program;
-}
-
-async function main() {
-    let exitCode = 0;
-
-    const program = createProgram();
-    program.exitOverride();
-
-    try {
-        await telemetry.trackCli(async () => {
-            await program.parseAsync();
-        });
-    } catch (e) {
-        if (e instanceof CommanderError) {
-            // ignore
-            exitCode = e.exitCode;
-        } else if (e instanceof CliError) {
-            // log
-            console.error(colors.red(e.message));
-            exitCode = 1;
-        } else {
-            console.error(colors.red(`Unhandled error: ${e}`));
-            exitCode = 1;
-        }
-    }
-
-    if (telemetry.isTracking) {
-        // give telemetry a chance to send events before exit
-        setTimeout(() => {
-            process.exit(exitCode);
-        }, 200);
-    } else {
-        process.exit(exitCode);
-    }
-}
-
-main();

package/src/plugins/index.ts

@@ -1,2 +0,0 @@
-export { default as prisma } from './prisma';
-export { default as typescript } from './typescript';

package/src/plugins/prisma.ts

@@ -1,21 +0,0 @@
-import { PrismaSchemaGenerator, type CliPlugin } from '@zenstackhq/sdk';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const plugin: CliPlugin = {
-    name: 'Prisma Schema Generator',
-    statusText: 'Generating Prisma schema',
-    async generate({ model, defaultOutputPath, pluginOptions }) {
-        let outFile = path.join(defaultOutputPath, 'schema.prisma');
-        if (typeof pluginOptions['output'] === 'string') {
-            outFile = path.resolve(defaultOutputPath, pluginOptions['output']);
-            if (!fs.existsSync(path.dirname(outFile))) {
-                fs.mkdirSync(path.dirname(outFile), { recursive: true });
-            }
-        }
-        const prismaSchema = await new PrismaSchemaGenerator(model).generate();
-        fs.writeFileSync(outFile, prismaSchema);
-    },
-};
-
-export default plugin;

package/src/plugins/typescript.ts

@@ -1,40 +0,0 @@
-import type { CliPlugin } from '@zenstackhq/sdk';
-import { TsSchemaGenerator } from '@zenstackhq/sdk';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const plugin: CliPlugin = {
-    name: 'TypeScript Schema Generator',
-    statusText: 'Generating TypeScript schema',
-    async generate({ model, defaultOutputPath, pluginOptions }) {
-        // output path
-        let outDir = defaultOutputPath;
-        if (typeof pluginOptions['output'] === 'string') {
-            outDir = path.resolve(defaultOutputPath, pluginOptions['output']);
-            if (!fs.existsSync(outDir)) {
-                fs.mkdirSync(outDir, { recursive: true });
-            }
-        }
-
-        // lite mode
-        const lite = pluginOptions['lite'] === true;
-
-        // liteOnly mode
-        const liteOnly = pluginOptions['liteOnly'] === true;
-
-        // add .js extension when importing
-        const importWithFileExtension = pluginOptions['importWithFileExtension'];
-        if (importWithFileExtension && typeof importWithFileExtension !== 'string') {
-            throw new Error('The "importWithFileExtension" option must be a string if specified.');
-        }
-
-        await new TsSchemaGenerator().generate(model, {
-            outDir,
-            lite,
-            liteOnly,
-            importWithFileExtension: importWithFileExtension as string | undefined,
-        });
-    },
-};
-
-export default plugin;