@zenstackhq/cli 3.0.0-alpha.26 → 3.0.0-alpha.28

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @zenstackhq/cli@3.0.0-alpha.26 build /home/runner/work/zenstack-v3/zenstack-v3/packages/cli
+> @zenstackhq/cli@3.0.0-alpha.28 build /home/runner/work/zenstack-v3/zenstack-v3/packages/cli
 > tsc --noEmit && tsup-node
 
 CLI Building entry: {"index":"src/index.ts"}
@@ -10,13 +10,13 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js     20.49 KB
-ESM dist/index.js.map 43.09 KB
-ESM ⚡️ Build success in 117ms
-CJS dist/index.cjs     23.97 KB
-CJS dist/index.cjs.map 43.35 KB
-CJS ⚡️ Build success in 117ms
+CJS dist/index.cjs     26.78 KB
+CJS dist/index.cjs.map 48.65 KB
+CJS ⚡️ Build success in 129ms
+ESM dist/index.js     23.19 KB
+ESM dist/index.js.map 48.28 KB
+ESM ⚡️ Build success in 131ms
 DTS Build start
-DTS ⚡️ Build success in 2894ms
+DTS ⚡️ Build success in 3413ms
 DTS dist/index.d.ts  108.00 B
 DTS dist/index.d.cts 108.00 B

package/dist/index.cjs

@@ -217,32 +217,73 @@ __name(runPush, "runPush");
 // src/actions/generate.ts
 var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_ast2 = require("@zenstackhq/language/ast");
