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

package/dist/index.js

@@ -1,86 +1,17 @@
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// package.json
-var require_package = __commonJS({
-  "package.json"(exports, module) {
-    module.exports = {
-      name: "@zenstackhq/cli",
-      publisher: "zenstack",
-      displayName: "ZenStack CLI",
-      description: "FullStack database toolkit with built-in access control and automatic API generation.",
-      version: "3.0.0-alpha.3",
-      type: "module",
-      author: {
-        name: "ZenStack Team"
-      },
-      homepage: "https://zenstack.dev",
-      license: "MIT",
-      keywords: [
-        "orm",
-        "fullstack",
-        "react",
-        "typescript",
-        "data modeling"
-      ],
-      bin: {
-        zenstack: "bin/cli"
-      },
-      scripts: {
-        build: "tsup-node",
-        watch: "tsup-node --watch",
-        lint: "eslint src --ext ts",
-        test: "vitest",
-        pack: "pnpm pack"
-      },
-      dependencies: {
-        "@types/node": "^20.0.0",
-        "@zenstackhq/language": "workspace:*",
-        "@zenstackhq/sdk": "workspace:*",
-        "async-exit-hook": "^2.0.1",
-        colors: "1.4.0",
-        commander: "^8.3.0",
-        langium: "~3.3.0",
-        ora: "^5.4.1",
-        "package-manager-detector": "^1.3.0",
-        "tiny-invariant": "^1.3.3",
-        "ts-pattern": "^4.3.0"
-      },
-      peerDependencies: {
-        prisma: "^6.0.0",
-        typescript: "^5.0.0"
-      },
-      devDependencies: {
-        "@types/async-exit-hook": "^2.0.0",
-        "@types/better-sqlite3": "^7.6.13",
-        "@types/semver": "^7.3.13",
-        "@types/tmp": "^0.2.6",
-        "@zenstackhq/runtime": "workspace:*",
-        "@zenstackhq/testtools": "workspace:*",
-        "better-sqlite3": "^11.8.1",
-        tmp: "^0.2.3"
-      }
-    };
-  }
-});
-
 // src/index.ts
 import { ZModelLanguageMetaData } from "@zenstackhq/language";
-import colors5 from "colors";
-import { Command, Option } from "commander";
+import colors6 from "colors";
+import { Command, CommanderError, Option } from "commander";
 
 // src/actions/db.ts
-import path2 from "node:path";
+import fs2 from "fs";
 
 // src/utils/exec-utils.ts
 import { execSync as _exec } from "child_process";
