@zenstackhq/cli 3.1.1 → 3.2.0

package/src/actions/action-utils.ts

@@ -1,146 +0,0 @@
-import { loadDocument } from '@zenstackhq/language';
-import { isDataSource } from '@zenstackhq/language/ast';
-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) {
-        if (!fs.existsSync(file)) {
-            throw new CliError(`Schema file not found: ${file}`);
-        }
-        return file;
-    }
-
-    const pkgJsonConfig = getPkgJsonConfig(process.cwd());
-    if (pkgJsonConfig.schema) {
-        if (!fs.existsSync(pkgJsonConfig.schema)) {
-            throw new CliError(`Schema file not found: ${pkgJsonConfig.schema}`);
-        }
-        if (fs.statSync(pkgJsonConfig.schema).isDirectory()) {
-            const schemaPath = path.join(pkgJsonConfig.schema, 'schema.zmodel');
-            if (!fs.existsSync(schemaPath)) {
-                throw new CliError(`Schema file not found: ${schemaPath}`);
-            }
-            return schemaPath;
-        } else {
-            return pkgJsonConfig.schema;
-        }
-    }
-
-    if (fs.existsSync('./schema.zmodel')) {
-        return './schema.zmodel';
-    } else if (fs.existsSync('./zenstack/schema.zmodel')) {
-        return './zenstack/schema.zmodel';
-    } else {
-        throw new CliError(
-            'Schema file not found in default locations ("./schema.zmodel" or "./zenstack/schema.zmodel").',
-        );
-    }
-}
-
-export async function loadSchemaDocument(schemaFile: string) {
-    const loadResult = await loadDocument(schemaFile);
-    if (!loadResult.success) {
-        loadResult.errors.forEach((err) => {
-            console.error(colors.red(err));
-        });
-        throw new CliError('Schema contains errors. See above for details.');
-    }
-    loadResult.warnings.forEach((warn) => {
-        console.warn(colors.yellow(warn));
-    });
-    return loadResult.model;
-}
-
-export function handleSubProcessError(err: unknown) {
-    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, folder?: string) {
-    const model = await loadSchemaDocument(zmodelPath);
-    if (!model.declarations.some(isDataSource)) {
-        throw new CliError('Schema must define a datasource');
-    }
-    const prismaSchema = await new PrismaSchemaGenerator(model).generate();
-    if (!folder) {
-        folder = path.dirname(zmodelPath);
-    }
-    const prismaSchemaFile = path.resolve(folder, '~schema.prisma');
-    fs.writeFileSync(prismaSchemaFile, prismaSchema);
-    return prismaSchemaFile;
-}
-
-export function getPkgJsonConfig(startPath: string) {
-    const result: { schema: string | undefined; output: string | undefined; seed: string | undefined } = {
-        schema: undefined,
-        output: undefined,
-        seed: undefined,
-    };
-    const pkgJsonFile = findUp(['package.json'], startPath, false);
-
-    if (!pkgJsonFile) {
-        return result;
-    }
-
-    let pkgJson: any = undefined;
-    try {
-        pkgJson = JSON.parse(fs.readFileSync(pkgJsonFile, 'utf8'));
-    } catch {
-        return result;
-    }
-
-    if (pkgJson.zenstack && typeof pkgJson.zenstack === 'object') {
-        result.schema =
-            pkgJson.zenstack.schema && typeof pkgJson.zenstack.schema === 'string'
-                ? path.resolve(path.dirname(pkgJsonFile), pkgJson.zenstack.schema)
-                : undefined;
-        result.output =
-            pkgJson.zenstack.output && typeof pkgJson.zenstack.output === 'string'
-                ? path.resolve(path.dirname(pkgJsonFile), pkgJson.zenstack.output)
-                : undefined;
-        result.seed =
-            typeof pkgJson.zenstack.seed === 'string' && pkgJson.zenstack.seed ? pkgJson.zenstack.seed : undefined;
-    }
-
-    return result;
-}
-
-type FindUpResult<Multiple extends boolean> = Multiple extends true ? string[] | undefined : string | undefined;
-
-function findUp<Multiple extends boolean = false>(
-    names: string[],
-    cwd: string = process.cwd(),
-    multiple: Multiple = false as Multiple,
-    result: string[] = [],
-): FindUpResult<Multiple> {
-    if (!names.some((name) => !!name)) {
-        return undefined;
-    }
-    const target = names.find((name) => fs.existsSync(path.join(cwd, name)));
-    if (multiple === false && target) {
-        return path.join(cwd, target) as FindUpResult<Multiple>;
-    }
-    if (target) {
-        result.push(path.join(cwd, target));
-    }
-    const up = path.resolve(cwd, '..');
-    if (up === cwd) {
-        return (multiple && result.length > 0 ? result : undefined) as FindUpResult<Multiple>;
-    }
-    return findUp(names, up, multiple, result);
-}
-
-export async function requireDataSourceUrl(schemaFile: string) {
-    const zmodel = await loadSchemaDocument(schemaFile);
-    const dataSource = zmodel.declarations.find(isDataSource);
-    if (!dataSource?.fields.some((f) => f.name === 'url')) {
-        throw new CliError('The schema\'s "datasource" must have a "url" field to use this command.');
-    }
-}

