@zenstackhq/cli 3.4.0-beta.1 → 3.4.0-beta.2

package/dist/index.cjs

@@ -42,6 +42,7 @@ 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);
+var import_node_module = require("module");
 var import_node_path = __toESM(require("path"), 1);
 
 // src/cli-error.ts
@@ -157,10 +158,10 @@ function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
   }
   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);
+    return import_node_path.default.resolve(cwd, target);
   }
   if (target) {
-    result.push(import_node_path.default.join(cwd, target));
+    result.push(import_node_path.default.resolve(cwd, target));
   }
   const up = import_node_path.default.resolve(cwd, "..");
   if (up === cwd) {
@@ -189,6 +190,44 @@ function getOutputPath(options, schemaFile) {
   }
 }
 __name(getOutputPath, "getOutputPath");
+async function getZenStackPackages(searchPath) {
+  const pkgJsonFile = findUp([
+    "package.json"
+  ], searchPath, false);
+  if (!pkgJsonFile) {
+    return [];
+  }
+  let pkgJson;
+  try {
+    pkgJson = JSON.parse(import_node_fs.default.readFileSync(pkgJsonFile, "utf8"));
+  } catch {
+    return [];
+  }
+  const packages = Array.from(new Set([
+    ...Object.keys(pkgJson.dependencies ?? {}),
+    ...Object.keys(pkgJson.devDependencies ?? {})
+  ].filter((p) => p.startsWith("@zenstackhq/")))).sort();
+  const require2 = (0, import_node_module.createRequire)(pkgJsonFile);
+  const result = packages.map((pkg) => {
+    try {
+      const depPkgJson = require2(`${pkg}/package.json`);
+      if (depPkgJson.private) {
+        return void 0;
+      }
+      return {
+        pkg,
+        version: depPkgJson.version
+      };
+    } catch {
+      return {
+        pkg,
+        version: void 0
+      };
+    }
+  });
+  return result.filter((p) => !!p);
+}
+__name(getZenStackPackages, "getZenStackPackages");
 
 // src/actions/check.ts
 async function run(options) {
@@ -269,6 +308,14 @@ var import_common_helpers = require("@zenstackhq/common-helpers");
 // src/actions/pull/utils.ts
 var import_ast2 = require("@zenstackhq/language/ast");
 var import_utils = require("@zenstackhq/language/utils");
+function isDatabaseManagedAttribute(name) {
+  return [
+    "@relation",
+    "@id",
+    "@unique"
+  ].includes(name) || name.startsWith("@db.");
+}
+__name(isDatabaseManagedAttribute, "isDatabaseManagedAttribute");
 function getDatasource(model) {
   const datasource = model.declarations.find((d) => d.$type === "DataSource");
   if (!datasource) {
@@ -731,12 +778,84 @@ function syncRelation({ model, relation, services, options, selfRelation, simila
   });
   sourceModel.fields.splice(firstSourceFieldId, 0, sourceFieldFactory.node);
   const oppositeFieldPrefix = /[0-9]/g.test(targetModel.name.charAt(0)) ? "_" : "";
-  const { name: oppositeFieldName } = resolveNameCasing(options.fieldCasing, similarRelations > 0 ? `${oppositeFieldPrefix}${(0, import_common_helpers.lowerCaseFirst)(sourceModel.name)}_${firstColumn}` : `${(0, import_common_helpers.lowerCaseFirst)(resolveNameCasing(options.fieldCasing, sourceModel.name).name)}${relation.references.type === "many" ? "s" : ""}`);
+  let { name: oppositeFieldName } = resolveNameCasing(options.fieldCasing, similarRelations > 0 ? `${oppositeFieldPrefix}${(0, import_common_helpers.lowerCaseFirst)(sourceModel.name)}_${firstColumn}` : `${(0, import_common_helpers.lowerCaseFirst)(resolveNameCasing(options.fieldCasing, sourceModel.name).name)}${relation.references.type === "many" ? "s" : ""}`);
+  if (targetModel.fields.find((f) => f.name === oppositeFieldName)) {
+    ({ name: oppositeFieldName } = resolveNameCasing(options.fieldCasing, `${(0, import_common_helpers.lowerCaseFirst)(sourceModel.name)}_${firstColumn}To${relation.references.table}_${relation.references.columns[0]}`));
+  }
   const targetFieldFactory = new import_factory.DataFieldFactory().setContainer(targetModel).setName(oppositeFieldName).setType((tb) => tb.setOptional(relation.references.type === "one").setArray(relation.references.type === "many").setReference(sourceModel));
   if (includeRelationName) targetFieldFactory.addAttribute((ab) => ab.setDecl(relationAttribute).addArg((ab2) => ab2.StringLiteral.setValue(relationName)));
   targetModel.fields.push(targetFieldFactory.node);
 }
 __name(syncRelation, "syncRelation");
+function consolidateEnums({ newModel, oldModel }) {
+  const newEnums = newModel.declarations.filter((d) => (0, import_ast3.isEnum)(d));
+  const newDataModels = newModel.declarations.filter((d) => d.$type === "DataModel");
+  const oldDataModels = oldModel.declarations.filter((d) => d.$type === "DataModel");
+  const enumMapping = /* @__PURE__ */ new Map();
+  for (const newEnum of newEnums) {
+    for (const newDM of newDataModels) {
+      for (const field of newDM.fields) {
+        if (field.$type !== "DataField" || field.type.reference?.ref !== newEnum) continue;
+        const oldDM = oldDataModels.find((d) => getDbName(d) === getDbName(newDM));
+        if (!oldDM) continue;
+        const oldField = oldDM.fields.find((f) => getDbName(f) === getDbName(field));
+        if (!oldField || oldField.$type !== "DataField" || !oldField.type.reference?.ref) continue;
+        const oldEnum = oldField.type.reference.ref;
+        if (!(0, import_ast3.isEnum)(oldEnum)) continue;
+        enumMapping.set(newEnum, oldEnum);
+        break;
+      }
+      if (enumMapping.has(newEnum)) break;
+    }
+  }
+  const reverseMapping = /* @__PURE__ */ new Map();
+  for (const [newEnum, oldEnum] of enumMapping) {
+    if (!reverseMapping.has(oldEnum)) {
+      reverseMapping.set(oldEnum, []);
+    }
+    reverseMapping.get(oldEnum).push(newEnum);
+  }
+  for (const [oldEnum, newEnumsGroup] of reverseMapping) {
+    const keepEnum = newEnumsGroup[0];
+    if (newEnumsGroup.length === 1 && keepEnum.name === oldEnum.name) continue;
+    const oldValues = new Set(oldEnum.fields.map((f) => getDbName(f)));
+    const allMatch = newEnumsGroup.every((ne) => {
+      const newValues = new Set(ne.fields.map((f) => getDbName(f)));
+      return oldValues.size === newValues.size && [
+        ...oldValues
+      ].every((v) => newValues.has(v));
+    });
+    if (!allMatch) continue;
+    keepEnum.name = oldEnum.name;
+    keepEnum.attributes = oldEnum.attributes.map((attr) => {
+      const copy = {
+        ...attr,
+        $container: keepEnum
+      };
+      return copy;
+    });
+    for (let i = 1; i < newEnumsGroup.length; i++) {
+      const idx = newModel.declarations.indexOf(newEnumsGroup[i]);
+      if (idx >= 0) {
+        newModel.declarations.splice(idx, 1);
+      }
+    }
+    for (const newDM of newDataModels) {
+      for (const field of newDM.fields) {
+        if (field.$type !== "DataField") continue;
+        const ref = field.type.reference?.ref;
+        if (ref && newEnumsGroup.includes(ref)) {
+          field.type.reference = {
+            ref: keepEnum,
+            $refText: keepEnum.name
+          };
+        }
+      }
+    }
+    console.log(import_colors3.default.gray(`Consolidated enum${newEnumsGroup.length > 1 ? "s" : ""} ${newEnumsGroup.map((e) => e.name).join(", ")} \u2192 ${oldEnum.name}`));
+  }
+}
+__name(consolidateEnums, "consolidateEnums");
 
 // src/actions/pull/provider/mysql.ts
 var import_factory2 = require("@zenstackhq/language/factory");
@@ -994,6 +1113,10 @@ var mysql = {
           return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("uuid", services));
         }
         return (ab) => ab.StringLiteral.setValue(val);
+      case "Json":
+        return (ab) => ab.StringLiteral.setValue(val);
+      case "Bytes":
+        return (ab) => ab.StringLiteral.setValue(val);
     }
     if (val.includes("(") && val.includes(")")) {
       return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("dbgenerated", services)).addArg((a) => a.setValue((v) => v.StringLiteral.setValue(val)));
