@zenstackhq/cli 3.4.3 → 3.4.4

package/dist/index.cjs

@@ -34,16 +34,23 @@ var import_colors12 = __toESM(require("colors"), 1);
 var import_commander = require("commander");
 
 // src/actions/check.ts
+var import_ast2 = require("@zenstackhq/language/ast");
 var import_colors2 = __toESM(require("colors"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 
 // src/actions/action-utils.ts
+var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_language = require("@zenstackhq/language");
 var import_ast = require("@zenstackhq/language/ast");
 var import_sdk = require("@zenstackhq/sdk");
 var import_colors = __toESM(require("colors"), 1);
+var import_jiti = require("jiti");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_module = require("module");
 var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_terminal_link = __toESM(require("terminal-link"), 1);
+var import_zod = require("zod");
 
 // src/cli-error.ts
 var CliError = class extends Error {
@@ -53,8 +60,6 @@ var CliError = class extends Error {
 };
 
 // src/actions/action-utils.ts
-var import_terminal_link = __toESM(require("terminal-link"), 1);
-var import_zod = require("zod");
 function getSchemaFile(file) {
   if (file) {
     if (!import_node_fs.default.existsSync(file)) {
@@ -230,6 +235,80 @@ async function getZenStackPackages(searchPath) {
   return result.filter((p) => !!p);
 }
 __name(getZenStackPackages, "getZenStackPackages");
+function getPluginProvider(plugin3) {
+  const providerField = plugin3.fields.find((f) => f.name === "provider");
+  (0, import_common_helpers.invariant)(providerField, `Plugin ${plugin3.name} does not have a provider field`);
+  const provider = providerField.value.value;
+  return provider;
+}
+__name(getPluginProvider, "getPluginProvider");
+async function loadPluginModule(provider, basePath) {
+  if (provider.toLowerCase().endsWith(".zmodel")) {
+    return void 0;
+  }
+  let moduleSpec = provider;
+  if (moduleSpec.startsWith(".")) {
+    moduleSpec = import_node_path.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_fs.default.existsSync(moduleSpec) && import_node_fs.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_path.default.join(moduleSpec, `index${suffix}`);
+    if (import_node_fs.default.existsSync(indexPath)) {
+      return await importAsEsm((0, import_node_url.pathToFileURL)(indexPath).toString());
+    }
+  }
+  for (const suffix of tsSuffixes) {
+    const indexPath = import_node_path.default.join(moduleSpec, `index${suffix}`);
+    if (import_node_fs.default.existsSync(indexPath)) {
+      return await importAsTs(indexPath);
+    }
+  }
+  try {
+    const mod = await import(moduleSpec);
+    return mod.default;
+  } catch (err) {
+    const errorCode = err?.code;
+    if (errorCode === "ERR_MODULE_NOT_FOUND" || errorCode === "MODULE_NOT_FOUND") {
+      throw new CliError(`Cannot find plugin module "${provider}". Please make sure the package exists.`);
+    }
+    throw new CliError(`Failed to load plugin module "${provider}": ${err.message}`);
+  }
+}
+__name(loadPluginModule, "loadPluginModule");
 var FETCH_CLI_MAX_TIME = 1e3;
 var CLI_CONFIG_ENDPOINT = "https://zenstack.dev/config/cli-v3.json";
 var usageTipsSchema = import_zod.z.object({
@@ -287,7 +366,8 @@ __name(startUsageTipsFetch, "startUsageTipsFetch");
 async function run(options) {
   const schemaFile = getSchemaFile(options.schema);
   try {
-    await loadSchemaDocument(schemaFile);
+    const model = await loadSchemaDocument(schemaFile);
+    await checkPluginResolution(schemaFile, model);
     console.log(import_colors2.default.green("\u2713 Schema validation completed successfully."));
   } catch (error) {
     console.error(import_colors2.default.red("\u2717 Schema validation failed."));
@@ -295,13 +375,23 @@ async function run(options) {
   }
 }
 __name(run, "run");
+async function checkPluginResolution(schemaFile, model) {
+  const plugins = model.declarations.filter(import_ast2.isPlugin);
+  for (const plugin3 of plugins) {
+    const provider = getPluginProvider(plugin3);
+    if (!provider.startsWith("@core/")) {
+      await loadPluginModule(provider, import_node_path2.default.dirname(schemaFile));
+    }
+  }
+}
+__name(checkPluginResolution, "checkPluginResolution");
 
 // src/actions/db.ts
 var import_language2 = require("@zenstackhq/language");
-var import_ast4 = require("@zenstackhq/language/ast");
+var import_ast5 = require("@zenstackhq/language/ast");
 var import_colors4 = __toESM(require("colors"), 1);
 var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var import_ora = __toESM(require("ora"), 1);
 
 // src/utils/exec-utils.ts
@@ -354,13 +444,13 @@ __name(execPrisma, "execPrisma");
 
 // src/actions/pull/index.ts
 var import_colors3 = __toESM(require("colors"), 1);
-var import_ast3 = require("@zenstackhq/language/ast");
+var import_ast4 = require("@zenstackhq/language/ast");
 var import_factory = require("@zenstackhq/language/factory");
 var import_langium = require("langium");
-var import_common_helpers = require("@zenstackhq/common-helpers");
+var import_common_helpers2 = require("@zenstackhq/common-helpers");
 
 // src/actions/pull/utils.ts
-var import_ast2 = require("@zenstackhq/language/ast");
+var import_ast3 = require("@zenstackhq/language/ast");
 var import_utils = require("@zenstackhq/language/utils");
 function isDatabaseManagedAttribute(name) {
   return [
@@ -378,7 +468,7 @@ function getDatasource(model) {
   const urlField = datasource.fields.find((f) => f.name === "url");
   if (!urlField) throw new CliError(`No url field found in the datasource declaration.`);
   let url = (0, import_utils.getStringLiteral)(urlField.value);
-  if (!url && (0, import_ast2.isInvocationExpr)(urlField.value)) {
+  if (!url && (0, import_ast3.isInvocationExpr)(urlField.value)) {
     const envName = (0, import_utils.getStringLiteral)(urlField.value.args[0]?.value);
     if (!envName) {
       throw new CliError("The url field must be a string literal or an env().");
@@ -561,7 +651,7 @@ function syncEnums({ dbEnums, model, oldModel, provider, options, services, defa
     const dummyBuildReference = /* @__PURE__ */ __name((_node, _property, _refNode, refText) => ({
       $refText: refText
     }), "dummyBuildReference");
-    oldModel.declarations.filter((d) => (0, import_ast3.isEnum)(d)).forEach((d) => {
+    oldModel.declarations.filter((d) => (0, import_ast4.isEnum)(d)).forEach((d) => {
       const copy = import_langium.AstUtils.copyAstNode(d, dummyBuildReference);
       copy.$container = model;
       model.declarations.push(copy);
@@ -625,7 +715,7 @@ function syncTable({ model, provider, table, services, options, defaultSchema })
         if (column.computed) {
           typeBuilder.setUnsupported((unsupportedBuilder) => unsupportedBuilder.setValue((lt) => lt.StringLiteral.setValue(column.datatype)));
         } else if (column.datatype === "enum") {
-          const ref = model.declarations.find((d) => (0, import_ast3.isEnum)(d) && getDbName(d) === column.datatype_name);
+          const ref = model.declarations.find((d) => (0, import_ast4.isEnum)(d) && getDbName(d) === column.datatype_name);
           if (!ref) {
             throw new CliError(`Enum ${column.datatype_name} not found`);
           }
@@ -789,9 +879,9 @@ function syncRelation({ model, relation, services, options, selfRelation, simila
   const relationName = `${relation.table}${similarRelations > 0 ? `_${firstColumn}` : ""}To${relation.references.table}`;
   const sourceNameFromReference = firstSourceField.name.toLowerCase().endsWith("id") ? `${resolveNameCasing(options.fieldCasing, firstSourceField.name.slice(0, -2)).name}${relation.type === "many" ? "s" : ""}` : void 0;
   const sourceFieldFromReference = sourceModel.fields.find((f) => f.name === sourceNameFromReference);
-  let { name: sourceFieldName } = resolveNameCasing(options.fieldCasing, similarRelations > 0 ? `${fieldPrefix}${(0, import_common_helpers.lowerCaseFirst)(sourceModel.name)}_${firstColumn}` : `${(!sourceFieldFromReference ? sourceNameFromReference : void 0) || (0, import_common_helpers.lowerCaseFirst)(resolveNameCasing(options.fieldCasing, targetModel.name).name)}${relation.type === "many" ? "s" : ""}`);
+  let { name: sourceFieldName } = resolveNameCasing(options.fieldCasing, similarRelations > 0 ? `${fieldPrefix}${(0, import_common_helpers2.lowerCaseFirst)(sourceModel.name)}_${firstColumn}` : `${(!sourceFieldFromReference ? sourceNameFromReference : void 0) || (0, import_common_helpers2.lowerCaseFirst)(resolveNameCasing(options.fieldCasing, targetModel.name).name)}${relation.type === "many" ? "s" : ""}`);
   if (sourceModel.fields.find((f) => f.name === sourceFieldName)) {
-    sourceFieldName = `${sourceFieldName}To${(0, import_common_helpers.lowerCaseFirst)(targetModel.name)}_${relation.references.columns[0]}`;
+    sourceFieldName = `${sourceFieldName}To${(0, import_common_helpers2.lowerCaseFirst)(targetModel.name)}_${relation.references.columns[0]}`;
   }
   const sourceFieldFactory = new import_factory.DataFieldFactory().setContainer(sourceModel).setName(sourceFieldName).setType((tb) => tb.setOptional(relation.nullable).setArray(relation.type === "many").setReference(targetModel));
   sourceFieldFactory.addAttribute((ab) => {
@@ -832,9 +922,9 @@ 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)) ? "_" : "";
-  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" : ""}`);
+  let { name: oppositeFieldName } = resolveNameCasing(options.fieldCasing, similarRelations > 0 ? `${oppositeFieldPrefix}${(0, import_common_helpers2.lowerCaseFirst)(sourceModel.name)}_${firstColumn}` : `${(0, import_common_helpers2.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]}`));
+    ({ name: oppositeFieldName } = resolveNameCasing(options.fieldCasing, `${(0, import_common_helpers2.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)));
@@ -842,7 +932,7 @@ function syncRelation({ model, relation, services, options, selfRelation, simila
 }
 __name(syncRelation, "syncRelation");
 function consolidateEnums({ newModel, oldModel }) {
-  const newEnums = newModel.declarations.filter((d) => (0, import_ast3.isEnum)(d));
+  const newEnums = newModel.declarations.filter((d) => (0, import_ast4.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();
@@ -855,7 +945,7 @@ function consolidateEnums({ newModel, oldModel }) {
         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;
+        if (!(0, import_ast4.isEnum)(oldEnum)) continue;
         enumMapping.set(newEnum, oldEnum);
         break;
       }
@@ -2533,8 +2623,8 @@ async function runPull(options) {
   const spinner = (0, import_ora.default)();
   try {
     const schemaFile = getSchemaFile(options.schema);
-    const outPath = options.output ? import_node_path2.default.resolve(options.output) : void 0;
-    const treatAsFile = !!outPath && (import_node_fs2.default.existsSync(outPath) && import_node_fs2.default.lstatSync(outPath).isFile() || import_node_path2.default.extname(outPath) !== "");
+    const outPath = options.output ? import_node_path3.default.resolve(options.output) : void 0;
+    const treatAsFile = !!outPath && (import_node_fs2.default.existsSync(outPath) && import_node_fs2.default.lstatSync(outPath).isFile() || import_node_path3.default.extname(outPath) !== "");
     const { model, services } = await loadSchemaDocument(schemaFile, {
       returnServices: true,
       mergeImports: treatAsFile
@@ -2608,7 +2698,7 @@ async function runPull(options) {
       oldModel: model
     });
     console.log(import_colors4.default.blue("Schema synced"));
-    const baseDir = import_node_path2.default.dirname(import_node_path2.default.resolve(schemaFile));
+    const baseDir = import_node_path3.default.dirname(import_node_path3.default.resolve(schemaFile));
     const baseDirUrlPath = new URL(`file://${baseDir}`).pathname;
     const docs = services.shared.workspace.LangiumDocuments.all.filter(({ uri }) => uri.path.toLowerCase().startsWith(baseDirUrlPath.toLowerCase())).toArray();
     const docsSet = new Set(docs.map((d) => d.uri.toString()));
@@ -2644,8 +2734,8 @@ async function runPull(options) {
       deletedEnums.push(import_colors4.default.red(`- Enum ${decl.name} deleted`));
     });
     newModel.declarations.filter((d) => [
-      import_ast4.DataModel,
-      import_ast4.Enum
+      import_ast5.DataModel,
+      import_ast5.Enum
     ].includes(d.$type)).forEach((_declaration) => {
       const newDataModel = _declaration;
       const declarations = services.shared.workspace.IndexManager.allElements(newDataModel.$type, docsSet).toArray();
@@ -2893,7 +2983,7 @@ async function runPull(options) {
       if (treatAsFile) {
         const zmodelSchema = await (0, import_language2.formatDocument)(generator.generate(newModel));
         console.log(import_colors4.default.blue(`Writing to ${outPath}`));
-        import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(outPath), {
+        import_node_fs2.default.mkdirSync(import_node_path3.default.dirname(outPath), {
           recursive: true
         });
         import_node_fs2.default.writeFileSync(outPath, zmodelSchema);
@@ -2901,12 +2991,12 @@ async function runPull(options) {
         import_node_fs2.default.mkdirSync(outPath, {
           recursive: true
         });
-        const baseDir2 = import_node_path2.default.dirname(import_node_path2.default.resolve(schemaFile));
+        const baseDir2 = import_node_path3.default.dirname(import_node_path3.default.resolve(schemaFile));
         for (const { uri, parseResult: { value: documentModel } } of docs) {
           const zmodelSchema = await (0, import_language2.formatDocument)(generator.generate(documentModel));
-          const relPath = import_node_path2.default.relative(baseDir2, uri.fsPath);
-          const targetFile = import_node_path2.default.join(outPath, relPath);
-          import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(targetFile), {
+          const relPath = import_node_path3.default.relative(baseDir2, uri.fsPath);
+          const targetFile = import_node_path3.default.join(outPath, relPath);
+          import_node_fs2.default.mkdirSync(import_node_path3.default.dirname(targetFile), {
             recursive: true
           });
           console.log(import_colors4.default.blue(`Writing to ${targetFile}`));
@@ -2916,7 +3006,7 @@ async function runPull(options) {
     } else {
       for (const { uri, parseResult: { value: documentModel } } of docs) {
         const zmodelSchema = await (0, import_language2.formatDocument)(generator.generate(documentModel));
-        console.log(import_colors4.default.blue(`Writing to ${import_node_path2.default.relative(process.cwd(), uri.fsPath).replace(/\\/g, "/")}`));
+        console.log(import_colors4.default.blue(`Writing to ${import_node_path3.default.relative(process.cwd(), uri.fsPath).replace(/\\/g, "/")}`));
         import_node_fs2.default.writeFileSync(uri.fsPath, zmodelSchema);
       }
     }
@@ -2948,16 +3038,13 @@ async function run3(options) {
 __name(run3, "run");
 
 // src/actions/generate.ts
-var import_common_helpers2 = require("@zenstackhq/common-helpers");
+var import_common_helpers3 = require("@zenstackhq/common-helpers");
 var import_language4 = require("@zenstackhq/language");
-var import_ast5 = require("@zenstackhq/language/ast");
+var import_ast6 = require("@zenstackhq/language/ast");
 var import_utils7 = require("@zenstackhq/language/utils");
 var import_chokidar = require("chokidar");
 var import_colors6 = __toESM(require("colors"), 1);
-var import_jiti = require("jiti");
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
-var import_node_url = require("url");
+var import_node_path6 = __toESM(require("path"), 1);
 var import_ora2 = __toESM(require("ora"), 1);
 var import_semver = __toESM(require("semver"), 1);
 
@@ -2971,16 +3058,16 @@ __export(plugins_exports, {
 // src/plugins/prisma.ts
 var import_sdk2 = require("@zenstackhq/sdk");
 var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var plugin = {
   name: "Prisma Schema Generator",
   statusText: "Generating Prisma schema",
   async generate({ model, defaultOutputPath, pluginOptions }) {
-    let outFile = import_node_path3.default.join(defaultOutputPath, "schema.prisma");
+    let outFile = import_node_path4.default.join(defaultOutputPath, "schema.prisma");
     if (typeof pluginOptions["output"] === "string") {
-      outFile = import_node_path3.default.resolve(defaultOutputPath, pluginOptions["output"]);
-      if (!import_node_fs4.default.existsSync(import_node_path3.default.dirname(outFile))) {
-        import_node_fs4.default.mkdirSync(import_node_path3.default.dirname(outFile), {
+      outFile = import_node_path4.default.resolve(defaultOutputPath, pluginOptions["output"]);
+      if (!import_node_fs4.default.existsSync(import_node_path4.default.dirname(outFile))) {
+        import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(outFile), {
           recursive: true
         });
       }
@@ -2994,14 +3081,14 @@ var prisma_default = plugin;
 // src/plugins/typescript.ts
 var import_sdk3 = require("@zenstackhq/sdk");
 var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var plugin2 = {
   name: "TypeScript Schema Generator",
   statusText: "Generating TypeScript schema",
   async generate({ model, defaultOutputPath, pluginOptions }) {
     let outDir = defaultOutputPath;
     if (typeof pluginOptions["output"] === "string") {
-      outDir = import_node_path4.default.resolve(defaultOutputPath, pluginOptions["output"]);
+      outDir = import_node_path5.default.resolve(defaultOutputPath, pluginOptions["output"]);
       if (!import_node_fs5.default.existsSync(outDir)) {
         import_node_fs5.default.mkdirSync(outDir, {
           recursive: true
@@ -3062,7 +3149,7 @@ ${logPaths}`);
       ignorePermissionErrors: true,
       ignored: /* @__PURE__ */ __name((at) => !schemaExtensions.some((ext) => at.endsWith(ext)), "ignored")
     });
-    const reGenerateSchema = (0, import_common_helpers2.singleDebounce)(async () => {
+    const reGenerateSchema = (0, import_common_helpers3.singleDebounce)(async () => {
       if (logsEnabled) {
         console.log("Got changes, run generation!");
       }
@@ -3125,7 +3212,7 @@ async function pureGenerate(options, fromWatch) {
 
 \`\`\`ts
 import { ZenStackClient } from '@zenstackhq/orm';
-import { schema } from '${import_node_path5.default.relative(".", outputPath)}/schema';
+import { schema } from '${import_node_path6.default.relative(".", outputPath)}/schema';
 
 const client = new ZenStackClient(schema, {
     dialect: { ... }
@@ -3139,7 +3226,7 @@ Check documentation: https://zenstack.dev/docs/`);
 }
 __name(pureGenerate, "pureGenerate");
 async function runPlugins(schemaFile, model, outputPath, options) {
-  const plugins = model.declarations.filter(import_ast5.isPlugin);
+  const plugins = model.declarations.filter(import_ast6.isPlugin);
   const processedPlugins = [];
   for (const plugin3 of plugins) {
     const provider = getPluginProvider(plugin3);
@@ -3150,7 +3237,7 @@ async function runPlugins(schemaFile, model, outputPath, options) {
         throw new CliError(`Unknown core plugin: ${provider}`);
       }
     } else {
-      cliPlugin = await loadPluginModule(provider, import_node_path5.default.dirname(schemaFile));
+      cliPlugin = await loadPluginModule(provider, import_node_path6.default.dirname(schemaFile));
     }
     if (cliPlugin) {
       const pluginOptions = getPluginOptions(plugin3);
@@ -3194,7 +3281,7 @@ async function runPlugins(schemaFile, model, outputPath, options) {
     }
   });
   for (const { cliPlugin, pluginOptions } of processedPlugins) {
-    (0, import_common_helpers2.invariant)(typeof cliPlugin.generate === "function", `Plugin ${cliPlugin.name} does not have a generate function`);
+    (0, import_common_helpers3.invariant)(typeof cliPlugin.generate === "function", `Plugin ${cliPlugin.name} does not have a generate function`);
     let spinner;
     if (!options.silent) {
       spinner = (0, import_ora2.default)(cliPlugin.statusText ?? `Running plugin ${cliPlugin.name}`).start();
@@ -3214,13 +3301,6 @@ async function runPlugins(schemaFile, model, outputPath, options) {
   }
 }
 __name(runPlugins, "runPlugins");
-function getPluginProvider(plugin3) {
-  const providerField = plugin3.fields.find((f) => f.name === "provider");
-  (0, import_common_helpers2.invariant)(providerField, `Plugin ${plugin3.name} does not have a provider field`);
-  const provider = providerField.value.value;
-  return provider;
-}
-__name(getPluginProvider, "getPluginProvider");
 function getPluginOptions(plugin3) {
   const result = {};
   for (const field of plugin3.fields) {
@@ -3237,65 +3317,6 @@ function getPluginOptions(plugin3) {
   return result;
 }
 __name(getPluginOptions, "getPluginOptions");
-async function loadPluginModule(provider, basePath) {
-  let moduleSpec = provider;
-  if (moduleSpec.startsWith(".")) {
-    moduleSpec = import_node_path5.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_path5.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_path5.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");
 async function checkForMismatchedPackages(projectPath) {
   const packages = await getZenStackPackages(projectPath);
   if (!packages.length) {
@@ -3355,8 +3376,8 @@ __name(run5, "run");
 
 // src/actions/init.ts
 var import_colors8 = __toESM(require("colors"), 1);
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var import_ora3 = __toESM(require("ora"), 1);
 var import_package_manager_detector = require("package-manager-detector");
 
@@ -3435,11 +3456,11 @@ async function run6(projectPath) {
     }
   }
   const generationFolder = "zenstack";
-  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_fs6.default.existsSync(import_node_path7.default.join(projectPath, generationFolder))) {
+    import_node_fs6.default.mkdirSync(import_node_path7.default.join(projectPath, generationFolder));
   }
-  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);
+  if (!import_node_fs6.default.existsSync(import_node_path7.default.join(projectPath, generationFolder, "schema.zmodel"))) {
+    import_node_fs6.default.writeFileSync(import_node_path7.default.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
   } else {
     console.log(import_colors8.default.yellow("Schema file already exists. Skipping generation of sample."));
   }
@@ -3450,8 +3471,8 @@ async function run6(projectPath) {
 __name(run6, "run");
 
 // src/actions/migrate.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 
 // src/actions/seed.ts
 var import_colors9 = __toESM(require("colors"), 1);
@@ -3484,7 +3505,7 @@ __name(run7, "run");
 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 prismaSchemaDir = options.migrations ? import_node_path8.default.dirname(options.migrations) : void 0;
   const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
   try {
     switch (command) {
@@ -3505,8 +3526,8 @@ async function run8(command, options) {
         break;
     }
   } finally {
-    if (import_node_fs8.default.existsSync(prismaSchemaFile)) {
-      import_node_fs8.default.unlinkSync(prismaSchemaFile);
+    if (import_node_fs7.default.existsSync(prismaSchemaFile)) {
+      import_node_fs7.default.unlinkSync(prismaSchemaFile);
     }
   }
 }
@@ -3595,7 +3616,7 @@ function handleSubProcessError2(err) {
 __name(handleSubProcessError2, "handleSubProcessError");
 
 // src/actions/proxy.ts
-var import_ast6 = require("@zenstackhq/language/ast");
+var import_ast7 = require("@zenstackhq/language/ast");
 var import_utils8 = require("@zenstackhq/language/utils");
 var import_orm = require("@zenstackhq/orm");
 var import_mysql2 = require("@zenstackhq/orm/dialects/mysql");
@@ -3607,12 +3628,12 @@ var import_colors11 = __toESM(require("colors"), 1);
 var import_cors = __toESM(require("cors"), 1);
 var import_express2 = __toESM(require("express"), 1);
 var import_jiti2 = require("jiti");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 
 // src/utils/version-utils.ts
 var import_colors10 = __toESM(require("colors"), 1);
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 var import_semver2 = __toESM(require("semver"), 1);
 var import_meta2 = {};
@@ -3620,8 +3641,8 @@ var CHECK_VERSION_TIMEOUT = 2e3;
 var VERSION_CHECK_TAG = "latest";
 function getVersion() {
   try {
-    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;
+    const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path9.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    return JSON.parse(import_node_fs8.default.readFileSync(import_node_path9.default.join(_dirname, "../package.json"), "utf8")).version;
   } catch {
     return void 0;
   }
@@ -3669,11 +3690,11 @@ 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_path9.default.isAbsolute(outputPath)) {
-    outputPath = import_node_path9.default.resolve(process.cwd(), outputPath);
+  if (!import_node_path10.default.isAbsolute(outputPath)) {
+    outputPath = import_node_path10.default.resolve(process.cwd(), outputPath);
   }
   const model = await loadSchemaDocument(schemaFile);
-  const dataSource = model.declarations.find(import_ast6.isDataSource);
+  const dataSource = model.declarations.find(import_ast7.isDataSource);
   let databaseUrl = options.databaseUrl;
   if (!databaseUrl) {
     const schemaUrl = dataSource?.fields.find((f) => f.name === "url")?.value;
@@ -3686,18 +3707,18 @@ async function run9(options) {
   const dialect = await createDialect(provider, databaseUrl, outputPath);
   const fileUrl = typeof __filename !== "undefined" ? __filename : import_meta3.url;
   const jiti = (0, import_jiti2.createJiti)(fileUrl);
-  const schemaModule = await jiti.import(import_node_path9.default.join(outputPath, "schema"));
+  const schemaModule = await jiti.import(import_node_path10.default.join(outputPath, "schema"));
   const schema = schemaModule.schema;
   const omit = {};
   for (const [modelName, modelDef] of Object.entries(schema.models)) {
-    const computedFields = {};
+    const omitFields = {};
     for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
-      if (fieldDef.computed === true) {
-        computedFields[fieldName] = true;
+      if (fieldDef.computed === true || fieldDef.type === "Unsupported") {
+        omitFields[fieldName] = true;
       }
     }
-    if (Object.keys(computedFields).length > 0) {
-      omit[modelName] = computedFields;
+    if (Object.keys(omitFields).length > 0) {
+      omit[modelName] = omitFields;
     }
   }
   const db = new import_orm.ZenStackClient(schema, {
@@ -3715,9 +3736,9 @@ async function run9(options) {
 }
 __name(run9, "run");
 function evaluateUrl(schemaUrl) {
-  if ((0, import_ast6.isLiteralExpr)(schemaUrl)) {
+  if ((0, import_ast7.isLiteralExpr)(schemaUrl)) {
     return (0, import_utils8.getStringLiteral)(schemaUrl);
-  } else if ((0, import_ast6.isInvocationExpr)(schemaUrl)) {
+  } else if ((0, import_ast7.isInvocationExpr)(schemaUrl)) {
     const envFunction = schemaUrl;
     const envName = (0, import_utils8.getStringLiteral)(envFunction.args[0]?.value);
     const envValue = process.env[envName];
@@ -3757,8 +3778,8 @@ async function createDialect(provider, databaseUrl, outputPath) {
       let resolvedUrl = databaseUrl.trim();
       if (resolvedUrl.startsWith("file:")) {
         const filePath = resolvedUrl.substring("file:".length);
-        if (!import_node_path9.default.isAbsolute(filePath)) {
-          resolvedUrl = import_node_path9.default.join(outputPath, filePath);
+        if (!import_node_path10.default.isAbsolute(filePath)) {
+          resolvedUrl = import_node_path10.default.join(outputPath, filePath);
         }
       }
       console.log(import_colors11.default.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
@@ -3856,7 +3877,7 @@ __name(startServer, "startServer");
 // src/telemetry.ts
 var import_mixpanel = require("mixpanel");
 var import_node_crypto2 = require("crypto");
-var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
 var os2 = __toESM(require("os"), 1);
 
 // src/constants.ts
@@ -3867,14 +3888,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_fs11 = __toESM(require("fs"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
 
 // src/utils/is-docker.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    import_node_fs10.default.statSync("/.dockerenv");
+    import_node_fs9.default.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -3883,7 +3904,7 @@ function hasDockerEnv() {
 __name(hasDockerEnv, "hasDockerEnv");
 function hasDockerCGroup() {
   try {
-    return import_node_fs10.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return import_node_fs9.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -3901,7 +3922,7 @@ __name(isDocker, "isDocker");
 var cachedResult;
 var hasContainerEnv = /* @__PURE__ */ __name(() => {
   try {
-    import_node_fs11.default.statSync("/run/.containerenv");
+    import_node_fs10.default.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -3918,7 +3939,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_fs12 = __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;
@@ -3927,7 +3948,7 @@ var isWsl = /* @__PURE__ */ __name(() => {
     return true;
   }
   try {
-    return import_node_fs12.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    return import_node_fs11.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
   } catch {
     return false;
   }
@@ -4084,7 +4105,7 @@ var Telemetry = class {
     try {
       const packageJsonPath = import_meta4.resolve("prisma/package.json");
       const packageJsonUrl = new URL(packageJsonPath);
-      const packageJson = JSON.parse(import_node_fs13.default.readFileSync(packageJsonUrl, "utf8"));
+      const packageJson = JSON.parse(import_node_fs12.default.readFileSync(packageJsonUrl, "utf8"));
       return packageJson.version;
     } catch {
       return void 0;