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

package/dist/index.js

@@ -26,6 +26,7 @@ import { isDataSource } from "@zenstackhq/language/ast";
 import { PrismaSchemaGenerator } from "@zenstackhq/sdk";
 import colors from "colors";
 import fs from "fs";
+import { createRequire } from "module";
 import path from "path";
 
 // src/cli-error.ts
@@ -141,10 +142,10 @@ function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
   }
   const target = names.find((name) => fs.existsSync(path.join(cwd, name)));
   if (multiple === false && target) {
-    return path.join(cwd, target);
+    return path.resolve(cwd, target);
   }
   if (target) {
-    result.push(path.join(cwd, target));
+    result.push(path.resolve(cwd, target));
   }
   const up = path.resolve(cwd, "..");
   if (up === cwd) {
@@ -173,6 +174,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(fs.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 = 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) {
@@ -252,6 +291,14 @@ import { lowerCaseFirst } from "@zenstackhq/common-helpers";
 // src/actions/pull/utils.ts
 import { isInvocationExpr } from "@zenstackhq/language/ast";
 import { getLiteralArray, getStringLiteral } from "@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) {
@@ -714,12 +761,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}${lowerCaseFirst(sourceModel.name)}_${firstColumn}` : `${lowerCaseFirst(resolveNameCasing(options.fieldCasing, sourceModel.name).name)}${relation.references.type === "many" ? "s" : ""}`);
+  let { name: oppositeFieldName } = resolveNameCasing(options.fieldCasing, similarRelations > 0 ? `${oppositeFieldPrefix}${lowerCaseFirst(sourceModel.name)}_${firstColumn}` : `${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, `${lowerCaseFirst(sourceModel.name)}_${firstColumn}To${relation.references.table}_${relation.references.columns[0]}`));
+  }
   const targetFieldFactory = new 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) => 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 (!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(colors3.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
 import { DataFieldAttributeFactory as DataFieldAttributeFactory2 } from "@zenstackhq/language/factory";
@@ -977,6 +1096,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)));
@@ -1575,6 +1698,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)));
@@ -2210,6 +2353,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;
@@ -2385,6 +2532,10 @@ async function runPull(options) {
         similarRelations
       });
     }
+    consolidateEnums({
+      newModel,
+      oldModel: model
+    });
     console.log(colors4.blue("Schema synced"));
     const baseDir = path2.dirname(path2.resolve(schemaFile));
     const baseDirUrlPath = new URL(`file://${baseDir}`).pathname;
