@zenstackhq/cli 3.0.0-alpha.3 → 3.0.0-alpha.30

package/src/actions/generate.ts

@@ -1,72 +1,135 @@
-import { isPlugin, LiteralExpr, type Model } from '@zenstackhq/language/ast';
-import type { CliGenerator } from '@zenstackhq/runtime/client';
-import { PrismaSchemaGenerator, TsSchemaGenerator } from '@zenstackhq/sdk';
+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 fs from 'node:fs';
 import path from 'node:path';
-import invariant from 'tiny-invariant';
-import { getSchemaFile, loadSchemaDocument } from './action-utils';
+import 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;
 };
 
 /**
  * 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 = options.output ?? path.dirname(schemaFile);
-
-    // generate TS schema
-    const tsSchemaFile = path.join(outputPath, 'schema.ts');
-    await new TsSchemaGenerator().generate(schemaFile, [], tsSchemaFile);
-
-    await runPlugins(model, outputPath, tsSchemaFile);
+    const outputPath = getOutputPath(options, schemaFile);
 
-    // generate Prisma schema
-    const prismaSchema = await new PrismaSchemaGenerator(model).generate();
-    fs.writeFileSync(path.join(outputPath, 'schema.prisma'), prismaSchema);
+    await runPlugins(schemaFile, model, outputPath);
 
-    if (!options.silent) {
-        console.log(colors.green('Generation completed successfully.'));
-        console.log(`You can now create a ZenStack client with it.
+    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/runtime';
 import { schema } from '${outputPath}/schema';
 
 const client = new ZenStackClient(schema, {
-    dialectConfig: { ... } 
+    dialect: { ... }
 });
-\`\`\`
-`);
+\`\`\``);
+}
+
+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(
-    model: Model,
-    outputPath: string,
-    tsSchemaFile: string
-) {
+async function runPlugins(schemaFile: string, model: Model, outputPath: string) {
     const plugins = model.declarations.filter(isPlugin);
+    const processedPlugins: { cliPlugin: CliPlugin; pluginOptions: Record<string, unknown> }[] = [];
+
     for (const plugin of plugins) {
-        const providerField = plugin.fields.find((f) => f.name === 'provider');
+        const provider = getPluginProvider(plugin);
+
+        let cliPlugin: CliPlugin;
+        if (provider.startsWith('@core/')) {
+            cliPlugin = (corePlugins as any)[provider.slice('@core/'.length)];
+            if (!cliPlugin) {
+                throw new CliError(`Unknown core plugin: ${provider}`);
+            }
+        } else {
+            let moduleSpec = provider;
+            if (moduleSpec.startsWith('.')) {
+                // relative to schema's path
+                moduleSpec = path.resolve(path.dirname(schemaFile), moduleSpec);
+            }
+            try {
+                cliPlugin = (await import(moduleSpec)).default as CliPlugin;
+            } catch (error) {
+                throw new CliError(`Failed to load plugin ${provider}: ${error}`);
+            }
+        }
+
+        processedPlugins.push({ cliPlugin, pluginOptions: getPluginOptions(plugin) });
+    }
+
+    const defaultPlugins = [corePlugins['typescript']].reverse();
+    defaultPlugins.forEach((d) => {
+        if (!processedPlugins.some((p) => p.cliPlugin === d)) {
+            processedPlugins.push({ cliPlugin: d, pluginOptions: {} });
+        }
+    });
+
+    for (const { cliPlugin, pluginOptions } of processedPlugins) {
         invariant(
-            providerField,
-            `Plugin ${plugin.name} does not have a provider field`
+            typeof cliPlugin.generate === 'function',
+            `Plugin ${cliPlugin.name} does not have a generate function`,
         );
-        const provider = (providerField.value as LiteralExpr).value as string;
-        let useProvider = provider;
-        if (useProvider.startsWith('@core/')) {
-            useProvider = `@zenstackhq/runtime/plugins/${useProvider.slice(6)}`;
+
+        // run plugin generator
+        const 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;
         }
-        const generator = (await import(useProvider)).default as CliGenerator;
-        console.log('Running generator:', provider);
-        await generator({ model, outputPath, tsSchemaFile });
+        result[field.name] = value;
     }
+    return result;
 }

package/src/actions/index.ts

@@ -3,5 +3,6 @@ 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 check } from './check';
 
-export { db, generate, info, init, migrate };
+export { db, generate, info, init, migrate, check };

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,11 +1,30 @@
+import fs from 'node:fs';
 import path from 'node:path';
+import { CliError } from '../cli-error';
 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;
+    migrations?: string;
+};
+
+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;
 };
 
 /**
@@ -13,97 +32,105 @@ type CommonOptions = {
  */
 export async function run(command: string, options: CommonOptions) {
     const schemaFile = getSchemaFile(options.schema);
+    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;
 
-    // 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;
-
-        case 'reset':
-            await runReset(prismaSchemaFile, options as any);
-            break;
-
-        case 'deploy':
-            await runDeploy(prismaSchemaFile, options);
-            break;
-
-        case 'status':
-            await runStatus(prismaSchemaFile, options);
-            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);
+        }
     }
 }
 
-async function runDev(prismaSchemaFile: string, _options: unknown) {
+async function runDev(prismaSchemaFile: string, options: DevOptions) {
     try {
-        await execPackage(
-            `prisma migrate dev --schema "${prismaSchemaFile}" --skip-generate`,
-            {
-                stdio: 'inherit',
-            }
-        );
+        const cmd = [
+            'prisma migrate dev',
+            ` --schema "${prismaSchemaFile}"`,
+            ' --skip-generate',
+            options.name ? ` --name ${options.name}` : '',
+            options.createOnly ? ' --create-only' : '',
+        ].join('');
+
+        await execPackage(cmd);
     } 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',
-            }
+        const cmd = ['prisma migrate reset', ` --schema "${prismaSchemaFile}"`, options.force ? ' --force' : ''].join(
+            '',
         );
+
+        await execPackage(cmd);
     } 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',
-            }
-        );
+        const cmd = ['prisma migrate deploy', ` --schema "${prismaSchemaFile}"`].join('');
+
+        await execPackage(cmd);
     } 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}"`);
+    } catch (err) {
+        handleSubProcessError(err);
+    }
+}
+
+async 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 = [
+            'prisma migrate resolve',
+            ` --schema "${prismaSchemaFile}"`,
+            options.applied ? ` --applied ${options.applied}` : '',
+            options.rolledBack ? ` --rolled-back ${options.rolledBack}` : '',
+        ].join('');
+
+        await execPackage(cmd);
     } 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/actions/templates.ts

@@ -27,14 +27,15 @@ model Post {
 `;
 
 export const STARTER_MAIN_TS = `import { ZenStackClient } from '@zenstackhq/runtime';
-import { schema } from './zenstack/schema';
 import SQLite from 'better-sqlite3';
+import { SqliteDialect } from 'kysely';
+import { schema } from './zenstack/schema';
 
 async function main() {
     const client = new ZenStackClient(schema, {
-        dialectConfig: {
+        dialect: new SqliteDialect({
             database: new SQLite('./zenstack/dev.db'),
-        },
+        }),
     });
     const user = await client.user.create({
         data: {