package/src/actions/check.ts

@@ -1,22 +0,0 @@
-import colors from 'colors';
-import { getSchemaFile, loadSchemaDocument } from './action-utils';
-
-type Options = {
-    schema?: string;
-};
-
-/**
- * CLI action for checking a schema's validity.
- */
-export async function run(options: Options) {
-    const schemaFile = getSchemaFile(options.schema);
-
-    try {
-        await loadSchemaDocument(schemaFile);
-        console.log(colors.green('✓ Schema validation completed successfully.'));
-    } catch (error) {
-        console.error(colors.red('✗ Schema validation failed.'));
-        // Re-throw to maintain CLI exit code behavior
-        throw error;
-    }
-}

package/src/actions/db.ts

@@ -1,51 +0,0 @@
-import fs from 'node:fs';
-import { execPrisma } from '../utils/exec-utils';
-import { generateTempPrismaSchema, getSchemaFile, handleSubProcessError, requireDataSourceUrl } from './action-utils';
-
-type Options = {
-    schema?: string;
-    acceptDataLoss?: boolean;
-    forceReset?: boolean;
-};
-
-/**
- * CLI action for db related commands
- */
-export async function run(command: string, options: Options) {
-    switch (command) {
-        case 'push':
-            await runPush(options);
-            break;
-    }
-}
-
-async function runPush(options: Options) {
-    const schemaFile = getSchemaFile(options.schema);
-
-    // validate datasource url exists
-    await requireDataSourceUrl(schemaFile);
-
-    // generate a temp prisma schema file
-    const prismaSchemaFile = await generateTempPrismaSchema(schemaFile);
-
-    try {
-        // run prisma db push
-        const cmd = [
-            'db push',
-            ` --schema "${prismaSchemaFile}"`,
-            options.acceptDataLoss ? ' --accept-data-loss' : '',
-            options.forceReset ? ' --force-reset' : '',
-            ' --skip-generate',
-        ].join('');
-
-        try {
-            execPrisma(cmd);
-        } catch (err) {
-            handleSubProcessError(err);
-        }
-    } finally {
-        if (fs.existsSync(prismaSchemaFile)) {
-            fs.unlinkSync(prismaSchemaFile);
-        }
-    }
-}

package/src/actions/format.ts

@@ -1,27 +0,0 @@
-import { formatDocument } from '@zenstackhq/language';
-import colors from 'colors';
-import fs from 'node:fs';
-import { getSchemaFile } from './action-utils';
-
-type Options = {
-    schema?: string;
-};
-
-/**
- * CLI action for formatting a ZModel schema file.
- */
-export async function run(options: Options) {
-    const schemaFile = getSchemaFile(options.schema);
-    let formattedContent: string;
-
-    try {
-        formattedContent = await formatDocument(fs.readFileSync(schemaFile, 'utf-8'));
-    } catch (error) {
-        console.error(colors.red('✗ Schema formatting failed.'));
-        // Re-throw to maintain CLI exit code behavior
-        throw error;
-    }
-
-    fs.writeFileSync(schemaFile, formattedContent, 'utf-8');
-    console.log(colors.green('✓ Schema formatting completed successfully.'));
-}