@@ -2560,23 +2711,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(colors4.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
@@ -2674,8 +2815,8 @@ async function runPull(options) {
       });
     }
     const generator = new ZModelCodeGenerator({
-      quote: options.quote,
-      indent: options.indent
+      quote: options.quote ?? "single",
+      indent: options.indent ?? 4
     });
     if (options.output) {
       if (treatAsFile) {
@@ -2812,7 +2953,13 @@ var plugin2 = {
 var typescript_default = plugin2;
 
 // src/actions/generate.ts
+import semver from "semver";
 async function run4(options) {
+  try {
+    await checkForMismatchedPackages(process.cwd());
+  } catch (err) {
+    console.warn(colors6.yellow(`Failed to check for mismatched ZenStack packages: ${err}`));
+  }
   const model = await pureGenerate(options, false);
   if (options.watch) {
     const logsEnabled = !options.silent;
@@ -3064,13 +3211,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 = semver.sort(Array.from(versions)).reverse()[0];
+    console.warn(colors6.yellow(`${slashes}
+
+	${message}
+`));
+    for (const { pkg, version: version2 } of packages) {
+      if (!version2) continue;
+      if (version2 === latestVersion) {
+        console.log(`	${pkg.padEnd(32)}	${colors6.green(version2)}`);
+      } else {
+        console.log(`	${pkg.padEnd(32)}	${colors6.yellow(version2)}`);
+      }
+    }
+    console.warn(`
+${colors6.yellow(slashes)}`);
+    return true;
+  }
+  return false;
+}
+__name(checkForMismatchedPackages, "checkForMismatchedPackages");
 
 // src/actions/info.ts
 import colors7 from "colors";
-import path6 from "path";
 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;
   }
@@ -3087,51 +3267,11 @@ async function run5(projectPath) {
   }
 }
 __name(run5, "run");
-async function getZenStackPackages(projectPath) {
-  let pkgJson;
-  const resolvedPath = path6.resolve(projectPath);
-  try {
-    pkgJson = (await import(path6.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
 import colors8 from "colors";
 import fs7 from "fs";
-import path7 from "path";
+import path6 from "path";
 import ora3 from "ora";
 import { detect, resolveCommand } from "package-manager-detector";
 
@@ -3206,11 +3346,11 @@ async function run6(projectPath) {
     }
   }
   const generationFolder = "zenstack";
-  if (!fs7.existsSync(path7.join(projectPath, generationFolder))) {
-    fs7.mkdirSync(path7.join(projectPath, generationFolder));
+  if (!fs7.existsSync(path6.join(projectPath, generationFolder))) {
+    fs7.mkdirSync(path6.join(projectPath, generationFolder));
   }
-  if (!fs7.existsSync(path7.join(projectPath, generationFolder, "schema.zmodel"))) {
-    fs7.writeFileSync(path7.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
+  if (!fs7.existsSync(path6.join(projectPath, generationFolder, "schema.zmodel"))) {
+    fs7.writeFileSync(path6.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
   } else {
     console.log(colors8.yellow("Schema file already exists. Skipping generation of sample."));
   }
@@ -3222,7 +3362,7 @@ __name(run6, "run");
 
 // src/actions/migrate.ts
 import fs8 from "fs";
-import path8 from "path";
+import path7 from "path";
 
 // src/actions/seed.ts
 import colors9 from "colors";
@@ -3255,7 +3395,7 @@ __name(run7, "run");
 async function run8(command, options) {
   const schemaFile = getSchemaFile(options.schema);
   await requireDataSourceUrl(schemaFile);
-  const prismaSchemaDir = options.migrations ? path8.dirname(options.migrations) : void 0;
+  const prismaSchemaDir = options.migrations ? path7.dirname(options.migrations) : void 0;
   const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
   try {
     switch (command) {
@@ -3380,21 +3520,21 @@ import cors from "cors";
 import express from "express";
 import { createJiti as createJiti2 } from "jiti";
 import { createPool as createMysqlPool } from "mysql2";
-import path10 from "path";
+import path9 from "path";
 import { Pool as PgPool } from "pg";
 
 // src/utils/version-utils.ts
 import colors10 from "colors";
 import fs9 from "fs";
-import path9 from "path";
+import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import semver from "semver";
+import semver2 from "semver";
 var CHECK_VERSION_TIMEOUT = 2e3;
 var VERSION_CHECK_TAG = "next";
 function getVersion() {
   try {
-    const _dirname = typeof __dirname !== "undefined" ? __dirname : path9.dirname(fileURLToPath2(import.meta.url));
-    return JSON.parse(fs9.readFileSync(path9.join(_dirname, "../package.json"), "utf8")).version;
+    const _dirname = typeof __dirname !== "undefined" ? __dirname : path8.dirname(fileURLToPath2(import.meta.url));
+    return JSON.parse(fs9.readFileSync(path8.join(_dirname, "../package.json"), "utf8")).version;
   } catch {
     return void 0;
   }
@@ -3408,7 +3548,7 @@ async function checkNewVersion() {
   } catch {
     return;
   }
-  if (latestVersion && currVersion && semver.gt(latestVersion, currVersion)) {
+  if (latestVersion && currVersion && semver2.gt(latestVersion, currVersion)) {
     console.log(`A newer version ${colors10.cyan(latestVersion)} is available.`);
   }
 }
@@ -3423,7 +3563,7 @@ async function getLatestVersion() {
   if (fetchResult.ok) {
     const data = await fetchResult.json();
     const latestVersion = data?.version;
-    if (typeof latestVersion === "string" && semver.valid(latestVersion)) {
+    if (typeof latestVersion === "string" && semver2.valid(latestVersion)) {
       return latestVersion;
     }
   }
@@ -3441,8 +3581,8 @@ async function run9(options) {
   const schemaFile = getSchemaFile(options.schema);
   console.log(colors11.gray(`Loading ZModel schema from: ${schemaFile}`));
   let outputPath = getOutputPath(options, schemaFile);
-  if (!path10.isAbsolute(outputPath)) {
-    outputPath = path10.resolve(process.cwd(), outputPath);
+  if (!path9.isAbsolute(outputPath)) {
+    outputPath = path9.resolve(process.cwd(), outputPath);
   }
   const model = await loadSchemaDocument(schemaFile);
   const dataSource = model.declarations.find(isDataSource2);
@@ -3457,7 +3597,7 @@ async function run9(options) {
   const provider = getStringLiteral2(dataSource?.fields.find((f) => f.name === "provider")?.value);
   const dialect = createDialect(provider, databaseUrl, outputPath);
   const jiti = createJiti2(import.meta.url);
-  const schemaModule = await jiti.import(path10.join(outputPath, "schema"));
+  const schemaModule = await jiti.import(path9.join(outputPath, "schema"));
   const schema = schemaModule.schema;
   const omit = {};
   for (const [modelName, modelDef] of Object.entries(schema.models)) {
@@ -3521,8 +3661,8 @@ function createDialect(provider, databaseUrl, outputPath) {
       let resolvedUrl = databaseUrl.trim();
       if (resolvedUrl.startsWith("file:")) {
         const filePath = resolvedUrl.substring("file:".length);
-        if (!path10.isAbsolute(filePath)) {
-          resolvedUrl = path10.join(outputPath, filePath);
+        if (!path9.isAbsolute(filePath)) {
+          resolvedUrl = path9.join(outputPath, filePath);
         }
       }
       console.log(colors11.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
@@ -3883,7 +4023,7 @@ Documentation: https://zenstack.dev/docs`).showHelpAfterError().showSuggestionAf
   migrateCommand.command("resolve").addOption(schemaOption).addOption(noVersionCheckOption).addOption(migrationsOption).addOption(new Option("--applied <migration>", "record a specific migration as applied")).addOption(new Option("--rolled-back <migration>", "record a specific migration as rolled back")).description("Resolve issues with database migrations in deployment databases").action((options) => migrateAction("resolve", options));
   const dbCommand = 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 Option("--accept-data-loss", "ignore data loss warnings")).addOption(new Option("--force-reset", "force a reset of the database before push")).action((options) => dbAction("push", options));
-  dbCommand.command("pull").description("Introspect your database.").addOption(schemaOption).addOption(noVersionCheckOption).addOption(new 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 Option("--model-casing <pascal|camel|snake|none>", "set the casing of generated models").default("pascal")).addOption(new Option("--field-casing <pascal|camel|snake|none>", "set the casing of generated fields").default("camel")).addOption(new Option("--always-map", "always add @map and @@map attributes to models and fields").default(false)).addOption(new Option("--quote <double|single>", "set the quote style of generated schema files").default("single")).addOption(new 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 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 Option("--model-casing <pascal|camel|snake|none>", "set the casing of generated models").default("pascal")).addOption(new Option("--field-casing <pascal|camel|snake|none>", "set the casing of generated fields").default("camel")).addOption(new Option("--always-map", "always add @map and @@map attributes to models and fields").default(false)).addOption(new Option("--quote <double|single>", "set the quote style of generated schema files").default("single")).addOption(new 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.: