@zenstackhq/cli 3.0.0-alpha.9 → 3.0.0-beta.2

package/dist/index.cjs

@@ -26,16 +26,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  createProgram: () => createProgram
-});
-module.exports = __toCommonJS(src_exports);
 var import_language2 = require("@zenstackhq/language");
-var import_colors5 = __toESM(require("colors"), 1);
+var import_colors7 = __toESM(require("colors"), 1);
 var import_commander = require("commander");
 
 // src/actions/db.ts
@@ -44,10 +38,10 @@ var import_node_fs2 = __toESM(require("fs"), 1);
 // src/utils/exec-utils.ts
 var import_child_process = require("child_process");
 function execSync(cmd, options) {
-  const { env, ...restOptions } = options ?? {};
-  const mergedEnv = env ? {
+  const { env: env2, ...restOptions } = options ?? {};
+  const mergedEnv = env2 ? {
     ...process.env,
-    ...env
+    ...env2
   } : void 0;
   (0, import_child_process.execSync)(cmd, {
     encoding: "utf-8",
@@ -65,6 +59,7 @@ __name(execPackage, "execPackage");
 
 // src/actions/action-utils.ts
 var import_language = require("@zenstackhq/language");
+var import_ast = require("@zenstackhq/language/ast");
 var import_sdk = require("@zenstackhq/sdk");
 var import_colors = __toESM(require("colors"), 1);
 var import_node_fs = __toESM(require("fs"), 1);
@@ -85,6 +80,13 @@ function getSchemaFile(file) {
     }
     return file;
   }
+  const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+  if (pkgJsonConfig.schema) {
+    if (!import_node_fs.default.existsSync(pkgJsonConfig.schema)) {
+      throw new CliError(`Schema file not found: ${pkgJsonConfig.schema}`);
+    }
+    return pkgJsonConfig.schema;
+  }
   if (import_node_fs.default.existsSync("./zenstack/schema.zmodel")) {
     return "./zenstack/schema.zmodel";
   } else if (import_node_fs.default.existsSync("./schema.zmodel")) {
@@ -97,12 +99,14 @@ __name(getSchemaFile, "getSchemaFile");
 async function loadSchemaDocument(schemaFile) {
   const loadResult = await (0, import_language.loadDocument)(schemaFile);
   if (!loadResult.success) {
-    console.error(import_colors.default.red("Error loading schema:"));
     loadResult.errors.forEach((err) => {
       console.error(import_colors.default.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(import_colors.default.yellow(warn));
+  });
   return loadResult.model;
 }
 __name(loadSchemaDocument, "loadSchemaDocument");
@@ -114,14 +118,62 @@ function handleSubProcessError(err) {
   }
 }
 __name(handleSubProcessError, "handleSubProcessError");
-async function generateTempPrismaSchema(zmodelPath) {
+async function generateTempPrismaSchema(zmodelPath, folder) {
   const model = await loadSchemaDocument(zmodelPath);
+  if (!model.declarations.some(import_ast.isDataSource)) {
+    throw new CliError("Schema must define a datasource");
+  }
   const prismaSchema = await new import_sdk.PrismaSchemaGenerator(model).generate();
-  const prismaSchemaFile = import_node_path.default.resolve(import_node_path.default.dirname(zmodelPath), "~schema.prisma");
+  if (!folder) {
+    folder = import_node_path.default.dirname(zmodelPath);
+  }
+  const prismaSchemaFile = import_node_path.default.resolve(folder, "~schema.prisma");
   import_node_fs.default.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(import_node_fs.default.readFileSync(pkgJsonFile, "utf8"));
+  } catch {
+    return result;
+  }
+  if (pkgJson.zenstack && typeof pkgJson.zenstack === "object") {
+    result.schema = pkgJson.zenstack.schema && import_node_path.default.resolve(import_node_path.default.dirname(pkgJsonFile), pkgJson.zenstack.schema);
+    result.output = pkgJson.zenstack.output && import_node_path.default.resolve(import_node_path.default.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) => import_node_fs.default.existsSync(import_node_path.default.join(cwd, name)));
+  if (multiple === false && target) {
+    return import_node_path.default.join(cwd, target);
+  }
+  if (target) {
+    result.push(import_node_path.default.join(cwd, target));
+  }
+  const up = import_node_path.default.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) {
@@ -136,11 +188,15 @@ 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`;
+    const cmd = [
+      "prisma db push",
+      ` --schema "${prismaSchemaFile}"`,
+      options.acceptDataLoss ? " --accept-data-loss" : "",
+      options.forceReset ? " --force-reset" : "",
+      " --skip-generate"
+    ].join("");
     try {
-      await execPackage(cmd, {
-        stdio: "inherit"
-      });
+      await execPackage(cmd);
     } catch (err) {
       handleSubProcessError(err);
     }
@@ -154,31 +210,74 @@ __name(runPush, "runPush");
 
 // src/actions/generate.ts
 var import_common_helpers = require("@zenstackhq/common-helpers");
-var import_ast = require("@zenstackhq/language/ast");
-var import_sdk2 = require("@zenstackhq/sdk");
+var import_ast2 = require("@zenstackhq/language/ast");
+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);
-async function run2(options) {
-  const schemaFile = getSchemaFile(options.schema);
-  const model = await loadSchemaDocument(schemaFile);
-  const outputPath = options.output ?? import_node_path2.default.dirname(schemaFile);
-  const tsSchemaFile = import_node_path2.default.join(outputPath, "schema.ts");
-  await new import_sdk2.TsSchemaGenerator().generate(schemaFile, [], tsSchemaFile);
-  await runPlugins(model, outputPath, tsSchemaFile);
-  if (options.savePrismaSchema) {
+var plugin = {
+  name: "Prisma Schema Generator",
+  statusText: "Generating Prisma schema",
+  async generate({ model, schemaFile, defaultOutputPath, pluginOptions }) {
+    let outFile = import_node_path2.default.join(defaultOutputPath, "schema.prisma");
+    if (typeof pluginOptions["output"] === "string") {
+      outFile = import_node_path2.default.resolve(import_node_path2.default.dirname(schemaFile), pluginOptions["output"]);
+      if (!import_node_fs3.default.existsSync(import_node_path2.default.dirname(outFile))) {
+        import_node_fs3.default.mkdirSync(import_node_path2.default.dirname(outFile), {
+          recursive: true
+        });
+      }
+    }
     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(outFile, 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
+        });
+      }
     }
-    import_node_fs3.default.writeFileSync(prismaSchemaFile, prismaSchema);
+    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);
+  await runPlugins(schemaFile, model, outputPath, options);
   if (!options.silent) {
-    console.log(import_colors2.default.green("Generation completed successfully."));
+    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
@@ -186,37 +285,112 @@ import { ZenStackClient } from '@zenstackhq/runtime';
 import { schema } from '${outputPath}/schema';
 
 const client = new ZenStackClient(schema, {
-    dialectConfig: { ... }
+    dialect: { ... }
 });
 \`\`\`
-`);
+
+Check documentation: https://zenstack.dev/docs/3.x`);
   }
 }
 __name(run2, "run");
-async function runPlugins(model, outputPath, tsSchemaFile) {
-  const plugins = model.declarations.filter(import_ast.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)}`;
+function getOutputPath(options, schemaFile) {
+  if (options.output) {
+    return options.output;
+  }
+  const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+  if (pkgJsonConfig.output) {
+    return pkgJsonConfig.output;
+  } else {
+    return import_node_path4.default.dirname(schemaFile);
+  }
+}
+__name(getOutputPath, "getOutputPath");
+async function runPlugins(schemaFile, model, outputPath, options) {
+  const plugins = model.declarations.filter(import_ast2.isPlugin);
+  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`);
+    let spinner;
+    if (!options.silent) {
+      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) {
@@ -225,11 +399,11 @@ async function run3(projectPath) {
   }
   console.log("Installed ZenStack Packages:");
   const versions = /* @__PURE__ */ new Set();
-  for (const { pkg, version } of packages) {
-    if (version) {
-      versions.add(version);
+  for (const { pkg, version: version2 } of packages) {
+    if (version2) {
+      versions.add(version2);
     }
-    console.log(`    ${import_colors3.default.green(pkg.padEnd(20))}	${version}`);
+    console.log(`    ${import_colors3.default.green(pkg.padEnd(20))}	${version2}`);
   }
   if (versions.size > 1) {
     console.warn(import_colors3.default.yellow("WARNING: Multiple versions of Zenstack packages detected. This may cause issues."));
@@ -238,9 +412,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"
       }
@@ -259,6 +433,9 @@ async function getZenStackPackages(projectPath) {
           type: "json"
         }
       })).default;
+      if (depPkgJson.private) {
+        return void 0;
+      }
       return {
         pkg,
         version: depPkgJson.version
@@ -270,15 +447,15 @@ async function getZenStackPackages(projectPath) {
       };
     }
   }));