package/src/actions/generate.ts

@@ -1,226 +0,0 @@
-import { invariant } from '@zenstackhq/common-helpers';
-import { isPlugin, LiteralExpr, Plugin, type Model } from '@zenstackhq/language/ast';
-import { getLiteral, getLiteralArray } from '@zenstackhq/language/utils';
-import { type CliPlugin } from '@zenstackhq/sdk';
-import colors from 'colors';
-import { createJiti } from 'jiti';
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import ora, { type Ora } from 'ora';
-import { CliError } from '../cli-error';
-import * as corePlugins from '../plugins';
-import { getPkgJsonConfig, getSchemaFile, loadSchemaDocument } from './action-utils';
-
-type Options = {
-    schema?: string;
-    output?: string;
-    silent: boolean;
-    lite: boolean;
-    liteOnly: boolean;
-};
-
-/**
- * CLI action for generating code from schema
- */
-export async function run(options: Options) {
-    const start = Date.now();
-
-    const schemaFile = getSchemaFile(options.schema);
-
-    const model = await loadSchemaDocument(schemaFile);
-    const outputPath = getOutputPath(options, schemaFile);
-
-    await runPlugins(schemaFile, model, outputPath, options);
-
-    if (!options.silent) {
-        console.log(colors.green(`Generation completed successfully in ${Date.now() - start}ms.\n`));
-        console.log(`You can now create a ZenStack client with it.
-
-\`\`\`ts
-import { ZenStackClient } from '@zenstackhq/orm';
-import { schema } from '${path.relative('.', outputPath)}/schema';
-
-const client = new ZenStackClient(schema, {
-    dialect: { ... }
-});
-\`\`\`
-
-Check documentation: https://zenstack.dev/docs/`);
-    }
-}
-
-function getOutputPath(options: Options, schemaFile: string) {
-    if (options.output) {
-        return options.output;
-    }
-    const pkgJsonConfig = getPkgJsonConfig(process.cwd());
-    if (pkgJsonConfig.output) {
-        return pkgJsonConfig.output;
-    } else {
-        return path.dirname(schemaFile);
-    }
-}
-
-async function runPlugins(schemaFile: string, model: Model, outputPath: string, options: Options) {
-    const plugins = model.declarations.filter(isPlugin);
-    const processedPlugins: { cliPlugin: CliPlugin; pluginOptions: Record<string, unknown> }[] = [];
-
-    for (const plugin of plugins) {
-        const provider = getPluginProvider(plugin);
-
-        let cliPlugin: CliPlugin | undefined;
-        if (provider.startsWith('@core/')) {
-            cliPlugin = (corePlugins as any)[provider.slice('@core/'.length)];
-            if (!cliPlugin) {
-                throw new CliError(`Unknown core plugin: ${provider}`);
-            }
-        } else {
-            cliPlugin = await loadPluginModule(provider, path.dirname(schemaFile));
-        }
-
-        if (cliPlugin) {
-            const pluginOptions = getPluginOptions(plugin);
-
-            // merge CLI options
-            if (provider === '@core/typescript') {
-                if (pluginOptions['lite'] === undefined) {
-                    pluginOptions['lite'] = options.lite;
-                }
-                if (pluginOptions['liteOnly'] === undefined) {
-                    pluginOptions['liteOnly'] = options.liteOnly;
-                }
-            }
-
-            processedPlugins.push({ cliPlugin, pluginOptions });
-        }
-    }
-
-    const defaultPlugins = [
-        {
-            plugin: corePlugins['typescript'],
-            options: { lite: options.lite, liteOnly: options.liteOnly },
-        },
-    ];
-    defaultPlugins.forEach(({ plugin, options }) => {
-        if (!processedPlugins.some((p) => p.cliPlugin === plugin)) {
-            // default plugins are run before user plugins
-            processedPlugins.unshift({ cliPlugin: plugin, pluginOptions: options });
-        }
-    });
-
-    for (const { cliPlugin, pluginOptions } of processedPlugins) {
-        invariant(
-            typeof cliPlugin.generate === 'function',
-            `Plugin ${cliPlugin.name} does not have a generate function`,
-        );
-
-        // run plugin generator
-        let spinner: Ora | undefined;
-
-        if (!options.silent) {
-            spinner = ora(cliPlugin.statusText ?? `Running plugin ${cliPlugin.name}`).start();
-        }
-        try {
-            await cliPlugin.generate({
-                schemaFile,
-                model,
-                defaultOutputPath: outputPath,
-                pluginOptions,
-            });
-            spinner?.succeed();
-        } catch (err) {
-            spinner?.fail();
-            console.error(err);
-        }
-    }
-}
-
-function getPluginProvider(plugin: Plugin) {
-    const providerField = plugin.fields.find((f) => f.name === 'provider');
-    invariant(providerField, `Plugin ${plugin.name} does not have a provider field`);
-    const provider = (providerField.value as LiteralExpr).value as string;
-    return provider;
-}
-
-function getPluginOptions(plugin: Plugin): Record<string, unknown> {
-    const result: Record<string, unknown> = {};
-    for (const field of plugin.fields) {
-        if (field.name === 'provider') {
-            continue; // skip provider
-        }
-        const value = getLiteral(field.value) ?? getLiteralArray(field.value);
-        if (value === undefined) {
-            console.warn(`Plugin "${plugin.name}" option "${field.name}" has unsupported value, skipping`);
-            continue;
-        }
-        result[field.name] = value;
-    }
-    return result;
-}
-
-async function loadPluginModule(provider: string, basePath: string) {
-    let moduleSpec = provider;
-    if (moduleSpec.startsWith('.')) {
-        // relative to schema's path
-        moduleSpec = path.resolve(basePath, moduleSpec);
-    }
-
-    const importAsEsm = async (spec: string) => {
-        try {
-            const result = (await import(spec)).default as CliPlugin;
-            return result;
-        } catch (err) {
-            throw new CliError(`Failed to load plugin module from ${spec}: ${(err as Error).message}`);
-        }
-    };
-
-    const jiti = createJiti(pathToFileURL(basePath).toString());
-    const importAsTs = async (spec: string) => {
-        try {
-            const result = (await jiti.import(spec, { default: true })) as CliPlugin;
-            return result;
-        } catch (err) {
-            throw new CliError(`Failed to load plugin module from ${spec}: ${(err as Error).message}`);
-        }
-    };
-
-    const esmSuffixes = ['.js', '.mjs'];
-    const tsSuffixes = ['.ts', '.mts'];
-
-    if (fs.existsSync(moduleSpec) && fs.statSync(moduleSpec).isFile()) {
-        // try provider as ESM file
-        if (esmSuffixes.some((suffix) => moduleSpec.endsWith(suffix))) {
-            return await importAsEsm(pathToFileURL(moduleSpec).toString());
-        }
-
-        // try provider as TS file
-        if (tsSuffixes.some((suffix) => moduleSpec.endsWith(suffix))) {
-            return await importAsTs(moduleSpec);
-        }
-    }
-
-    // try ESM index files in provider directory
-    for (const suffix of esmSuffixes) {
-        const indexPath = path.join(moduleSpec, `index${suffix}`);
-        if (fs.existsSync(indexPath)) {
-            return await importAsEsm(pathToFileURL(indexPath).toString());
-        }
-    }
-
-    // try TS index files in provider directory
-    for (const suffix of tsSuffixes) {
-        const indexPath = path.join(moduleSpec, `index${suffix}`);
-        if (fs.existsSync(indexPath)) {
-            return await importAsTs(indexPath);
-        }
-    }
-
-    // last resort, try to import as esm directly
-    try {
-        return (await import(moduleSpec)).default as CliPlugin;
-    } catch {
-        // plugin may not export a generator so we simply ignore the error here
-        return undefined;
-    }
-}