@@ -1592,6 +1715,26 @@ var postgresql = {
           return (ab) => ab.StringLiteral.setValue(val.slice(1, -1).replace(/''/g, "'"));
         }
         return (ab) => ab.StringLiteral.setValue(val);
+      case "Json":
+        if (val.includes("::")) {
+          return typeCastingConvert({
+            defaultValue,
+            enums,
+            val,
+            services
+          });
+        }
+        return (ab) => ab.StringLiteral.setValue(val);
+      case "Bytes":
+        if (val.includes("::")) {
+          return typeCastingConvert({
+            defaultValue,
+            enums,
+            val,
+            services
+          });
+        }
+        return (ab) => ab.StringLiteral.setValue(val);
     }
     if (val.includes("(") && val.includes(")")) {
       return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("dbgenerated", services)).addArg((a) => a.setValue((v) => v.StringLiteral.setValue(val)));
@@ -2227,6 +2370,10 @@ var sqlite = {
           return (ab) => ab.StringLiteral.setValue(strippedName);
         }
         return (ab) => ab.StringLiteral.setValue(val);
+      case "Json":
+        return (ab) => ab.StringLiteral.setValue(val);
+      case "Bytes":
+        return (ab) => ab.StringLiteral.setValue(val);
     }
     console.warn(`Unsupported default value type: "${defaultValue}" for field type "${fieldType}". Skipping default value.`);
     return null;
