@zenstackhq/cli 3.0.0-beta.8 → 3.0.0

package/dist/index.cjs

@@ -28,34 +28,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_language2 = require("@zenstackhq/language");
-var import_colors7 = __toESM(require("colors"), 1);
+var import_language3 = require("@zenstackhq/language");
+var import_colors9 = __toESM(require("colors"), 1);
 var import_commander = require("commander");
 
-// src/actions/db.ts
-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: env2, ...restOptions } = options ?? {};
-  const mergedEnv = env2 ? {
-    ...process.env,
-    ...env2
-  } : void 0;
-  (0, import_child_process.execSync)(cmd, {
-    encoding: "utf-8",
-    stdio: options?.stdio ?? "inherit",
-    env: mergedEnv,
-    ...restOptions
-  });
-}
-__name(execSync, "execSync");
-function execPackage(cmd, options) {
-  const packageManager = process?.versions?.["bun"] ? "bunx" : "npx";
-  execSync(`${packageManager} ${cmd}`, options);
-}
-__name(execPackage, "execPackage");
+// src/actions/check.ts
+var import_colors2 = __toESM(require("colors"), 1);
 
 // src/actions/action-utils.ts
 var import_language = require("@zenstackhq/language");
@@ -85,14 +63,22 @@ function getSchemaFile(file) {
     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.statSync(pkgJsonConfig.schema).isDirectory()) {
+      const schemaPath = import_node_path.default.join(pkgJsonConfig.schema, "schema.zmodel");
+      if (!import_node_fs.default.existsSync(schemaPath)) {
+        throw new CliError(`Schema file not found: ${schemaPath}`);
+      }
+      return schemaPath;
+    } else {
+      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")) {
+  if (import_node_fs.default.existsSync("./schema.zmodel")) {
     return "./schema.zmodel";
+  } else if (import_node_fs.default.existsSync("./zenstack/schema.zmodel")) {
+    return "./zenstack/schema.zmodel";
   } else {
-    throw new CliError('Schema file not found in default locations ("./zenstack/schema.zmodel" or "./schema.zmodel").');
+    throw new CliError('Schema file not found in default locations ("./schema.zmodel" or "./zenstack/schema.zmodel").');
   }
 }
 __name(getSchemaFile, "getSchemaFile");
@@ -135,7 +121,8 @@ __name(generateTempPrismaSchema, "generateTempPrismaSchema");
 function getPkgJsonConfig(startPath) {
   const result = {
     schema: void 0,
-    output: void 0
+    output: void 0,
+    seed: void 0
   };
   const pkgJsonFile = findUp([
     "package.json"
@@ -150,8 +137,9 @@ function getPkgJsonConfig(startPath) {
     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);
+    result.schema = pkgJson.zenstack.schema && typeof pkgJson.zenstack.schema === "string" ? import_node_path.default.resolve(import_node_path.default.dirname(pkgJsonFile), pkgJson.zenstack.schema) : void 0;
+    result.output = pkgJson.zenstack.output && typeof pkgJson.zenstack.output === "string" ? import_node_path.default.resolve(import_node_path.default.dirname(pkgJsonFile), pkgJson.zenstack.output) : void 0;
+    result.seed = typeof pkgJson.zenstack.seed === "string" && pkgJson.zenstack.seed ? pkgJson.zenstack.seed : void 0;
   }
   return result;
 }
@@ -174,29 +162,102 @@ function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
   return findUp(names, up, multiple, result);
 }
 __name(findUp, "findUp");
+async function requireDataSourceUrl(schemaFile) {
+  const zmodel = await loadSchemaDocument(schemaFile);
+  const dataSource = zmodel.declarations.find(import_ast.isDataSource);
+  if (!dataSource?.fields.some((f) => f.name === "url")) {
+    throw new CliError(`The schema's "datasource" must have a "url" field to use this command.`);
+  }
+}
+__name(requireDataSourceUrl, "requireDataSourceUrl");
+
+// src/actions/check.ts
+async function run(options) {
+  const schemaFile = getSchemaFile(options.schema);
+  try {
+    await loadSchemaDocument(schemaFile);
+    console.log(import_colors2.default.green("\u2713 Schema validation completed successfully."));
+  } catch (error) {
+    console.error(import_colors2.default.red("\u2717 Schema validation failed."));
+    throw error;
+  }
+}
+__name(run, "run");
 
 // src/actions/db.ts
-async function run(command, options) {
+var import_node_fs2 = __toESM(require("fs"), 1);
+
+// src/utils/exec-utils.ts
+var import_child_process = require("child_process");
+var import_url = require("url");
+var import_meta = {};
+function execSync(cmd, options) {
+  const { env: env2, ...restOptions } = options ?? {};
+  const mergedEnv = env2 ? {
+    ...process.env,
+    ...env2
+  } : void 0;
+  (0, import_child_process.execSync)(cmd, {
+    encoding: "utf-8",
+    stdio: options?.stdio ?? "inherit",
+    env: mergedEnv,
+    ...restOptions
+  });
+}
+__name(execSync, "execSync");
+function execPackage(cmd, options) {
+  const packageManager = process?.versions?.["bun"] ? "bunx" : "npx";
+  execSync(`${packageManager} ${cmd}`, options);
+}
+__name(execPackage, "execPackage");
+function execPrisma(args, options) {
+  let prismaPath;
+  try {
+    if (typeof import_meta.resolve === "function") {
+      prismaPath = (0, import_url.fileURLToPath)(import_meta.resolve("prisma/build/index.js"));
+    } else {
+      prismaPath = require.resolve("prisma/build/index.js");
+    }
+  } catch {
+  }
+  const _options = {
+    ...options,
+    env: {
+      ...options?.env,
+      PRISMA_HIDE_UPDATE_MESSAGE: "1"
+    }
+  };
+  if (!prismaPath) {
+    execPackage(`prisma ${args}`, _options);
+    return;
+  }
+  execSync(`node ${prismaPath} ${args}`, _options);
+}
+__name(execPrisma, "execPrisma");
+
+// src/actions/db.ts
+async function run2(command, options) {
   switch (command) {
     case "push":
       await runPush(options);
       break;
   }
 }
-__name(run, "run");
+__name(run2, "run");
 async function runPush(options) {
   const schemaFile = getSchemaFile(options.schema);
+  await requireDataSourceUrl(schemaFile);
   const prismaSchemaFile = await generateTempPrismaSchema(schemaFile);
   try {
     const cmd = [
-      "prisma db push",
+      "db push",
       ` --schema "${prismaSchemaFile}"`,
       options.acceptDataLoss ? " --accept-data-loss" : "",
       options.forceReset ? " --force-reset" : "",
       " --skip-generate"
     ].join("");
     try {
-      await execPackage(cmd);
+      execPrisma(cmd);
     } catch (err) {
       handleSubProcessError(err);
     }
@@ -208,12 +269,33 @@ async function runPush(options) {
 }
 __name(runPush, "runPush");
 
+// src/actions/format.ts
+var import_language2 = require("@zenstackhq/language");
+var import_colors3 = __toESM(require("colors"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+async function run3(options) {
+  const schemaFile = getSchemaFile(options.schema);
+  let formattedContent;
+  try {
+    formattedContent = await (0, import_language2.formatDocument)(import_node_fs3.default.readFileSync(schemaFile, "utf-8"));
+  } catch (error) {
+    console.error(import_colors3.default.red("\u2717 Schema formatting failed."));
+    throw error;
+  }
+  import_node_fs3.default.writeFileSync(schemaFile, formattedContent, "utf-8");
+  console.log(import_colors3.default.green("\u2713 Schema formatting completed successfully."));
+}
+__name(run3, "run");
+
 // src/actions/generate.ts
 var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_ast2 = require("@zenstackhq/language/ast");
 var import_utils = require("@zenstackhq/language/utils");
-var import_colors2 = __toESM(require("colors"), 1);
+var import_colors4 = __toESM(require("colors"), 1);
+var import_jiti = require("jiti");
+var import_node_fs6 = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
+var import_node_url = require("url");
 var import_ora = __toESM(require("ora"), 1);
 
 // src/plugins/index.ts
@@ -225,30 +307,30 @@ __export(plugins_exports, {
 
 // src/plugins/prisma.ts
 var import_sdk2 = require("@zenstackhq/sdk");
-var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_fs4 = __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, schemaFile, defaultOutputPath, pluginOptions }) {
+  async generate({ model, 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), {
+      outFile = import_node_path2.default.resolve(defaultOutputPath, pluginOptions["output"]);
+      if (!import_node_fs4.default.existsSync(import_node_path2.default.dirname(outFile))) {
+        import_node_fs4.default.mkdirSync(import_node_path2.default.dirname(outFile), {
           recursive: true
         });
       }
     }
     const prismaSchema = await new import_sdk2.PrismaSchemaGenerator(model).generate();
-    import_node_fs3.default.writeFileSync(outFile, prismaSchema);
+    import_node_fs4.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_fs5 = __toESM(require("fs"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
 var plugin2 = {
   name: "TypeScript Schema Generator",
@@ -257,32 +339,43 @@ var plugin2 = {
     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, {
+      if (!import_node_fs5.default.existsSync(outDir)) {
+        import_node_fs5.default.mkdirSync(outDir, {
           recursive: true
         });
       }
     }
-    await new import_sdk3.TsSchemaGenerator().generate(model, outDir);
+    const lite = pluginOptions["lite"] === true;
+    const liteOnly = pluginOptions["liteOnly"] === true;
+    const importWithFileExtension = pluginOptions["importWithFileExtension"];
+    if (importWithFileExtension && typeof importWithFileExtension !== "string") {
+      throw new Error('The "importWithFileExtension" option must be a string if specified.');
+    }
+    await new import_sdk3.TsSchemaGenerator().generate(model, {
+      outDir,
+      lite,
+      liteOnly,
+      importWithFileExtension
+    });
   }
 };
 var typescript_default = plugin2;
 
 // src/actions/generate.ts
-async function run2(options) {
+async function run4(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 in ${Date.now() - start}ms.
+    console.log(import_colors4.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';
-import { schema } from '${outputPath}/schema';
+import { ZenStackClient } from '@zenstackhq/orm';
+import { schema } from '${import_node_path4.default.relative(".", outputPath)}/schema';
 
 const client = new ZenStackClient(schema, {
     dialect: { ... }
@@ -292,7 +385,7 @@ const client = new ZenStackClient(schema, {
 Check documentation: https://zenstack.dev/docs/3.x`);
   }
 }
-__name(run2, "run");
+__name(run4, "run");
 function getOutputPath(options, schemaFile) {
   if (options.output) {
     return options.output;
@@ -317,29 +410,38 @@ async function runPlugins(schemaFile, model, outputPath, options) {
         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}`);
+      cliPlugin = await loadPluginModule(provider, import_node_path4.default.dirname(schemaFile));
+    }
+    if (cliPlugin) {
+      const pluginOptions = getPluginOptions(plugin3);
+      if (provider === "@core/typescript") {
+        if (pluginOptions["lite"] === void 0) {
+          pluginOptions["lite"] = options.lite;
+        }
+        if (pluginOptions["liteOnly"] === void 0) {
+          pluginOptions["liteOnly"] = options.liteOnly;
+        }
       }
+      processedPlugins.push({
+        cliPlugin,
+        pluginOptions
+      });
     }
-    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: {}
+    {
+      plugin: typescript_default,
+      options: {
+        lite: options.lite,
+        liteOnly: options.liteOnly
+      }
+    }
+  ];
+  defaultPlugins.forEach(({ plugin: plugin3, options: options2 }) => {
+    if (!processedPlugins.some((p) => p.cliPlugin === plugin3)) {
+      processedPlugins.unshift({
+        cliPlugin: plugin3,
+        pluginOptions: options2
       });
     }
   });
@@ -387,11 +489,70 @@ function getPluginOptions(plugin3) {
   return result;
 }
 __name(getPluginOptions, "getPluginOptions");
+async function loadPluginModule(provider, basePath) {
+  let moduleSpec = provider;
+  if (moduleSpec.startsWith(".")) {
+    moduleSpec = import_node_path4.default.resolve(basePath, moduleSpec);
+  }
+  const importAsEsm = /* @__PURE__ */ __name(async (spec) => {
+    try {
+      const result = (await import(spec)).default;
+      return result;
+    } catch (err) {
+      throw new CliError(`Failed to load plugin module from ${spec}: ${err.message}`);
+    }
+  }, "importAsEsm");
+  const jiti = (0, import_jiti.createJiti)((0, import_node_url.pathToFileURL)(basePath).toString());
+  const importAsTs = /* @__PURE__ */ __name(async (spec) => {
+    try {
+      const result = await jiti.import(spec, {
+        default: true
+      });
+      return result;
+    } catch (err) {
+      throw new CliError(`Failed to load plugin module from ${spec}: ${err.message}`);
+    }
+  }, "importAsTs");
+  const esmSuffixes = [
+    ".js",
+    ".mjs"
+  ];
+  const tsSuffixes = [
+    ".ts",
+    ".mts"
+  ];
+  if (import_node_fs6.default.existsSync(moduleSpec) && import_node_fs6.default.statSync(moduleSpec).isFile()) {
+    if (esmSuffixes.some((suffix) => moduleSpec.endsWith(suffix))) {
+      return await importAsEsm((0, import_node_url.pathToFileURL)(moduleSpec).toString());
+    }
+    if (tsSuffixes.some((suffix) => moduleSpec.endsWith(suffix))) {
+      return await importAsTs(moduleSpec);
+    }
+  }
+  for (const suffix of esmSuffixes) {
+    const indexPath = import_node_path4.default.join(moduleSpec, `index${suffix}`);
+    if (import_node_fs6.default.existsSync(indexPath)) {
+      return await importAsEsm((0, import_node_url.pathToFileURL)(indexPath).toString());
+    }
+  }
+  for (const suffix of tsSuffixes) {
+    const indexPath = import_node_path4.default.join(moduleSpec, `index${suffix}`);
+    if (import_node_fs6.default.existsSync(indexPath)) {
+      return await importAsTs(indexPath);
+    }
+  }
+  try {
+    return (await import(moduleSpec)).default;
+  } catch {
+    return void 0;
+  }
+}
+__name(loadPluginModule, "loadPluginModule");
 
 // src/actions/info.ts
-var import_colors3 = __toESM(require("colors"), 1);
+var import_colors5 = __toESM(require("colors"), 1);
 var import_node_path5 = __toESM(require("path"), 1);
-async function run3(projectPath) {
+async function run5(projectPath) {
   const packages = await getZenStackPackages(projectPath);
   if (!packages) {
     console.error("Unable to locate package.json. Are you in a valid project directory?");
@@ -403,13 +564,13 @@ async function run3(projectPath) {
     if (version2) {
       versions.add(version2);
     }
-    console.log(`    ${import_colors3.default.green(pkg.padEnd(20))}	${version2}`);
+    console.log(`    ${import_colors5.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."));
+    console.warn(import_colors5.default.yellow("WARNING: Multiple versions of Zenstack packages detected. This may cause issues."));
   }
 }
-__name(run3, "run");
+__name(run5, "run");
 async function getZenStackPackages(projectPath) {
   let pkgJson;
   const resolvedPath = import_node_path5.default.resolve(projectPath);
@@ -452,8 +613,8 @@ async function getZenStackPackages(projectPath) {
 __name(getZenStackPackages, "getZenStackPackages");
 
 // src/actions/init.ts
-var import_colors4 = __toESM(require("colors"), 1);
-var import_node_fs5 = __toESM(require("fs"), 1);
+var import_colors6 = __toESM(require("colors"), 1);
+var import_node_fs7 = __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");
@@ -482,20 +643,20 @@ model Post {
     title     String   @length(1, 256)
     content   String
     published Boolean  @default(false)
-    author    User     @relation(fields: [authorId], references: [id])
+    author    User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
     authorId  String
 }
 `;
 
 // src/actions/init.ts
-async function run4(projectPath) {
+async function run6(projectPath) {
   const packages = [
     {
       name: "@zenstackhq/cli@next",
       dev: true
     },
     {
-      name: "@zenstackhq/runtime@next",
+      name: "@zenstackhq/orm@next",
       dev: false
     }
   ];
@@ -506,12 +667,12 @@ async function run4(projectPath) {
       name: "npm"
     };
   }
-  console.log(import_colors4.default.gray(`Using package manager: ${pm.agent}`));
+  console.log(import_colors6.default.gray(`Using package manager: ${pm.agent}`));
   for (const pkg of packages) {
-    const resolved = (0, import_package_manager_detector.resolveCommand)(pm.agent, "install", [
+    const resolved = (0, import_package_manager_detector.resolveCommand)(pm.agent, "add", [
       pkg.name,
       ...pkg.dev ? [
-        pm.agent === "yarn" ? "--dev" : "--save-dev"
+        pm.agent.startsWith("yarn") || pm.agent === "bun" ? "--dev" : "--save-dev"
       ] : []
     ]);
     if (!resolved) {
@@ -529,25 +690,55 @@ async function run4(projectPath) {
     }
   }
   const generationFolder = "zenstack";
-  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_fs7.default.existsSync(import_node_path6.default.join(projectPath, generationFolder))) {
+    import_node_fs7.default.mkdirSync(import_node_path6.default.join(projectPath, generationFolder));
   }
-  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);
+  if (!import_node_fs7.default.existsSync(import_node_path6.default.join(projectPath, generationFolder, "schema.zmodel"))) {
+    import_node_fs7.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."));
+    console.log(import_colors6.default.yellow("Schema file already exists. Skipping generation of sample."));
   }
-  console.log(import_colors4.default.green("ZenStack project initialized successfully!"));
-  console.log(import_colors4.default.gray(`See "${generationFolder}/schema.zmodel" for your database schema.`));
-  console.log(import_colors4.default.gray("Run `zenstack generate` to compile the the schema into a TypeScript file."));
+  console.log(import_colors6.default.green("ZenStack project initialized successfully!"));
+  console.log(import_colors6.default.gray(`See "${generationFolder}/schema.zmodel" for your database schema.`));
+  console.log(import_colors6.default.gray("Run `zenstack generate` to compile the the schema into a TypeScript file."));
 }
-__name(run4, "run");
+__name(run6, "run");
 
 // src/actions/migrate.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
 var import_node_path7 = __toESM(require("path"), 1);
-async function run5(command, options) {
+
+// src/actions/seed.ts
+var import_colors7 = __toESM(require("colors"), 1);
+var import_execa = require("execa");
+async function run7(options, args) {
+  const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+  if (!pkgJsonConfig.seed) {
+    if (!options.noWarnings) {
+      console.warn(import_colors7.default.yellow("No seed script defined in package.json. Skipping seeding."));
+    }
+    return;
+  }
+  const command = `${pkgJsonConfig.seed}${args.length > 0 ? " " + args.join(" ") : ""}`;
+  if (options.printStatus) {
+    console.log(import_colors7.default.gray(`Running seed script "${command}"...`));
+  }
+  try {
+    await (0, import_execa.execaCommand)(command, {
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+  } catch (err) {
+    console.error(import_colors7.default.red(err instanceof Error ? err.message : String(err)));
+    throw new CliError("Failed to seed the database. Please check the error message above for details.");
+  }
+}
+__name(run7, "run");
+
+// src/actions/migrate.ts
+async function run8(command, options) {
   const schemaFile = getSchemaFile(options.schema);
+  await requireDataSourceUrl(schemaFile);
   const prismaSchemaDir = options.migrations ? import_node_path7.default.dirname(options.migrations) : void 0;
   const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
   try {
@@ -569,22 +760,23 @@ async function run5(command, options) {
         break;
     }
   } finally {
-    if (import_node_fs6.default.existsSync(prismaSchemaFile)) {
-      import_node_fs6.default.unlinkSync(prismaSchemaFile);
+    if (import_node_fs8.default.existsSync(prismaSchemaFile)) {
+      import_node_fs8.default.unlinkSync(prismaSchemaFile);
     }
   }
 }
-__name(run5, "run");
-async function runDev(prismaSchemaFile, options) {
+__name(run8, "run");
+function runDev(prismaSchemaFile, options) {
   try {
     const cmd = [
-      "prisma migrate dev",
+      "migrate dev",
       ` --schema "${prismaSchemaFile}"`,
       " --skip-generate",
-      options.name ? ` --name ${options.name}` : "",
+      " --skip-seed",
+      options.name ? ` --name "${options.name}"` : "",
       options.createOnly ? " --create-only" : ""
     ].join("");
-    await execPackage(cmd);
+    execPrisma(cmd);
   } catch (err) {
     handleSubProcessError2(err);
   }
@@ -593,48 +785,56 @@ __name(runDev, "runDev");
 async function runReset(prismaSchemaFile, options) {
   try {
     const cmd = [
-      "prisma migrate reset",
+      "migrate reset",
       ` --schema "${prismaSchemaFile}"`,
+      " --skip-generate",
+      " --skip-seed",
       options.force ? " --force" : ""
     ].join("");
-    await execPackage(cmd);
+    execPrisma(cmd);
   } catch (err) {
     handleSubProcessError2(err);
   }
+  if (!options.skipSeed) {
+    await run7({
+      noWarnings: true,
+      printStatus: true
+    }, []);
+  }
 }
 __name(runReset, "runReset");
-async function runDeploy(prismaSchemaFile, _options) {
+function runDeploy(prismaSchemaFile, _options) {
   try {
     const cmd = [
-      "prisma migrate deploy",
+      "migrate deploy",
       ` --schema "${prismaSchemaFile}"`
     ].join("");
-    await execPackage(cmd);
+    execPrisma(cmd);
   } catch (err) {
     handleSubProcessError2(err);
   }
 }
 __name(runDeploy, "runDeploy");
-async function runStatus(prismaSchemaFile, _options) {
+function runStatus(prismaSchemaFile, _options) {
   try {
-    await execPackage(`prisma migrate status --schema "${prismaSchemaFile}"`);
+    execPrisma(`migrate status --schema "${prismaSchemaFile}"`);
   } catch (err) {
     handleSubProcessError2(err);
   }
 }
 __name(runStatus, "runStatus");
-async function runResolve(prismaSchemaFile, options) {
+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",
+      "migrate resolve",
       ` --schema "${prismaSchemaFile}"`,
-      options.applied ? ` --applied ${options.applied}` : "",
-      options.rolledBack ? ` --rolled-back ${options.rolledBack}` : ""
+      options.applied ? ` --applied "${options.applied}"` : "",
+      options.rolledBack ? ` --rolled-back "${options.rolledBack}"` : ""
     ].join("");
-    await execPackage(cmd);
+    execPrisma(cmd);
   } catch (err) {
     handleSubProcessError2(err);
   }
@@ -649,24 +849,10 @@ 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 import_node_fs13 = __toESM(require("fs"), 1);
 var os2 = __toESM(require("os"), 1);
 
 // src/constants.ts
@@ -677,14 +863,14 @@ 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);
+var import_node_fs10 = __toESM(require("fs"), 1);
 
 // src/utils/is-docker.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    import_node_fs7.default.statSync("/.dockerenv");
+    import_node_fs9.default.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -693,7 +879,7 @@ function hasDockerEnv() {
 __name(hasDockerEnv, "hasDockerEnv");
 function hasDockerCGroup() {
   try {
-    return import_node_fs7.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return import_node_fs9.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -711,7 +897,7 @@ __name(isDocker, "isDocker");
 var cachedResult;
 var hasContainerEnv = /* @__PURE__ */ __name(() => {
   try {
-    import_node_fs8.default.statSync("/run/.containerenv");
+    import_node_fs10.default.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -728,7 +914,7 @@ __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 import_node_fs11 = __toESM(require("fs"), 1);
 var isWsl = /* @__PURE__ */ __name(() => {
   if (import_node_process2.default.platform !== "linux") {
     return false;
@@ -737,7 +923,7 @@ var isWsl = /* @__PURE__ */ __name(() => {
     return true;
   }
   try {
-    return import_node_fs9.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    return import_node_fs11.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
   } catch {
     return false;
   }
@@ -801,18 +987,18 @@ function getMachineId() {
 __name(getMachineId, "getMachineId");
 
 // src/utils/version-utils.ts
-var import_colors6 = __toESM(require("colors"), 1);
-var import_node_fs10 = __toESM(require("fs"), 1);
+var import_colors8 = __toESM(require("colors"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
 var import_node_path8 = __toESM(require("path"), 1);
-var import_node_url = require("url");
+var import_node_url2 = require("url");
 var import_semver = __toESM(require("semver"), 1);
-var import_meta = {};
+var import_meta2 = {};
 var CHECK_VERSION_TIMEOUT = 2e3;
 var VERSION_CHECK_TAG = "next";
 function getVersion() {
   try {
-    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;
+    const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path8.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    return JSON.parse(import_node_fs12.default.readFileSync(import_node_path8.default.join(_dirname, "../package.json"), "utf8")).version;
   } catch {
     return void 0;
   }
@@ -827,7 +1013,7 @@ async function checkNewVersion() {
     return;
   }
   if (latestVersion && currVersion && import_semver.default.gt(latestVersion, currVersion)) {
-    console.log(`A newer version ${import_colors6.default.cyan(latestVersion)} is available.`);
+    console.log(`A newer version ${import_colors8.default.cyan(latestVersion)} is available.`);
   }
 }
 __name(checkNewVersion, "checkNewVersion");
@@ -850,7 +1036,7 @@ async function getLatestVersion() {
 __name(getLatestVersion, "getLatestVersion");
 
 // src/telemetry.ts
-var import_meta2 = {};
+var import_meta3 = {};
 var Telemetry = class {
   static {
     __name(this, "Telemetry");
@@ -941,9 +1127,9 @@ var Telemetry = class {
   }
   getPrismaVersion() {
     try {
-      const packageJsonPath = import_meta2.resolve("prisma/package.json");
+      const packageJsonPath = import_meta3.resolve("prisma/package.json");
       const packageJsonUrl = new URL(packageJsonPath);
-      const packageJson = JSON.parse(import_node_fs11.default.readFileSync(packageJsonUrl, "utf8"));
+      const packageJson = JSON.parse(import_node_fs13.default.readFileSync(packageJsonUrl, "utf8"));
       return packageJson.version;
     } catch {
       return void 0;
@@ -954,45 +1140,62 @@ var telemetry = new Telemetry();
 
 // src/index.ts
 var generateAction = /* @__PURE__ */ __name(async (options) => {
-  await telemetry.trackCommand("generate", () => run2(options));
+  await telemetry.trackCommand("generate", () => run4(options));
 }, "generateAction");
 var migrateAction = /* @__PURE__ */ __name(async (subCommand, options) => {
-  await telemetry.trackCommand(`migrate ${subCommand}`, () => run5(subCommand, options));
+  await telemetry.trackCommand(`migrate ${subCommand}`, () => run8(subCommand, options));
 }, "migrateAction");
 var dbAction = /* @__PURE__ */ __name(async (subCommand, options) => {
-  await telemetry.trackCommand(`db ${subCommand}`, () => run(subCommand, options));
+  await telemetry.trackCommand(`db ${subCommand}`, () => run2(subCommand, options));
 }, "dbAction");
 var infoAction = /* @__PURE__ */ __name(async (projectPath) => {
-  await telemetry.trackCommand("info", () => run3(projectPath));
+  await telemetry.trackCommand("info", () => run5(projectPath));
 }, "infoAction");
 var initAction = /* @__PURE__ */ __name(async (projectPath) => {
-  await telemetry.trackCommand("init", () => run4(projectPath));
+  await telemetry.trackCommand("init", () => run6(projectPath));
 }, "initAction");
 var checkAction = /* @__PURE__ */ __name(async (options) => {
-  await telemetry.trackCommand("check", () => run6(options));
+  await telemetry.trackCommand("check", () => run(options));
 }, "checkAction");
+var formatAction = /* @__PURE__ */ __name(async (options) => {
+  await telemetry.trackCommand("format", () => run3(options));
+}, "formatAction");
+var seedAction = /* @__PURE__ */ __name(async (options, args) => {
+  await telemetry.trackCommand("db seed", () => run7(options, args));
+}, "seedAction");
 function createProgram() {
-  const program = new import_commander.Command("zen");
-  program.version(getVersion(), "-v --version", "display CLI version");
-  const schemaExtensions = import_language2.ZModelLanguageMetaData.fileExtensions.join(", ");
-  program.description(`${import_colors7.default.bold.blue("\u03B6")} ZenStack is the data layer for modern TypeScript apps.
+  const program = new import_commander.Command("zen").alias("zenstack").helpOption("-h, --help", "Show this help message").version(getVersion(), "-v --version", "Show CLI version");
+  const schemaExtensions = import_language3.ZModelLanguageMetaData.fileExtensions.join(", ");
+  program.description(`${import_colors9.default.bold.blue("\u03B6")} ZenStack is the modern data layer for TypeScript apps.
 
-Documentation: https://zenstack.dev/docs/3.x`).showHelpAfterError().showSuggestionAfterError();
+Documentation: https://zenstack.dev/docs`).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);
+  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("--lite", "also generate a lite version of schema without attributes").default(false)).addOption(new import_commander.Option("--lite-only", "only generate lite version of schema without attributes").default(false)).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);
+  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(new import_commander.Option("--skip-seed", "skip seeding the database after reset")).addOption(noVersionCheckOption).description("Reset your database and apply all migrations, all data will be lost").addHelpText("after", "\nIf there is a seed script defined in package.json, it will be run after the reset. Use --skip-seed to skip it.").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));
+  dbCommand.command("seed").description("Seed the database").allowExcessArguments(true).addHelpText("after", `
+Seed script is configured under the "zenstack.seed" field in package.json.
+E.g.:
+{
+    "zenstack": {
+        "seed": "ts-node ./zenstack/seed.ts"
+    }
+}
+
+Arguments following -- are passed to the seed script. E.g.: "zen db seed -- --users 10"`).addOption(noVersionCheckOption).action((options, command) => seedAction(options, command.args));
+  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.command("format").description("Format a ZModel schema file").addOption(schemaOption).addOption(noVersionCheckOption).action(formatAction);
+  program.addHelpCommand("help [command]", "Display help for a command");
   program.hook("preAction", async (_thisCommand, actionCommand) => {
     if (actionCommand.getOptionValue("versionCheck") !== false) {
       await checkNewVersion();
@@ -1013,10 +1216,10 @@ async function main() {
     if (e instanceof import_commander.CommanderError) {
       exitCode = e.exitCode;
     } else if (e instanceof CliError) {
-      console.error(import_colors7.default.red(e.message));
+      console.error(import_colors9.default.red(e.message));
       exitCode = 1;
     } else {
-      console.error(import_colors7.default.red(`Unhandled error: ${e}`));
+      console.error(import_colors9.default.red(`Unhandled error: ${e}`));
       exitCode = 1;
     }
   }