-  return result;
+  return result.filter((p) => !!p);
 }
 __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
@@ -340,7 +517,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
@@ -352,11 +529,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."));
   }
@@ -367,10 +544,12 @@ async function run4(projectPath) {
 __name(run4, "run");
 
 // src/actions/migrate.ts
-var import_node_fs5 = __toESM(require("fs"), 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 prismaSchemaFile = await generateTempPrismaSchema(schemaFile);
+  const prismaSchemaDir = options.migrations ? import_node_path7.default.dirname(options.migrations) : void 0;
+  const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
   try {
     switch (command) {
       case "dev":
@@ -385,19 +564,27 @@ async function run5(command, options) {
       case "status":
         await runStatus(prismaSchemaFile, options);
         break;
+      case "resolve":
+        await runResolve(prismaSchemaFile, 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);
     }
   }
 }
 __name(run5, "run");
 async function runDev(prismaSchemaFile, options) {
   try {
-    await execPackage(`prisma migrate dev --schema "${prismaSchemaFile}" --skip-generate${options.name ? ` --name ${options.name}` : ""}${options.createOnly ? " --create-only" : ""}`, {
-      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);
   }
@@ -405,9 +592,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);
   }
@@ -415,9 +605,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);
   }
@@ -425,14 +617,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);
@@ -442,62 +649,385 @@ function handleSubProcessError2(err) {
 }
 __name(handleSubProcessError2, "handleSubProcessError");
 
+// src/actions/check.ts
+var import_colors5 = __toESM(require("colors"), 1);
+async function run6(options) {
+  const schemaFile = getSchemaFile(options.schema);
+  try {
+    await loadSchemaDocument(schemaFile);
+    console.log(import_colors5.default.green("\u2713 Schema validation completed successfully."));
+  } catch (error) {
+    console.error(import_colors5.default.red("\u2717 Schema validation failed."));
+    throw error;
+  }
+}
+__name(run6, "run");
+
+// src/telemetry.ts
+var import_mixpanel = require("mixpanel");
+var import_node_crypto2 = require("crypto");
+var import_node_fs11 = __toESM(require("fs"), 1);
+var os2 = __toESM(require("os"), 1);
+
+// src/constants.ts
+var TELEMETRY_TRACKING_TOKEN = "<TELEMETRY_TRACKING_TOKEN>";
+
+// src/utils/is-ci.ts
+var import_node_process = require("process");
+var isInCi = import_node_process.env["CI"] !== "0" && import_node_process.env["CI"] !== "false" && ("CI" in import_node_process.env || "CONTINUOUS_INTEGRATION" in import_node_process.env || Object.keys(import_node_process.env).some((key) => key.startsWith("CI_")));
+
+// src/utils/is-container.ts
+var import_node_fs8 = __toESM(require("fs"), 1);
+
+// src/utils/is-docker.ts
+var import_node_fs7 = __toESM(require("fs"), 1);
+var isDockerCached;
+function hasDockerEnv() {
+  try {
+    import_node_fs7.default.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(hasDockerEnv, "hasDockerEnv");
+function hasDockerCGroup() {
+  try {
+    return import_node_fs7.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+__name(hasDockerCGroup, "hasDockerCGroup");
+function isDocker() {
+  if (isDockerCached === void 0) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+__name(isDocker, "isDocker");
+
+// src/utils/is-container.ts
+var cachedResult;
+var hasContainerEnv = /* @__PURE__ */ __name(() => {
+  try {
+    import_node_fs8.default.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}, "hasContainerEnv");
+function isInContainer() {
+  if (cachedResult === void 0) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+__name(isInContainer, "isInContainer");
+
+// src/utils/is-wsl.ts
+var import_node_process2 = __toESM(require("process"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
+var isWsl = /* @__PURE__ */ __name(() => {
+  if (import_node_process2.default.platform !== "linux") {
+    return false;
+  }
+  if (import_node_os.default.release().toLowerCase().includes("microsoft")) {
+    return true;
+  }
+  try {
+    return import_node_fs9.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+  } catch {
+    return false;
+  }
+}, "isWsl");
+
+// src/utils/machine-id-utils.ts
+var import_child_process2 = require("child_process");
+var import_node_crypto = require("crypto");
+var { platform } = process;
+var win32RegBinPath = {
+  native: "%windir%\\System32",
+  mixed: "%windir%\\sysnative\\cmd.exe /c %windir%\\System32"
+};
+var guid = {
+  darwin: "ioreg -rd1 -c IOPlatformExpertDevice",
+  win32: `${win32RegBinPath[isWindowsProcessMixedOrNativeArchitecture()]}\\REG.exe QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid`,
+  linux: "( cat /var/lib/dbus/machine-id /etc/machine-id 2> /dev/null || hostname 2> /dev/null) | head -n 1 || :",
+  freebsd: "kenv -q smbios.system.uuid || sysctl -n kern.hostuuid"
+};
+function isWindowsProcessMixedOrNativeArchitecture() {
+  if (process.arch === "ia32" && process.env.hasOwnProperty("PROCESSOR_ARCHITEW6432")) {
+    return "mixed";
+  }
+  return "native";
+}
+__name(isWindowsProcessMixedOrNativeArchitecture, "isWindowsProcessMixedOrNativeArchitecture");
+function hash(guid2) {
+  return (0, import_node_crypto.createHash)("sha256").update(guid2).digest("hex");
+}
+__name(hash, "hash");
+function expose(result) {
+  switch (platform) {
+    case "darwin":
+      return result.split("IOPlatformUUID")[1]?.split("\n")[0]?.replace(/=|\s+|"/gi, "").toLowerCase();
+    case "win32":
+      return result.toString().split("REG_SZ")[1]?.replace(/\r+|\n+|\s+/gi, "").toLowerCase();
+    case "linux":
+      return result.toString().replace(/\r+|\n+|\s+/gi, "").toLowerCase();
+    case "freebsd":
+      return result.toString().replace(/\r+|\n+|\s+/gi, "").toLowerCase();
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+__name(expose, "expose");
+function getMachineId() {
+  if (!(platform in guid)) {
+    return (0, import_node_crypto.randomUUID)();
+  }
+  try {
+    const value = (0, import_child_process2.execSync)(guid[platform]);
+    const id = expose(value.toString());
+    if (!id) {
+      return (0, import_node_crypto.randomUUID)();
+    }
+    return hash(id);
+  } catch {
+    return (0, import_node_crypto.randomUUID)();
+  }
+}
+__name(getMachineId, "getMachineId");
+
 // src/utils/version-utils.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_colors6 = __toESM(require("colors"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var import_node_url = require("url");
+var import_semver = __toESM(require("semver"), 1);
 var import_meta = {};
+var CHECK_VERSION_TIMEOUT = 2e3;
+var VERSION_CHECK_TAG = "next";
 function getVersion() {
   try {
-    const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path5.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
-    return JSON.parse(import_node_fs6.default.readFileSync(import_node_path5.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_fs10.default.readFileSync(import_node_path8.default.join(_dirname, "../package.json"), "utf8")).version;
   } catch {
     return void 0;
   }
 }
 __name(getVersion, "getVersion");
+async function checkNewVersion() {
+  const currVersion = getVersion();
+  let latestVersion;
+  try {
+    latestVersion = await getLatestVersion();
+  } catch {
+    return;
+  }
+  if (latestVersion && currVersion && import_semver.default.gt(latestVersion, currVersion)) {
+    console.log(`A newer version ${import_colors6.default.cyan(latestVersion)} is available.`);
+  }
+}
+__name(checkNewVersion, "checkNewVersion");
+async function getLatestVersion() {
+  const fetchResult = await fetch(`https://registry.npmjs.org/@zenstackhq/cli/${VERSION_CHECK_TAG}`, {
+    headers: {
+      accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+    },
+    signal: AbortSignal.timeout(CHECK_VERSION_TIMEOUT)
+  });
+  if (fetchResult.ok) {
+    const data = await fetchResult.json();
+    const latestVersion = data?.version;
+    if (typeof latestVersion === "string" && import_semver.default.valid(latestVersion)) {
+      return latestVersion;
+    }
+  }
+  throw new Error("invalid npm registry response");
+}
+__name(getLatestVersion, "getLatestVersion");
+
+// src/telemetry.ts
+var import_meta2 = {};
+var Telemetry = class {
+  static {
+    __name(this, "Telemetry");
+  }
+  mixpanel;
+  hostId = getMachineId();
+  sessionid = (0, import_node_crypto2.randomUUID)();
+  _os_type = os2.type();
+  _os_release = os2.release();
+  _os_arch = os2.arch();
+  _os_version = os2.version();
+  _os_platform = os2.platform();
+  version = getVersion();
+  prismaVersion = this.getPrismaVersion();
+  isDocker = isDocker();
+  isWsl = isWsl();
+  isContainer = isInContainer();
+  isCi = isInCi;
+  constructor() {
+    if (process.env["DO_NOT_TRACK"] !== "1" && TELEMETRY_TRACKING_TOKEN) {
+      this.mixpanel = (0, import_mixpanel.init)(TELEMETRY_TRACKING_TOKEN, {
+        geolocate: true
+      });
+    }
+  }
+  get isTracking() {
+    return !!this.mixpanel;
+  }
+  track(event, properties = {}) {
+    if (this.mixpanel) {
+      const payload = {
+        distinct_id: this.hostId,
+        session: this.sessionid,
+        time: /* @__PURE__ */ new Date(),
+        $os: this._os_type,
+        osType: this._os_type,
+        osRelease: this._os_release,
+        osPlatform: this._os_platform,
+        osArch: this._os_arch,
+        osVersion: this._os_version,
+        nodeVersion: process.version,
+        version: this.version,
+        prismaVersion: this.prismaVersion,
+        isDocker: this.isDocker,
+        isWsl: this.isWsl,
+        isContainer: this.isContainer,
+        isCi: this.isCi,
+        ...properties
+      };
+      this.mixpanel.track(event, payload);
+    }
+  }
+  trackError(err) {
+    this.track("cli:error", {
+      message: err.message,
+      stack: err.stack
+    });
+  }
+  async trackSpan(startEvent, completeEvent, errorEvent, properties, action) {
+    this.track(startEvent, properties);
+    const start = Date.now();
+    let success = true;
+    try {
+      return await action();
+    } catch (err) {
+      this.track(errorEvent, {
+        message: err.message,
+        stack: err.stack,
+        ...properties
+      });
+      success = false;
+      throw err;
+    } finally {
+      this.track(completeEvent, {
+        duration: Date.now() - start,
+        success,
+        ...properties
+      });
+    }
+  }
+  async trackCommand(command, action) {
+    await this.trackSpan("cli:command:start", "cli:command:complete", "cli:command:error", {
+      command
+    }, action);
+  }
+  async trackCli(action) {
+    await this.trackSpan("cli:start", "cli:complete", "cli:error", {}, action);
+  }
+  getPrismaVersion() {
+    try {
+      const packageJsonPath = import_meta2.resolve("prisma/package.json");
+      const packageJsonUrl = new URL(packageJsonPath);
+      const packageJson = JSON.parse(import_node_fs11.default.readFileSync(packageJsonUrl, "utf8"));
+      return packageJson.version;
+    } catch {
+      return void 0;
+    }
+  }
+};
+var telemetry = new Telemetry();
 
 // src/index.ts
 var generateAction = /* @__PURE__ */ __name(async (options) => {
-  await run2(options);
+  await telemetry.trackCommand("generate", () => run2(options));
 }, "generateAction");
-var migrateAction = /* @__PURE__ */ __name(async (command, options) => {
-  await run5(command, options);
+var migrateAction = /* @__PURE__ */ __name(async (subCommand, options) => {
+  await telemetry.trackCommand(`migrate ${subCommand}`, () => run5(subCommand, options));
 }, "migrateAction");
-var dbAction = /* @__PURE__ */ __name(async (command, options) => {
-  await run(command, options);
+var dbAction = /* @__PURE__ */ __name(async (subCommand, options) => {
+  await telemetry.trackCommand(`db ${subCommand}`, () => run(subCommand, options));
 }, "dbAction");
 var infoAction = /* @__PURE__ */ __name(async (projectPath) => {
-  await run3(projectPath);
+  await telemetry.trackCommand("info", () => run3(projectPath));
 }, "infoAction");
 var initAction = /* @__PURE__ */ __name(async (projectPath) => {
-  await run4(projectPath);
+  await telemetry.trackCommand("init", () => run4(projectPath));
 }, "initAction");
+var checkAction = /* @__PURE__ */ __name(async (options) => {
+  await telemetry.trackCommand("check", () => run6(options));
+}, "checkAction");
 function createProgram() {
-  const program2 = new import_commander.Command("zenstack");
-  program2.version(getVersion(), "-v --version", "display CLI version");
+  const program = new import_commander.Command("zen");
+  program.version(getVersion(), "-v --version", "display CLI version");
   const schemaExtensions = import_language2.ZModelLanguageMetaData.fileExtensions.join(", ");
-  program2.description(`${import_colors5.default.bold.blue("\u03B6")} ZenStack is a Prisma power pack for building full-stack 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.");
-  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")).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")).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 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);
-  program2.command("init").description("Initialize an existing project for ZenStack.").argument("[path]", "project path", ".").action(initAction);
-  return program2;
+  program.description(`${import_colors7.default.bold.blue("\u03B6")} ZenStack is the data layer for modern TypeScript apps.
+
+Documentation: https://zenstack.dev/docs/3.x`).showHelpAfterError().showSuggestionAfterError();
+  const schemaOption = new import_commander.Option("--schema <file>", `schema file (with extension ${schemaExtensions}). Defaults to "zenstack/schema.zmodel" unless specified in package.json.`);
+  const noVersionCheckOption = new import_commander.Option("--no-version-check", "do not check for new version");
+  program.command("generate").description("Run code generation plugins.").addOption(schemaOption).addOption(noVersionCheckOption).addOption(new import_commander.Option("-o, --output <path>", "default output directory for code generation")).addOption(new import_commander.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 import_commander.Option("--migrations <path>", 'path that contains the "migrations" directory');
+  migrateCommand.command("dev").addOption(schemaOption).addOption(noVersionCheckOption).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).addOption(noVersionCheckOption).description("Reset your database and apply all migrations, all data will be lost.").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 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 = 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 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));
+  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.hook("preAction", async (_thisCommand, actionCommand) => {
+    if (actionCommand.getOptionValue("versionCheck") !== false) {
+      await checkNewVersion();
+    }
+  });
+  return program;
 }
 __name(createProgram, "createProgram");
-var program = createProgram();
-program.parse(process.argv);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createProgram
-});
+async function main() {
+  let exitCode = 0;
+  const program = createProgram();
+  program.exitOverride();
+  try {
+    await telemetry.trackCli(async () => {
+      await program.parseAsync();
+    });
+  } catch (e) {
+    if (e instanceof import_commander.CommanderError) {
+      exitCode = e.exitCode;
+    } else if (e instanceof CliError) {
+      console.error(import_colors7.default.red(e.message));
+      exitCode = 1;
+    } else {
+      console.error(import_colors7.default.red(`Unhandled error: ${e}`));
+      exitCode = 1;
+    }
+  }
+  if (telemetry.isTracking) {
+    setTimeout(() => {
+      process.exit(exitCode);
+    }, 200);
+  } else {
+    process.exit(exitCode);
+  }
+}
+__name(main, "main");
+main();
 //# sourceMappingURL=index.cjs.map