@zenstackhq/cli 3.0.0-beta.33 → 3.0.0-beta.34

package/dist/index.js

@@ -275,7 +275,10 @@ import { invariant } from "@zenstackhq/common-helpers";
 import { isPlugin } from "@zenstackhq/language/ast";
 import { getLiteral, getLiteralArray } from "@zenstackhq/language/utils";
 import colors4 from "colors";
+import { createJiti } from "jiti";
+import fs6 from "fs";
 import path4 from "path";
+import { pathToFileURL } from "url";
 import ora from "ora";
 
 // src/plugins/index.ts
@@ -390,14 +393,7 @@ async function runPlugins(schemaFile, model, outputPath, options) {
         throw new CliError(`Unknown core plugin: ${provider}`);
       }
     } else {
-      let moduleSpec = provider;
-      if (moduleSpec.startsWith(".")) {
-        moduleSpec = path4.resolve(path4.dirname(schemaFile), moduleSpec);
-      }
-      try {
-        cliPlugin = (await import(moduleSpec)).default;
-      } catch {
-      }
+      cliPlugin = await loadPluginModule(provider, path4.dirname(schemaFile));
     }
     if (cliPlugin) {
       const pluginOptions = getPluginOptions(plugin3);
@@ -426,7 +422,7 @@ async function runPlugins(schemaFile, model, outputPath, options) {
   ];
   defaultPlugins.forEach(({ plugin: plugin3, options: options2 }) => {
     if (!processedPlugins.some((p) => p.cliPlugin === plugin3)) {
-      processedPlugins.push({
+      processedPlugins.unshift({
         cliPlugin: plugin3,
         pluginOptions: options2
       });
@@ -476,6 +472,65 @@ function getPluginOptions(plugin3) {
   return result;
 }
 __name(getPluginOptions, "getPluginOptions");
+async function loadPluginModule(provider, basePath) {
+  let moduleSpec = provider;
+  if (moduleSpec.startsWith(".")) {
+    moduleSpec = path4.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 = createJiti(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 (fs6.existsSync(moduleSpec) && fs6.statSync(moduleSpec).isFile()) {
+    if (esmSuffixes.some((suffix) => moduleSpec.endsWith(suffix))) {
+      return await importAsEsm(pathToFileURL(moduleSpec).toString());
+    }
+    if (tsSuffixes.some((suffix) => moduleSpec.endsWith(suffix))) {
+      return await importAsTs(moduleSpec);
+    }
+  }
+  for (const suffix of esmSuffixes) {
+    const indexPath = path4.join(moduleSpec, `index${suffix}`);
+    if (fs6.existsSync(indexPath)) {
+      return await importAsEsm(pathToFileURL(indexPath).toString());
+    }
+  }
+  for (const suffix of tsSuffixes) {
+    const indexPath = path4.join(moduleSpec, `index${suffix}`);
+    if (fs6.existsSync(indexPath)) {
+      return await importAsTs(indexPath);
+    }
+  }
+  try {
+    return (await import(moduleSpec)).default;
+  } catch {
+    return void 0;
+  }
+}
+__name(loadPluginModule, "loadPluginModule");
 
 // src/actions/info.ts
 import colors5 from "colors";
@@ -542,7 +597,7 @@ __name(getZenStackPackages, "getZenStackPackages");
 
 // src/actions/init.ts
 import colors6 from "colors";
-import fs6 from "fs";
+import fs7 from "fs";
 import path6 from "path";
 import ora2 from "ora";
 import { detect, resolveCommand } from "package-manager-detector";
@@ -618,11 +673,11 @@ async function run6(projectPath) {
     }
   }
   const generationFolder = "zenstack";
-  if (!fs6.existsSync(path6.join(projectPath, generationFolder))) {
-    fs6.mkdirSync(path6.join(projectPath, generationFolder));
+  if (!fs7.existsSync(path6.join(projectPath, generationFolder))) {
+    fs7.mkdirSync(path6.join(projectPath, generationFolder));
   }
-  if (!fs6.existsSync(path6.join(projectPath, generationFolder, "schema.zmodel"))) {
-    fs6.writeFileSync(path6.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(colors6.yellow("Schema file already exists. Skipping generation of sample."));
   }
@@ -633,7 +688,7 @@ async function run6(projectPath) {
 __name(run6, "run");
 
 // src/actions/migrate.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path7 from "path";
 
 // src/actions/seed.ts
@@ -688,8 +743,8 @@ async function run8(command, options) {
         break;
     }
   } finally {
-    if (fs7.existsSync(prismaSchemaFile)) {
-      fs7.unlinkSync(prismaSchemaFile);
+    if (fs8.existsSync(prismaSchemaFile)) {
+      fs8.unlinkSync(prismaSchemaFile);
     }
   }
 }
@@ -780,7 +835,7 @@ __name(handleSubProcessError2, "handleSubProcessError");
 // src/telemetry.ts
 import { init } from "mixpanel";
 import { randomUUID as randomUUID2 } from "crypto";
-import fs12 from "fs";
+import fs13 from "fs";
 import * as os2 from "os";
 
 // src/constants.ts
@@ -791,14 +846,14 @@ import { env } from "process";
 var isInCi = env["CI"] !== "0" && env["CI"] !== "false" && ("CI" in env || "CONTINUOUS_INTEGRATION" in env || Object.keys(env).some((key) => key.startsWith("CI_")));
 
 // src/utils/is-container.ts
-import fs9 from "fs";
+import fs10 from "fs";
 
 // src/utils/is-docker.ts
-import fs8 from "fs";
+import fs9 from "fs";
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    fs8.statSync("/.dockerenv");
+    fs9.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -807,7 +862,7 @@ function hasDockerEnv() {
 __name(hasDockerEnv, "hasDockerEnv");
 function hasDockerCGroup() {
   try {
-    return fs8.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs9.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -825,7 +880,7 @@ __name(isDocker, "isDocker");
 var cachedResult;
 var hasContainerEnv = /* @__PURE__ */ __name(() => {
   try {
-    fs9.statSync("/run/.containerenv");
+    fs10.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -842,7 +897,7 @@ __name(isInContainer, "isInContainer");
 // src/utils/is-wsl.ts
 import process2 from "process";
 import os from "os";
-import fs10 from "fs";
+import fs11 from "fs";
 var isWsl = /* @__PURE__ */ __name(() => {
   if (process2.platform !== "linux") {
     return false;
@@ -851,7 +906,7 @@ var isWsl = /* @__PURE__ */ __name(() => {
     return true;
   }
   try {
-    return fs10.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    return fs11.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
   } catch {
     return false;
   }
@@ -916,7 +971,7 @@ __name(getMachineId, "getMachineId");
 
 // src/utils/version-utils.ts
 import colors8 from "colors";
-import fs11 from "fs";
+import fs12 from "fs";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import semver from "semver";
@@ -925,7 +980,7 @@ var VERSION_CHECK_TAG = "next";
 function getVersion() {
   try {
     const _dirname = typeof __dirname !== "undefined" ? __dirname : path8.dirname(fileURLToPath2(import.meta.url));
-    return JSON.parse(fs11.readFileSync(path8.join(_dirname, "../package.json"), "utf8")).version;
+    return JSON.parse(fs12.readFileSync(path8.join(_dirname, "../package.json"), "utf8")).version;
   } catch {
     return void 0;
   }
@@ -1055,7 +1110,7 @@ var Telemetry = class {
     try {
       const packageJsonPath = import.meta.resolve("prisma/package.json");
       const packageJsonUrl = new URL(packageJsonPath);
-      const packageJson = JSON.parse(fs12.readFileSync(packageJsonUrl, "utf8"));
+      const packageJson = JSON.parse(fs13.readFileSync(packageJsonUrl, "utf8"));
       return packageJson.version;
     } catch {
       return void 0;