-var import_sdk2 = require("@zenstackhq/sdk");
+var import_utils = require("@zenstackhq/language/utils");
 var import_colors2 = __toESM(require("colors"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_ora = __toESM(require("ora"), 1);
+
+// src/plugins/index.ts
+var plugins_exports = {};
+__export(plugins_exports, {
+  prisma: () => prisma_default,
+  typescript: () => typescript_default
+});
+
+// src/plugins/prisma.ts
+var import_sdk2 = require("@zenstackhq/sdk");
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
+var plugin = {
+  name: "Prisma Schema Generator",
+  statusText: "Generating Prisma schema",
+  async generate({ model, defaultOutputPath, pluginOptions }) {
+    let outDir = defaultOutputPath;
+    if (typeof pluginOptions["output"] === "string") {
+      outDir = import_node_path2.default.resolve(defaultOutputPath, pluginOptions["output"]);
+      if (!import_node_fs3.default.existsSync(outDir)) {
+        import_node_fs3.default.mkdirSync(outDir, {
+          recursive: true
+        });
+      }
+    }
+    const prismaSchema = await new import_sdk2.PrismaSchemaGenerator(model).generate();
+    import_node_fs3.default.writeFileSync(import_node_path2.default.join(outDir, "schema.prisma"), prismaSchema);
+  }
+};
+var prisma_default = plugin;
+
+// src/plugins/typescript.ts
+var import_sdk3 = require("@zenstackhq/sdk");
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var plugin2 = {
+  name: "TypeScript Schema Generator",
+  statusText: "Generating TypeScript schema",
+  async generate({ model, defaultOutputPath, pluginOptions }) {
+    let outDir = defaultOutputPath;
+    if (typeof pluginOptions["output"] === "string") {
+      outDir = import_node_path3.default.resolve(defaultOutputPath, pluginOptions["output"]);
+      if (!import_node_fs4.default.existsSync(outDir)) {
+        import_node_fs4.default.mkdirSync(outDir, {
+          recursive: true
+        });
+      }
+    }
+    await new import_sdk3.TsSchemaGenerator().generate(model, outDir);
+  }
+};
+var typescript_default = plugin2;
+
+// src/actions/generate.ts
 async function run2(options) {
   const start = Date.now();
   const schemaFile = getSchemaFile(options.schema);
   const model = await loadSchemaDocument(schemaFile);
   const outputPath = getOutputPath(options, schemaFile);
-  const tsSchemaFile = import_node_path2.default.join(outputPath, "schema.ts");
-  await new import_sdk2.TsSchemaGenerator().generate(schemaFile, [], outputPath);
-  await runPlugins(model, outputPath, tsSchemaFile);
-  if (options.savePrismaSchema) {
-    const prismaSchema = await new import_sdk2.PrismaSchemaGenerator(model).generate();
-    let prismaSchemaFile = import_node_path2.default.join(outputPath, "schema.prisma");
-    if (typeof options.savePrismaSchema === "string") {
-      prismaSchemaFile = import_node_path2.default.resolve(outputPath, options.savePrismaSchema);
-      import_node_fs3.default.mkdirSync(import_node_path2.default.dirname(prismaSchemaFile), {
-        recursive: true
-      });
-    }
-    import_node_fs3.default.writeFileSync(prismaSchemaFile, prismaSchema);
-  }
-  if (!options.silent) {
-    console.log(import_colors2.default.green(`Generation completed successfully in ${Date.now() - start}ms.`));
-    console.log(`You can now create a ZenStack client with it.
+  await runPlugins(schemaFile, model, outputPath);
+  console.log(import_colors2.default.green(`Generation completed successfully in ${Date.now() - start}ms.
+`));
+  console.log(`You can now create a ZenStack client with it.
 
 \`\`\`ts
 import { ZenStackClient } from '@zenstackhq/runtime';
@@ -252,7 +293,6 @@ const client = new ZenStackClient(schema, {
     dialect: { ... }
 });
 \`\`\``);
-  }
 }
 __name(run2, "run");
 function getOutputPath(options, schemaFile) {
@@ -263,34 +303,93 @@ function getOutputPath(options, schemaFile) {
   if (pkgJsonConfig.output) {
     return pkgJsonConfig.output;
   } else {
-    return import_node_path2.default.dirname(schemaFile);
+    return import_node_path4.default.dirname(schemaFile);
   }
 }
 __name(getOutputPath, "getOutputPath");
-async function runPlugins(model, outputPath, tsSchemaFile) {
+async function runPlugins(schemaFile, model, outputPath) {
   const plugins = model.declarations.filter(import_ast2.isPlugin);
-  for (const plugin of plugins) {
-    const providerField = plugin.fields.find((f) => f.name === "provider");
-    (0, import_common_helpers.invariant)(providerField, `Plugin ${plugin.name} does not have a provider field`);
-    const provider = providerField.value.value;
-    let useProvider = provider;
-    if (useProvider.startsWith("@core/")) {
-      useProvider = `@zenstackhq/runtime/plugins/${useProvider.slice(6)}`;
+  const processedPlugins = [];
+  for (const plugin3 of plugins) {
+    const provider = getPluginProvider(plugin3);
+    let cliPlugin;
+    if (provider.startsWith("@core/")) {
+      cliPlugin = plugins_exports[provider.slice("@core/".length)];
+      if (!cliPlugin) {
+        throw new CliError(`Unknown core plugin: ${provider}`);
+      }
+    } else {
+      let moduleSpec = provider;
+      if (moduleSpec.startsWith(".")) {
+        moduleSpec = import_node_path4.default.resolve(import_node_path4.default.dirname(schemaFile), moduleSpec);
+      }
+      try {
+        cliPlugin = (await import(moduleSpec)).default;
+      } catch (error) {
+        throw new CliError(`Failed to load plugin ${provider}: ${error}`);
+      }
     }
-    const generator = (await import(useProvider)).default;
-    console.log("Running generator:", provider);
-    await generator({
-      model,
-      outputPath,
-      tsSchemaFile
+    processedPlugins.push({
+      cliPlugin,
+      pluginOptions: getPluginOptions(plugin3)
     });
   }
+  const defaultPlugins = [
+    typescript_default
+  ].reverse();
+  defaultPlugins.forEach((d) => {
+    if (!processedPlugins.some((p) => p.cliPlugin === d)) {
+      processedPlugins.push({
+        cliPlugin: d,
+        pluginOptions: {}
+      });
+    }
+  });
+  for (const { cliPlugin, pluginOptions } of processedPlugins) {
+    (0, import_common_helpers.invariant)(typeof cliPlugin.generate === "function", `Plugin ${cliPlugin.name} does not have a generate function`);
+    const spinner = (0, import_ora.default)(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);
+    }
+  }
 }
 __name(runPlugins, "runPlugins");
+function getPluginProvider(plugin3) {
+  const providerField = plugin3.fields.find((f) => f.name === "provider");
+  (0, import_common_helpers.invariant)(providerField, `Plugin ${plugin3.name} does not have a provider field`);
+  const provider = providerField.value.value;
+  return provider;
+}
+__name(getPluginProvider, "getPluginProvider");
+function getPluginOptions(plugin3) {
+  const result = {};
+  for (const field of plugin3.fields) {
+    if (field.name === "provider") {
+      continue;
+    }
+    const value = (0, import_utils.getLiteral)(field.value) ?? (0, import_utils.getLiteralArray)(field.value);
+    if (value === void 0) {
+      console.warn(`Plugin "${plugin3.name}" option "${field.name}" has unsupported value, skipping`);
+      continue;
+    }
+    result[field.name] = value;
+  }
+  return result;
+}
+__name(getPluginOptions, "getPluginOptions");
 
 // src/actions/info.ts
 var import_colors3 = __toESM(require("colors"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 async function run3(projectPath) {
   const packages = await getZenStackPackages(projectPath);
   if (!packages) {
@@ -312,9 +411,9 @@ async function run3(projectPath) {
 __name(run3, "run");
 async function getZenStackPackages(projectPath) {
   let pkgJson;
-  const resolvedPath = import_node_path3.default.resolve(projectPath);
+  const resolvedPath = import_node_path5.default.resolve(projectPath);
   try {
-    pkgJson = (await import(import_node_path3.default.join(resolvedPath, "package.json"), {
+    pkgJson = (await import(import_node_path5.default.join(resolvedPath, "package.json"), {
       with: {
         type: "json"
       }
@@ -350,9 +449,9 @@ __name(getZenStackPackages, "getZenStackPackages");
 
 // src/actions/init.ts
 var import_colors4 = __toESM(require("colors"), 1);
-var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-var import_ora = __toESM(require("ora"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_ora2 = __toESM(require("ora"), 1);
 var import_package_manager_detector = require("package-manager-detector");
 
 // src/actions/templates.ts
@@ -414,7 +513,7 @@ async function run4(projectPath) {
     if (!resolved) {
       throw new CliError(`Unable to determine how to install package "${pkg.name}". Please install it manually.`);
     }
-    const spinner = (0, import_ora.default)(`Installing "${pkg.name}"`).start();
+    const spinner = (0, import_ora2.default)(`Installing "${pkg.name}"`).start();
     try {
       execSync(`${resolved.command} ${resolved.args.join(" ")}`, {
         cwd: projectPath
@@ -426,11 +525,11 @@ async function run4(projectPath) {
     }
   }
   const generationFolder = "zenstack";
-  if (!import_node_fs4.default.existsSync(import_node_path4.default.join(projectPath, generationFolder))) {
-    import_node_fs4.default.mkdirSync(import_node_path4.default.join(projectPath, generationFolder));
+  if (!import_node_fs5.default.existsSync(import_node_path6.default.join(projectPath, generationFolder))) {
+    import_node_fs5.default.mkdirSync(import_node_path6.default.join(projectPath, generationFolder));
   }
-  if (!import_node_fs4.default.existsSync(import_node_path4.default.join(projectPath, generationFolder, "schema.zmodel"))) {
-    import_node_fs4.default.writeFileSync(import_node_path4.default.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
+  if (!import_node_fs5.default.existsSync(import_node_path6.default.join(projectPath, generationFolder, "schema.zmodel"))) {
+    import_node_fs5.default.writeFileSync(import_node_path6.default.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
   } else {
     console.log(import_colors4.default.yellow("Schema file already exists. Skipping generation of sample."));
   }
@@ -441,11 +540,11 @@ async function run4(projectPath) {
 __name(run4, "run");
 
 // src/actions/migrate.ts
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 async function run5(command, options) {
   const schemaFile = getSchemaFile(options.schema);
-  const prismaSchemaDir = options.migrations ? import_node_path5.default.dirname(options.migrations) : void 0;
+  const prismaSchemaDir = options.migrations ? import_node_path7.default.dirname(options.migrations) : void 0;
   const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
   try {
     switch (command) {
@@ -466,8 +565,8 @@ async function run5(command, options) {
         break;
     }
   } finally {
-    if (import_node_fs5.default.existsSync(prismaSchemaFile)) {
-      import_node_fs5.default.unlinkSync(prismaSchemaFile);
+    if (import_node_fs6.default.existsSync(prismaSchemaFile)) {
+      import_node_fs6.default.unlinkSync(prismaSchemaFile);
     }
   }
 }
@@ -546,7 +645,7 @@ function handleSubProcessError2(err) {
 }
 __name(handleSubProcessError2, "handleSubProcessError");
 
-// src/actions/validate.ts
+// src/actions/check.ts
 var import_colors5 = __toESM(require("colors"), 1);
 async function run6(options) {
   const schemaFile = getSchemaFile(options.schema);
@@ -561,14 +660,14 @@ async function run6(options) {
 __name(run6, "run");
 
 // src/utils/version-utils.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 var import_meta = {};
 function getVersion() {
   try {
-    const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path6.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
-    return JSON.parse(import_node_fs6.default.readFileSync(import_node_path6.default.join(_dirname, "../package.json"), "utf8")).version;
+    const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path8.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+    return JSON.parse(import_node_fs7.default.readFileSync(import_node_path8.default.join(_dirname, "../package.json"), "utf8")).version;
   } catch {
     return void 0;
   }
@@ -591,30 +690,30 @@ var infoAction = /* @__PURE__ */ __name(async (projectPath) => {
 var initAction = /* @__PURE__ */ __name(async (projectPath) => {
   await run4(projectPath);
 }, "initAction");
-var validateAction = /* @__PURE__ */ __name(async (options) => {
+var checkAction = /* @__PURE__ */ __name(async (options) => {
   await run6(options);
-}, "validateAction");
+}, "checkAction");
 function createProgram() {
   const program2 = new import_commander.Command("zenstack");
   program2.version(getVersion(), "-v --version", "display CLI version");
   const schemaExtensions = import_language2.ZModelLanguageMetaData.fileExtensions.join(", ");
-  program2.description(`${import_colors6.default.bold.blue("\u03B6")} ZenStack is a database access toolkit for TypeScript apps.
+  program2.description(`${import_colors6.default.bold.blue("\u03B6")} ZenStack is the data layer for modern TypeScript apps.
 
 Documentation: https://zenstack.dev.`).showHelpAfterError().showSuggestionAfterError();
-  const schemaOption = new import_commander.Option("--schema <file>", `schema file (with extension ${schemaExtensions}). Defaults to "schema.zmodel" unless specified in package.json.`);
-  program2.command("generate").description("Run code generation.").addOption(schemaOption).addOption(new import_commander.Option("--silent", "do not print any output")).addOption(new import_commander.Option("--save-prisma-schema [path]", "save a Prisma schema file, by default into the output directory")).addOption(new import_commander.Option("-o, --output <path>", "default output directory for core plugins")).action(generateAction);
-  const migrateCommand = program2.command("migrate").description("Update the database schema with migrations.");
-  const migrationsOption = new import_commander.Option("--migrations <path>", "path for migrations");
+  const schemaOption = new import_commander.Option("--schema <file>", `schema file (with extension ${schemaExtensions}). Defaults to "zenstack/schema.zmodel" unless specified in package.json.`);
+  program2.command("generate").description("Run code generation plugins.").addOption(schemaOption).addOption(new import_commander.Option("-o, --output <path>", "default output directory for code generation")).action(generateAction);
+  const migrateCommand = program2.command("migrate").description("Run database schema migration related tasks.");
+  const migrationsOption = new import_commander.Option("--migrations <path>", 'path that contains the "migrations" directory');
   migrateCommand.command("dev").addOption(schemaOption).addOption(new import_commander.Option("-n, --name <name>", "migration name")).addOption(new import_commander.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 import_commander.Option("--force", "skip the confirmation prompt")).addOption(migrationsOption).description("Reset your database and apply all migrations, all data will be lost.").action((options) => migrateAction("reset", options));
   migrateCommand.command("deploy").addOption(schemaOption).addOption(migrationsOption).description("Deploy your pending migrations to your production/staging database.").action((options) => migrateAction("deploy", options));
   migrateCommand.command("status").addOption(schemaOption).addOption(migrationsOption).description("Check the status of your database migrations.").action((options) => migrateAction("status", options));
-  migrateCommand.command("resolve").addOption(schemaOption).addOption(migrationsOption).addOption(new import_commander.Option("--applied <migration>", "record a specific migration as applied")).addOption(new import_commander.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));
+  migrateCommand.command("resolve").addOption(schemaOption).addOption(migrationsOption).addOption(new import_commander.Option("--applied <migration>", "record a specific migration as applied")).addOption(new import_commander.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 = program2.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 import_commander.Option("--accept-data-loss", "ignore data loss warnings")).addOption(new import_commander.Option("--force-reset", "force a reset of the database before push")).action((options) => dbAction("push", options));
-  program2.command("info").description("Get information of installed ZenStack and related packages.").argument("[path]", "project path", ".").action(infoAction);
+  dbCommand.command("push").description("Push the state from your schema to your database.").addOption(schemaOption).addOption(new import_commander.Option("--accept-data-loss", "ignore data loss warnings")).addOption(new import_commander.Option("--force-reset", "force a reset of the database before push")).action((options) => dbAction("push", options));
+  program2.command("info").description("Get information of installed ZenStack packages.").argument("[path]", "project path", ".").action(infoAction);
   program2.command("init").description("Initialize an existing project for ZenStack.").argument("[path]", "project path", ".").action(initAction);
-  program2.command("validate").description("Validate a ZModel schema.").addOption(schemaOption).action(validateAction);
+  program2.command("check").description("Check a ZModel schema for syntax or semantic errors.").addOption(schemaOption).action(checkAction);
   return program2;
 }
 __name(createProgram, "createProgram");