package/src/actions/index.ts

@@ -1,10 +0,0 @@
-import { run as check } from './check';
-import { run as db } from './db';
-import { run as format } from './format';
-import { run as generate } from './generate';
-import { run as info } from './info';
-import { run as init } from './init';
-import { run as migrate } from './migrate';
-import { run as seed } from './seed';
-
-export { check, db, format, generate, info, init, migrate, seed };

package/src/actions/info.ts

@@ -1,71 +0,0 @@
-import colors from 'colors';
-import path from 'node:path';
-
-/**
- * CLI action for getting information about installed ZenStack packages
- */
-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?');
-        return;
-    }
-
-    console.log('Installed ZenStack Packages:');
-    const versions = new Set<string>();
-    for (const { pkg, version } of packages) {
-        if (version) {
-            versions.add(version);
-        }
-        console.log(`    ${colors.green(pkg.padEnd(20))}\t${version}`);
-    }
-
-    if (versions.size > 1) {
-        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 }>> {
-    let pkgJson: {
-        dependencies: Record<string, unknown>;
-        devDependencies: Record<string, unknown>;
-    };
-    const resolvedPath = path.resolve(projectPath);
-    try {
-        pkgJson = (
-            await import(path.join(resolvedPath, 'package.json'), {
-                with: { type: 'json' },
-            })
-        ).default;
-    } catch {
-        return [];
-    }
-
-    const packages = Array.from(
-        new Set(
-            [...Object.keys(pkgJson.dependencies ?? {}), ...Object.keys(pkgJson.devDependencies ?? {})].filter(
-                (p) => p.startsWith('@zenstackhq/') || p === 'zenstack',
-            ),
-        ),
-    ).sort();
-
-    const result = await Promise.all(
-        packages.map(async (pkg) => {
-            try {
-                const depPkgJson = (
-                    await import(`${pkg}/package.json`, {
-                        with: { type: 'json' },
-                    })
-                ).default;
-                if (depPkgJson.private) {
-                    return undefined;
-                }
-                return { pkg, version: depPkgJson.version as string };
-            } catch {
-                return { pkg, version: undefined };
-            }
-        }),
-    );
-
-    return result.filter((p) => !!p);
-}

package/src/actions/init.ts

@@ -1,61 +0,0 @@
-import colors from 'colors';
-import fs from 'node:fs';
-import path from 'node:path';
-import ora from 'ora';
-import { detect, resolveCommand } from 'package-manager-detector';
-import { CliError } from '../cli-error';
-import { execSync } from '../utils/exec-utils';
-import { STARTER_ZMODEL } from './templates';
-
-/**
- * CLI action for getting information about installed ZenStack packages
- */
-export async function run(projectPath: string) {
-    const packages = [
-        { name: '@zenstackhq/cli@latest', dev: true },
-        { name: '@zenstackhq/orm@latest', dev: false },
-    ];
-    let pm = await detect();
-    if (!pm) {
-        pm = { agent: 'npm', name: 'npm' };
-    }
-
-    console.log(colors.gray(`Using package manager: ${pm.agent}`));
-
-    for (const pkg of packages) {
-        const resolved = resolveCommand(pm.agent, 'add', [
-            pkg.name,
-            ...(pkg.dev ? [pm.agent.startsWith('yarn') || pm.agent === 'bun' ? '--dev' : '--save-dev'] : []),
-        ]);
-        if (!resolved) {
-            throw new CliError(`Unable to determine how to install package "${pkg.name}". Please install it manually.`);
-        }
-
-        const spinner = ora(`Installing "${pkg.name}"`).start();
-        try {
-            execSync(`${resolved.command} ${resolved.args.join(' ')}`, {
-                cwd: projectPath,
-            });
-            spinner.succeed();
-        } catch (e) {
-            spinner.fail();
-            throw e;
-        }
-    }
-
-    const generationFolder = 'zenstack';
-
-    if (!fs.existsSync(path.join(projectPath, generationFolder))) {
-        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);
-    } else {
-        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.'));
-}