@@ -105,7 +36,12 @@ function execPackage(cmd, options) {
 __name(execPackage, "execPackage");
 
 // src/actions/action-utils.ts
-import fs from "node:fs";
+import { loadDocument } from "@zenstackhq/language";
+import { isDataSource } from "@zenstackhq/language/ast";
+import { PrismaSchemaGenerator } from "@zenstackhq/sdk";
+import colors from "colors";
+import fs from "fs";
+import path from "path";
 
 // src/cli-error.ts
 var CliError = class extends Error {
@@ -115,8 +51,6 @@ var CliError = class extends Error {
 };
 
 // src/actions/action-utils.ts
-import { loadDocument } from "@zenstackhq/language";
-import colors from "colors";
 function getSchemaFile(file) {
   if (file) {
     if (!fs.existsSync(file)) {
@@ -124,6 +58,13 @@ function getSchemaFile(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}`);
+    }
+    return pkgJsonConfig.schema;
+  }
   if (fs.existsSync("./zenstack/schema.zmodel")) {
     return "./zenstack/schema.zmodel";
   } else if (fs.existsSync("./schema.zmodel")) {
@@ -136,12 +77,14 @@ __name(getSchemaFile, "getSchemaFile");
 async function loadSchemaDocument(schemaFile) {
   const loadResult = await loadDocument(schemaFile);
   if (!loadResult.success) {
-    console.error(colors.red("Error loading schema:"));
     loadResult.errors.forEach((err) => {
       console.error(colors.red(err));
     });
-    throw new CliError("Failed to load schema");
+    throw new CliError("Schema contains errors. See above for details.");
   }
+  loadResult.warnings.forEach((warn) => {
+    console.warn(colors.yellow(warn));
+  });
   return loadResult.model;
 }
 __name(loadSchemaDocument, "loadSchemaDocument");
@@ -153,90 +96,272 @@ function handleSubProcessError(err) {
   }
 }
 __name(handleSubProcessError, "handleSubProcessError");
+async function generateTempPrismaSchema(zmodelPath, folder) {
+  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;
+}
+__name(generateTempPrismaSchema, "generateTempPrismaSchema");
+function getPkgJsonConfig(startPath) {
+  const result = {
+    schema: void 0,
+    output: void 0
+  };
+  const pkgJsonFile = findUp([
+    "package.json"
+  ], startPath, false);
+  if (!pkgJsonFile) {
+    return result;
+  }
+  let pkgJson = void 0;
+  try {
+    pkgJson = JSON.parse(fs.readFileSync(pkgJsonFile, "utf8"));
+  } catch {
+    return result;
+  }
+  if (pkgJson.zenstack && typeof pkgJson.zenstack === "object") {
+    result.schema = pkgJson.zenstack.schema && path.resolve(path.dirname(pkgJsonFile), pkgJson.zenstack.schema);
+    result.output = pkgJson.zenstack.output && path.resolve(path.dirname(pkgJsonFile), pkgJson.zenstack.output);
+  }
+  return result;
+}
+__name(getPkgJsonConfig, "getPkgJsonConfig");
+function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
+  if (!names.some((name) => !!name)) {
+    return void 0;
+  }
+  const target = names.find((name) => fs.existsSync(path.join(cwd, name)));
+  if (multiple === false && target) {
+    return path.join(cwd, target);
+  }
+  if (target) {
+    result.push(path.join(cwd, target));
+  }
+  const up = path.resolve(cwd, "..");
+  if (up === cwd) {
+    return multiple && result.length > 0 ? result : void 0;
+  }
+  return findUp(names, up, multiple, result);
+}
+__name(findUp, "findUp");
+
+// src/actions/db.ts
+async function run(command, options) {
+  switch (command) {
+    case "push":
+      await runPush(options);
+      break;
+  }
+}
+__name(run, "run");
+async function runPush(options) {
+  const schemaFile = getSchemaFile(options.schema);
+  const prismaSchemaFile = await generateTempPrismaSchema(schemaFile);
+  try {
+    const cmd = [
+      "prisma db push",
+      ` --schema "${prismaSchemaFile}"`,
+      options.acceptDataLoss ? " --accept-data-loss" : "",
+      options.forceReset ? " --force-reset" : "",
+      " --skip-generate"
+    ].join("");
+    try {
+      await execPackage(cmd);
+    } catch (err) {
+      handleSubProcessError(err);
+    }
+  } finally {
+    if (fs2.existsSync(prismaSchemaFile)) {
+      fs2.unlinkSync(prismaSchemaFile);
+    }
+  }
+}
+__name(runPush, "runPush");
 
 // src/actions/generate.ts
+import { invariant } from "@zenstackhq/common-helpers";
 import { isPlugin } from "@zenstackhq/language/ast";
-import { PrismaSchemaGenerator, TsSchemaGenerator } from "@zenstackhq/sdk";
+import { getLiteral, getLiteralArray } from "@zenstackhq/language/utils";
 import colors2 from "colors";
-import fs2 from "node:fs";
-import path from "node:path";
-import invariant from "tiny-invariant";
-async function run(options) {
+import path4 from "path";
+import ora from "ora";
+
+// src/plugins/index.ts
+var plugins_exports = {};
+__export(plugins_exports, {
+  prisma: () => prisma_default,
+  typescript: () => typescript_default
+});
+
+// src/plugins/prisma.ts
+import { PrismaSchemaGenerator as PrismaSchemaGenerator2 } from "@zenstackhq/sdk";
+import fs3 from "fs";
+import path2 from "path";
+var plugin = {
+  name: "Prisma Schema Generator",
+  statusText: "Generating Prisma schema",
+  async generate({ model, schemaFile, defaultOutputPath, pluginOptions }) {
+    let outFile = path2.join(defaultOutputPath, "schema.prisma");
+    if (typeof pluginOptions["output"] === "string") {
+      outFile = path2.resolve(path2.dirname(schemaFile), pluginOptions["output"]);
+      if (!fs3.existsSync(path2.dirname(outFile))) {
+        fs3.mkdirSync(path2.dirname(outFile), {
+          recursive: true
+        });
+      }
+    }
+    const prismaSchema = await new PrismaSchemaGenerator2(model).generate();
+    fs3.writeFileSync(outFile, prismaSchema);
+  }
+};
+var prisma_default = plugin;
+
+// src/plugins/typescript.ts
+import { TsSchemaGenerator } from "@zenstackhq/sdk";
+import fs4 from "fs";
+import path3 from "path";
+var plugin2 = {
+  name: "TypeScript Schema Generator",
+  statusText: "Generating TypeScript schema",
+  async generate({ model, defaultOutputPath, pluginOptions }) {
+    let outDir = defaultOutputPath;
+    if (typeof pluginOptions["output"] === "string") {
+      outDir = path3.resolve(defaultOutputPath, pluginOptions["output"]);
+      if (!fs4.existsSync(outDir)) {
+        fs4.mkdirSync(outDir, {
+          recursive: true
+        });
+      }
+    }
+    await new 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 = options.output ?? path.dirname(schemaFile);
-  const tsSchemaFile = path.join(outputPath, "schema.ts");
-  await new TsSchemaGenerator().generate(schemaFile, [], tsSchemaFile);
-  await runPlugins(model, outputPath, tsSchemaFile);
-  const prismaSchema = await new PrismaSchemaGenerator(model).generate();
-  fs2.writeFileSync(path.join(outputPath, "schema.prisma"), prismaSchema);
-  if (!options.silent) {
-    console.log(colors2.green("Generation completed successfully."));
-    console.log(`You can now create a ZenStack client with it.
+  const outputPath = getOutputPath(options, schemaFile);
+  await runPlugins(schemaFile, model, outputPath);
+  console.log(colors2.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';
 import { schema } from '${outputPath}/schema';
 
 const client = new ZenStackClient(schema, {
-    dialectConfig: { ... } 
+    dialect: { ... }
 });
-\`\`\`
-`);
+\`\`\``);
+}
+__name(run2, "run");
+function getOutputPath(options, schemaFile) {
+  if (options.output) {
+    return options.output;
+  }
+  const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+  if (pkgJsonConfig.output) {
+    return pkgJsonConfig.output;
+  } else {
+    return path4.dirname(schemaFile);
   }
 }
-__name(run, "run");
-async function runPlugins(model, outputPath, tsSchemaFile) {
+__name(getOutputPath, "getOutputPath");
+async function runPlugins(schemaFile, model, outputPath) {
   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`);
-    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 = path4.resolve(path4.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)
     });
   }
-}
-__name(runPlugins, "runPlugins");
-
-// src/actions/db.ts
-async function run2(command, options) {
-  const schemaFile = getSchemaFile(options.schema);
-  await run({
-    schema: schemaFile,
-    silent: true
+  const defaultPlugins = [
+    typescript_default
+  ].reverse();
+  defaultPlugins.forEach((d) => {
+    if (!processedPlugins.some((p) => p.cliPlugin === d)) {
+      processedPlugins.push({
+        cliPlugin: d,
+        pluginOptions: {}
+      });
+    }
   });
-  const prismaSchemaFile = path2.join(path2.dirname(schemaFile), "schema.prisma");
-  switch (command) {
-    case "push":
-      await runPush(prismaSchemaFile, options);
-      break;
+  for (const { cliPlugin, pluginOptions } of processedPlugins) {
+    invariant(typeof cliPlugin.generate === "function", `Plugin ${cliPlugin.name} does not have a generate function`);
+    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);
+    }
   }
 }
-__name(run2, "run");
-async function runPush(prismaSchemaFile, options) {
-  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);
+__name(runPlugins, "runPlugins");
+function getPluginProvider(plugin3) {
+  const providerField = plugin3.fields.find((f) => f.name === "provider");
+  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 = getLiteral(field.value) ?? 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(runPush, "runPush");
+__name(getPluginOptions, "getPluginOptions");
 
 // src/actions/info.ts
 import colors3 from "colors";
-import path3 from "node:path";
+import path5 from "path";
 async function run3(projectPath) {
   const packages = await getZenStackPackages(projectPath);
   if (!packages) {
@@ -258,14 +383,14 @@ async function run3(projectPath) {
 __name(run3, "run");
 async function getZenStackPackages(projectPath) {
   let pkgJson;
-  const resolvedPath = path3.resolve(projectPath);
+  const resolvedPath = path5.resolve(projectPath);
   try {
-    pkgJson = (await import(path3.join(resolvedPath, "package.json"), {
+    pkgJson = (await import(path5.join(resolvedPath, "package.json"), {
       with: {
         type: "json"
       }
     })).default;
-  } catch (err) {
+  } catch {
     return [];
   }
   const packages = Array.from(new Set([
@@ -296,9 +421,9 @@ __name(getZenStackPackages, "getZenStackPackages");
 
 // src/actions/init.ts
 import colors4 from "colors";
-import fs3 from "node:fs";
-import path4 from "node:path";
-import ora from "ora";
+import fs5 from "fs";
+import path6 from "path";
+import ora2 from "ora";
 import { detect, resolveCommand } from "package-manager-detector";
 
 // src/actions/templates.ts
@@ -360,7 +485,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 = ora(`Installing "${pkg.name}"`).start();
+    const spinner = ora2(`Installing "${pkg.name}"`).start();
     try {
       execSync(`${resolved.command} ${resolved.args.join(" ")}`, {
         cwd: projectPath
@@ -372,11 +497,11 @@ async function run4(projectPath) {
     }
   }
   const generationFolder = "zenstack";
-  if (!fs3.existsSync(path4.join(projectPath, generationFolder))) {
-    fs3.mkdirSync(path4.join(projectPath, generationFolder));
+  if (!fs5.existsSync(path6.join(projectPath, generationFolder))) {
+    fs5.mkdirSync(path6.join(projectPath, generationFolder));
   }
-  if (!fs3.existsSync(path4.join(projectPath, generationFolder, "schema.zmodel"))) {
-    fs3.writeFileSync(path4.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
+  if (!fs5.existsSync(path6.join(projectPath, generationFolder, "schema.zmodel"))) {
+    fs5.writeFileSync(path6.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
   } else {
     console.log(colors4.yellow("Schema file already exists. Skipping generation of sample."));
   }
@@ -387,35 +512,47 @@ async function run4(projectPath) {
 __name(run4, "run");
 
 // src/actions/migrate.ts
-import path5 from "node:path";
+import fs6 from "fs";
+import path7 from "path";
 async function run5(command, options) {
   const schemaFile = getSchemaFile(options.schema);
-  await run({
-    schema: schemaFile,
-    silent: true
-  });
-  const prismaSchemaFile = path5.join(path5.dirname(schemaFile), "schema.prisma");
-  switch (command) {
-    case "dev":
-      await runDev(prismaSchemaFile, options);
-      break;
-    case "reset":
-      await runReset(prismaSchemaFile, options);
-      break;
-    case "deploy":
-      await runDeploy(prismaSchemaFile, options);
-      break;
-    case "status":
-      await runStatus(prismaSchemaFile, options);
-      break;
+  const prismaSchemaDir = options.migrations ? path7.dirname(options.migrations) : void 0;
+  const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
+  try {
+    switch (command) {
+      case "dev":
+        await runDev(prismaSchemaFile, options);
+        break;
+      case "reset":
+        await runReset(prismaSchemaFile, options);
+        break;
+      case "deploy":
+        await runDeploy(prismaSchemaFile, options);
+        break;
+      case "status":
+        await runStatus(prismaSchemaFile, options);
+        break;
+      case "resolve":
+        await runResolve(prismaSchemaFile, options);
+        break;
+    }
+  } finally {
+    if (fs6.existsSync(prismaSchemaFile)) {
+      fs6.unlinkSync(prismaSchemaFile);
+    }
   }
 }
 __name(run5, "run");
-async function runDev(prismaSchemaFile, _options) {
+async function runDev(prismaSchemaFile, options) {
   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) {
     handleSubProcessError2(err);
   }
@@ -423,9 +560,12 @@ async function runDev(prismaSchemaFile, _options) {
 __name(runDev, "runDev");
 async function runReset(prismaSchemaFile, options) {
   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) {
     handleSubProcessError2(err);
   }
@@ -433,9 +573,11 @@ async function runReset(prismaSchemaFile, options) {
 __name(runReset, "runReset");
 async function runDeploy(prismaSchemaFile, _options) {
   try {
-    await execPackage(`prisma migrate deploy --schema "${prismaSchemaFile}"`, {
-      stdio: "inherit"
-    });
+    const cmd = [
+      "prisma migrate deploy",
+      ` --schema "${prismaSchemaFile}"`
+    ].join("");
+    await execPackage(cmd);
   } catch (err) {
     handleSubProcessError2(err);
   }
@@ -443,14 +585,29 @@ async function runDeploy(prismaSchemaFile, _options) {
 __name(runDeploy, "runDeploy");
 async function runStatus(prismaSchemaFile, _options) {
   try {
-    await execPackage(`prisma migrate status --schema "${prismaSchemaFile}"`, {
-      stdio: "inherit"
-    });
+    await execPackage(`prisma migrate status --schema "${prismaSchemaFile}"`);
   } catch (err) {
     handleSubProcessError2(err);
   }
 }
 __name(runStatus, "runStatus");
+async function runResolve(prismaSchemaFile, options) {
+  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) {
+    handleSubProcessError2(err);
+  }
+}
+__name(runResolve, "runResolve");
 function handleSubProcessError2(err) {
   if (err instanceof Error && "status" in err && typeof err.status === "number") {
     process.exit(err.status);
@@ -460,29 +617,43 @@ function handleSubProcessError2(err) {
 }
 __name(handleSubProcessError2, "handleSubProcessError");
 
+// src/actions/check.ts
+import colors5 from "colors";
+async function run6(options) {
+  const schemaFile = getSchemaFile(options.schema);
+  try {
+    await loadSchemaDocument(schemaFile);
+    console.log(colors5.green("\u2713 Schema validation completed successfully."));
+  } catch (error) {
+    console.error(colors5.red("\u2717 Schema validation failed."));
+    throw error;
+  }
+}
+__name(run6, "run");
+
 // src/utils/version-utils.ts
+import fs7 from "fs";
+import path8 from "path";
+import { fileURLToPath } from "url";
 function getVersion() {
   try {
-    return __require("../package.json").version;
+    const _dirname = typeof __dirname !== "undefined" ? __dirname : path8.dirname(fileURLToPath(import.meta.url));
+    return JSON.parse(fs7.readFileSync(path8.join(_dirname, "../package.json"), "utf8")).version;
   } catch {
-    try {
-      return require_package().version;
-    } catch {
-      return void 0;
-    }
+    return void 0;
   }
 }
 __name(getVersion, "getVersion");
 
 // src/index.ts
 var generateAction = /* @__PURE__ */ __name(async (options) => {
-  await run(options);
+  await run2(options);
 }, "generateAction");
 var migrateAction = /* @__PURE__ */ __name(async (command, options) => {
   await run5(command, options);
 }, "migrateAction");
 var dbAction = /* @__PURE__ */ __name(async (command, options) => {
-  await run2(command, options);
+  await run(command, options);
 }, "dbAction");
 var infoAction = /* @__PURE__ */ __name(async (projectPath) => {
   await run3(projectPath);
@@ -490,29 +661,46 @@ var infoAction = /* @__PURE__ */ __name(async (projectPath) => {
 var initAction = /* @__PURE__ */ __name(async (projectPath) => {
   await run4(projectPath);
 }, "initAction");
+var checkAction = /* @__PURE__ */ __name(async (options) => {
+  await run6(options);
+}, "checkAction");
 function createProgram() {
   const program2 = new Command("zenstack");
   program2.version(getVersion(), "-v --version", "display CLI version");
   const schemaExtensions = ZModelLanguageMetaData.fileExtensions.join(", ");
-  program2.description(`${colors5.bold.blue("\u03B6")} ZenStack is a Prisma power pack for building full-stack apps.
+  program2.description(`${colors6.bold.blue("\u03B6")} ZenStack is the data layer for modern TypeScript apps.
 
 Documentation: 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.`);
-  program2.command("generate").description("Run code generation.").addOption(schemaOption).addOption(new Option("-o, --output <path>", "default output directory for core plugins")).action(generateAction);
-  const migrateCommand = program2.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.").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.").action((options) => migrateAction("reset", options));
-  migrateCommand.command("deploy").addOption(schemaOption).description("Deploy your pending migrations to your production/staging database.").action((options) => migrateAction("deploy", options));
-  migrateCommand.command("status").addOption(schemaOption).description("check the status of your database migrations.").action((options) => migrateAction("status", options));
+  const schemaOption = new 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 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 Option("--migrations <path>", 'path that contains the "migrations" directory');
+  migrateCommand.command("dev").addOption(schemaOption).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).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 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 = 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 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));
-  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 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));
+  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("check").description("Check a ZModel schema for syntax or semantic errors.").addOption(schemaOption).action(checkAction);
   return program2;
 }
 __name(createProgram, "createProgram");
 var program = createProgram();
-program.parse(process.argv);
+program.parseAsync().catch((err) => {
+  if (err instanceof CliError) {
+    console.error(colors6.red(err.message));
+    process.exit(1);
+  } else if (err instanceof CommanderError) {
+    process.exit(err.exitCode);
+  } else {
+    console.error(colors6.red("An unexpected error occurred:"));
+    console.error(err);
+    process.exit(1);
+  }
+});
 export {
   createProgram
 };