@@ -2402,6 +2549,10 @@ async function runPull(options) {
         similarRelations
       });
     }
+    consolidateEnums({
+      newModel,
+      oldModel: model
+    });
     console.log(import_colors4.default.blue("Schema synced"));
     const baseDir = import_node_path2.default.dirname(import_node_path2.default.resolve(schemaFile));
     const baseDirUrlPath = new URL(`file://${baseDir}`).pathname;
@@ -2577,23 +2728,13 @@ async function runPull(options) {
           }
           return;
         }
-        originalField.attributes.filter((attr) => !f.attributes.find((d) => d.decl.$refText === attr.decl.$refText) && ![
-          "@map",
-          "@@map",
-          "@default",
-          "@updatedAt"
-        ].includes(attr.decl.$refText)).forEach((attr) => {
+        originalField.attributes.filter((attr) => !f.attributes.find((d) => d.decl.$refText === attr.decl.$refText) && isDatabaseManagedAttribute(attr.decl.$refText)).forEach((attr) => {
           const field = attr.$container;
           const index = field.attributes.findIndex((d) => d === attr);
           field.attributes.splice(index, 1);
           getModelChanges(originalDataModel.name).deletedAttributes.push(import_colors4.default.yellow(`- ${attr.decl.$refText} from field: ${originalDataModel.name}.${field.name}`));
         });
-        f.attributes.filter((attr) => !originalField.attributes.find((d) => d.decl.$refText === attr.decl.$refText) && ![
-          "@map",
-          "@@map",
-          "@default",
-          "@updatedAt"
-        ].includes(attr.decl.$refText)).forEach((attr) => {
+        f.attributes.filter((attr) => !originalField.attributes.find((d) => d.decl.$refText === attr.decl.$refText) && isDatabaseManagedAttribute(attr.decl.$refText)).forEach((attr) => {
           const cloned = {
             ...attr,
             $container: originalField
@@ -2691,8 +2832,8 @@ async function runPull(options) {
       });
     }
     const generator = new import_language2.ZModelCodeGenerator({
-      quote: options.quote,
-      indent: options.indent
+      quote: options.quote ?? "single",
+      indent: options.indent ?? 4
     });
     if (options.output) {
       if (treatAsFile) {
@@ -2829,7 +2970,13 @@ var plugin2 = {
 var typescript_default = plugin2;
 
 // src/actions/generate.ts
+var import_semver = __toESM(require("semver"), 1);
 async function run4(options) {
+  try {
+    await checkForMismatchedPackages(process.cwd());
+  } catch (err) {
+    console.warn(import_colors6.default.yellow(`Failed to check for mismatched ZenStack packages: ${err}`));
+  }
   const model = await pureGenerate(options, false);
   if (options.watch) {
     const logsEnabled = !options.silent;
@@ -3081,13 +3228,46 @@ async function loadPluginModule(provider, basePath) {
   }
 }
 __name(loadPluginModule, "loadPluginModule");
+async function checkForMismatchedPackages(projectPath) {
+  const packages = await getZenStackPackages(projectPath);
+  if (!packages.length) {
+    return false;
+  }
+  const versions = /* @__PURE__ */ new Set();
+  for (const { version: version2 } of packages) {
+    if (version2) {
+      versions.add(version2);
+    }
+  }
+  if (versions.size > 1) {
+    const message = "WARNING: Multiple versions of ZenStack packages detected.\n	This will probably cause issues and break your types.";
+    const slashes = "/".repeat(73);
+    const latestVersion = import_semver.default.sort(Array.from(versions)).reverse()[0];
+    console.warn(import_colors6.default.yellow(`${slashes}
+
+	${message}
+`));
+    for (const { pkg, version: version2 } of packages) {
+      if (!version2) continue;
+      if (version2 === latestVersion) {
+        console.log(`	${pkg.padEnd(32)}	${import_colors6.default.green(version2)}`);
+      } else {
+        console.log(`	${pkg.padEnd(32)}	${import_colors6.default.yellow(version2)}`);
+      }
+    }
+    console.warn(`
+${import_colors6.default.yellow(slashes)}`);
+    return true;
+  }
+  return false;
+}
+__name(checkForMismatchedPackages, "checkForMismatchedPackages");
 
 // src/actions/info.ts
 var import_colors7 = __toESM(require("colors"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
 async function run5(projectPath) {
   const packages = await getZenStackPackages(projectPath);
-  if (!packages) {
+  if (!packages.length) {
     console.error("Unable to locate package.json. Are you in a valid project directory?");
     return;
   }
@@ -3104,51 +3284,11 @@ async function run5(projectPath) {
   }
 }
 __name(run5, "run");
-async function getZenStackPackages(projectPath) {
-  let pkgJson;
-  const resolvedPath = import_node_path6.default.resolve(projectPath);
-  try {
-    pkgJson = (await import(import_node_path6.default.join(resolvedPath, "package.json"), {
-      with: {
-        type: "json"
-      }
-    })).default;
-  } catch {
-    return [];
-  }
-  const packages = Array.from(new Set([
-    ...Object.keys(pkgJson.dependencies ?? {}),
-    ...Object.keys(pkgJson.devDependencies ?? {})
-  ].filter((p) => p.startsWith("@zenstackhq/") || p === "zenstack"))).sort();
-  const result = await Promise.all(packages.map(async (pkg) => {
-    try {
-      const depPkgJson = (await import(`${pkg}/package.json`, {
-        with: {
-          type: "json"
-        }
-      })).default;
-      if (depPkgJson.private) {
-        return void 0;
-      }
-      return {
-        pkg,
-        version: depPkgJson.version
-      };
-    } catch {
-      return {
-        pkg,
-        version: void 0
-      };
-    }
-  }));
-  return result.filter((p) => !!p);
-}
-__name(getZenStackPackages, "getZenStackPackages");
 
 // src/actions/init.ts
 var import_colors8 = __toESM(require("colors"), 1);
 var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_ora3 = __toESM(require("ora"), 1);
 var import_package_manager_detector = require("package-manager-detector");
 
@@ -3223,11 +3363,11 @@ async function run6(projectPath) {
     }
   }
   const generationFolder = "zenstack";
-  if (!import_node_fs7.default.existsSync(import_node_path7.default.join(projectPath, generationFolder))) {
-    import_node_fs7.default.mkdirSync(import_node_path7.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_fs7.default.existsSync(import_node_path7.default.join(projectPath, generationFolder, "schema.zmodel"))) {
-    import_node_fs7.default.writeFileSync(import_node_path7.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_colors8.default.yellow("Schema file already exists. Skipping generation of sample."));
   }
@@ -3239,7 +3379,7 @@ __name(run6, "run");
 
 // src/actions/migrate.ts
 var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/actions/seed.ts
 var import_colors9 = __toESM(require("colors"), 1);
@@ -3272,7 +3412,7 @@ __name(run7, "run");
 async function run8(command, options) {
   const schemaFile = getSchemaFile(options.schema);
   await requireDataSourceUrl(schemaFile);
-  const prismaSchemaDir = options.migrations ? import_node_path8.default.dirname(options.migrations) : void 0;
+  const prismaSchemaDir = options.migrations ? import_node_path7.default.dirname(options.migrations) : void 0;
   const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
   try {
     switch (command) {
@@ -3397,22 +3537,22 @@ var import_cors = __toESM(require("cors"), 1);
 var import_express2 = __toESM(require("express"), 1);
 var import_jiti2 = require("jiti");
 var import_mysql22 = require("mysql2");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 var import_pg2 = require("pg");
 
 // src/utils/version-utils.ts
 var import_colors10 = __toESM(require("colors"), 1);
 var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
-var import_semver = __toESM(require("semver"), 1);
+var import_semver2 = __toESM(require("semver"), 1);
 var import_meta2 = {};
 var CHECK_VERSION_TIMEOUT = 2e3;
 var VERSION_CHECK_TAG = "next";
 function getVersion() {
   try {
-    const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path9.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
-    return JSON.parse(import_node_fs9.default.readFileSync(import_node_path9.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_fs9.default.readFileSync(import_node_path8.default.join(_dirname, "../package.json"), "utf8")).version;
   } catch {
     return void 0;
   }
@@ -3426,7 +3566,7 @@ async function checkNewVersion() {
   } catch {
     return;
   }
-  if (latestVersion && currVersion && import_semver.default.gt(latestVersion, currVersion)) {
+  if (latestVersion && currVersion && import_semver2.default.gt(latestVersion, currVersion)) {
     console.log(`A newer version ${import_colors10.default.cyan(latestVersion)} is available.`);
   }
 }
@@ -3441,7 +3581,7 @@ async function getLatestVersion() {
   if (fetchResult.ok) {
     const data = await fetchResult.json();
     const latestVersion = data?.version;
-    if (typeof latestVersion === "string" && import_semver.default.valid(latestVersion)) {
+    if (typeof latestVersion === "string" && import_semver2.default.valid(latestVersion)) {
       return latestVersion;
     }
   }
@@ -3460,8 +3600,8 @@ async function run9(options) {
   const schemaFile = getSchemaFile(options.schema);
   console.log(import_colors11.default.gray(`Loading ZModel schema from: ${schemaFile}`));
   let outputPath = getOutputPath(options, schemaFile);
-  if (!import_node_path10.default.isAbsolute(outputPath)) {
-    outputPath = import_node_path10.default.resolve(process.cwd(), outputPath);
+  if (!import_node_path9.default.isAbsolute(outputPath)) {
+    outputPath = import_node_path9.default.resolve(process.cwd(), outputPath);
   }
   const model = await loadSchemaDocument(schemaFile);
   const dataSource = model.declarations.find(import_ast6.isDataSource);
@@ -3476,7 +3616,7 @@ async function run9(options) {
   const provider = (0, import_utils8.getStringLiteral)(dataSource?.fields.find((f) => f.name === "provider")?.value);
   const dialect = createDialect(provider, databaseUrl, outputPath);
   const jiti = (0, import_jiti2.createJiti)(import_meta3.url);
-  const schemaModule = await jiti.import(import_node_path10.default.join(outputPath, "schema"));
+  const schemaModule = await jiti.import(import_node_path9.default.join(outputPath, "schema"));
   const schema = schemaModule.schema;
   const omit = {};
   for (const [modelName, modelDef] of Object.entries(schema.models)) {
@@ -3540,8 +3680,8 @@ function createDialect(provider, databaseUrl, outputPath) {
       let resolvedUrl = databaseUrl.trim();
       if (resolvedUrl.startsWith("file:")) {
         const filePath = resolvedUrl.substring("file:".length);
-        if (!import_node_path10.default.isAbsolute(filePath)) {
-          resolvedUrl = import_node_path10.default.join(outputPath, filePath);
+        if (!import_node_path9.default.isAbsolute(filePath)) {
+          resolvedUrl = import_node_path9.default.join(outputPath, filePath);
         }
       }
       console.log(import_colors11.default.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
@@ -3903,7 +4043,7 @@ Documentation: https://zenstack.dev/docs`).showHelpAfterError().showSuggestionAf
   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("pull").description("Introspect your database.").addOption(schemaOption).addOption(noVersionCheckOption).addOption(new import_commander.Option("-o, --output <path>", "set custom output path for the introspected schema. If a file path is provided, all schemas are merged into that single file. If a directory path is provided, files are written to the directory and imports are kept.")).addOption(new import_commander.Option("--model-casing <pascal|camel|snake|none>", "set the casing of generated models").default("pascal")).addOption(new import_commander.Option("--field-casing <pascal|camel|snake|none>", "set the casing of generated fields").default("camel")).addOption(new import_commander.Option("--always-map", "always add @map and @@map attributes to models and fields").default(false)).addOption(new import_commander.Option("--quote <double|single>", "set the quote style of generated schema files").default("single")).addOption(new import_commander.Option("--indent <number>", "set the indentation of the generated schema files").default(4).argParser(parseInt)).action((options) => dbAction("pull", options));
+  dbCommand.command("pull").description("Introspect your database.").addOption(schemaOption).addOption(noVersionCheckOption).addOption(new import_commander.Option("-o, --output <path>", "set custom output path for the introspected schema. If a file path is provided, all schemas are merged into that single file. If a directory path is provided, files are written to the directory and imports are kept.")).addOption(new import_commander.Option("--model-casing <pascal|camel|snake|none>", "set the casing of generated models").default("pascal")).addOption(new import_commander.Option("--field-casing <pascal|camel|snake|none>", "set the casing of generated fields").default("camel")).addOption(new import_commander.Option("--always-map", "always add @map and @@map attributes to models and fields").default(false)).addOption(new import_commander.Option("--quote <double|single>", "set the quote style of generated schema files").default("single")).addOption(new import_commander.Option("--indent <number>", "set the indentation of the generated schema files").default(4)).action((options) => dbAction("pull", 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.: