@zenstackhq/cli 3.4.2 → 3.4.4

package/dist/index.js

@@ -18,16 +18,23 @@ import colors12 from "colors";
 import { Command, CommanderError, Option } from "commander";
 
 // src/actions/check.ts
+import { isPlugin } from "@zenstackhq/language/ast";
 import colors2 from "colors";
+import path2 from "path";
 
 // src/actions/action-utils.ts
+import { invariant } from "@zenstackhq/common-helpers";
 import { loadDocument } from "@zenstackhq/language";
 import { isDataSource } from "@zenstackhq/language/ast";
 import { PrismaSchemaGenerator } from "@zenstackhq/sdk";
 import colors from "colors";
+import { createJiti } from "jiti";
 import fs from "fs";
 import { createRequire } from "module";
 import path from "path";
+import { pathToFileURL } from "url";
+import terminalLink from "terminal-link";
+import { z } from "zod";
 
 // src/cli-error.ts
 var CliError = class extends Error {
@@ -37,8 +44,6 @@ var CliError = class extends Error {
 };
 
 // src/actions/action-utils.ts
-import terminalLink from "terminal-link";
-import { z } from "zod";
 function getSchemaFile(file) {
   if (file) {
     if (!fs.existsSync(file)) {
@@ -214,6 +219,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");
+  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 = path.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 (fs.existsSync(moduleSpec) && fs.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 = path.join(moduleSpec, `index${suffix}`);
+    if (fs.existsSync(indexPath)) {
+      return await importAsEsm(pathToFileURL(indexPath).toString());
+    }
+  }
+  for (const suffix of tsSuffixes) {
+    const indexPath = path.join(moduleSpec, `index${suffix}`);
+    if (fs.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 = z.object({
@@ -271,7 +350,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(colors2.green("\u2713 Schema validation completed successfully."));
   } catch (error) {
     console.error(colors2.red("\u2717 Schema validation failed."));
@@ -279,13 +359,23 @@ async function run(options) {
   }
 }
 __name(run, "run");
+async function checkPluginResolution(schemaFile, model) {
+  const plugins = model.declarations.filter(isPlugin);
+  for (const plugin3 of plugins) {
+    const provider = getPluginProvider(plugin3);
+    if (!provider.startsWith("@core/")) {
+      await loadPluginModule(provider, path2.dirname(schemaFile));
+    }
+  }
+}
+__name(checkPluginResolution, "checkPluginResolution");
 
 // src/actions/db.ts
 import { formatDocument, ZModelCodeGenerator } from "@zenstackhq/language";
 import { DataModel, Enum } from "@zenstackhq/language/ast";
 import colors4 from "colors";
 import fs2 from "fs";
-import path2 from "path";
+import path3 from "path";
 import ora from "ora";
 
 // src/utils/exec-utils.ts
@@ -2246,7 +2336,7 @@ var sqlite = {
         const stmt = db.prepare(sql);
         return stmt.all();
       }, "all");
-      const tablesRaw = all("SELECT name, type, sql AS definition FROM sqlite_schema WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' ORDER BY name");
+      const tablesRaw = all("SELECT name, type, sql AS definition FROM sqlite_schema WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' AND name <> '_prisma_migrations' ORDER BY name");
       const autoIncrementTables = /* @__PURE__ */ new Set();
       for (const t of tablesRaw) {
         if (t.type === "table" && t.definition) {
@@ -2516,8 +2606,8 @@ async function runPull(options) {
   const spinner = ora();
   try {
     const schemaFile = getSchemaFile(options.schema);
-    const outPath = options.output ? path2.resolve(options.output) : void 0;
-    const treatAsFile = !!outPath && (fs2.existsSync(outPath) && fs2.lstatSync(outPath).isFile() || path2.extname(outPath) !== "");
+    const outPath = options.output ? path3.resolve(options.output) : void 0;
+    const treatAsFile = !!outPath && (fs2.existsSync(outPath) && fs2.lstatSync(outPath).isFile() || path3.extname(outPath) !== "");
     const { model, services } = await loadSchemaDocument(schemaFile, {
       returnServices: true,
       mergeImports: treatAsFile
@@ -2591,7 +2681,7 @@ async function runPull(options) {
       oldModel: model
     });
     console.log(colors4.blue("Schema synced"));
-    const baseDir = path2.dirname(path2.resolve(schemaFile));
+    const baseDir = path3.dirname(path3.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()));
@@ -2876,7 +2966,7 @@ async function runPull(options) {
       if (treatAsFile) {
         const zmodelSchema = await formatDocument(generator.generate(newModel));
         console.log(colors4.blue(`Writing to ${outPath}`));
-        fs2.mkdirSync(path2.dirname(outPath), {
+        fs2.mkdirSync(path3.dirname(outPath), {
           recursive: true
         });
         fs2.writeFileSync(outPath, zmodelSchema);
@@ -2884,12 +2974,12 @@ async function runPull(options) {
         fs2.mkdirSync(outPath, {
           recursive: true
         });
-        const baseDir2 = path2.dirname(path2.resolve(schemaFile));
+        const baseDir2 = path3.dirname(path3.resolve(schemaFile));
         for (const { uri, parseResult: { value: documentModel } } of docs) {
           const zmodelSchema = await formatDocument(generator.generate(documentModel));
-          const relPath = path2.relative(baseDir2, uri.fsPath);
-          const targetFile = path2.join(outPath, relPath);
-          fs2.mkdirSync(path2.dirname(targetFile), {
+          const relPath = path3.relative(baseDir2, uri.fsPath);
+          const targetFile = path3.join(outPath, relPath);
+          fs2.mkdirSync(path3.dirname(targetFile), {
             recursive: true
           });
           console.log(colors4.blue(`Writing to ${targetFile}`));
@@ -2899,7 +2989,7 @@ async function runPull(options) {
     } else {
       for (const { uri, parseResult: { value: documentModel } } of docs) {
         const zmodelSchema = await formatDocument(generator.generate(documentModel));
-        console.log(colors4.blue(`Writing to ${path2.relative(process.cwd(), uri.fsPath).replace(/\\/g, "/")}`));
+        console.log(colors4.blue(`Writing to ${path3.relative(process.cwd(), uri.fsPath).replace(/\\/g, "/")}`));
         fs2.writeFileSync(uri.fsPath, zmodelSchema);
       }
     }
@@ -2931,16 +3021,13 @@ async function run3(options) {
 __name(run3, "run");
 
 // src/actions/generate.ts
-import { invariant, singleDebounce } from "@zenstackhq/common-helpers";
+import { invariant as invariant2, singleDebounce } from "@zenstackhq/common-helpers";
 import { ZModelLanguageMetaData } from "@zenstackhq/language";
-import { isPlugin } from "@zenstackhq/language/ast";
+import { isPlugin as isPlugin2 } from "@zenstackhq/language/ast";
 import { getLiteral, getLiteralArray as getLiteralArray2 } from "@zenstackhq/language/utils";
 import { watch } from "chokidar";
 import colors6 from "colors";
-import { createJiti } from "jiti";
-import fs6 from "fs";
-import path5 from "path";
-import { pathToFileURL } from "url";
+import path6 from "path";
 import ora2 from "ora";
 import semver from "semver";
 
@@ -2954,16 +3041,16 @@ __export(plugins_exports, {
 // src/plugins/prisma.ts
 import { PrismaSchemaGenerator as PrismaSchemaGenerator2 } from "@zenstackhq/sdk";
 import fs4 from "fs";
-import path3 from "path";
+import path4 from "path";
 var plugin = {
   name: "Prisma Schema Generator",
   statusText: "Generating Prisma schema",
   async generate({ model, defaultOutputPath, pluginOptions }) {
-    let outFile = path3.join(defaultOutputPath, "schema.prisma");
+    let outFile = path4.join(defaultOutputPath, "schema.prisma");
     if (typeof pluginOptions["output"] === "string") {
-      outFile = path3.resolve(defaultOutputPath, pluginOptions["output"]);
-      if (!fs4.existsSync(path3.dirname(outFile))) {
-        fs4.mkdirSync(path3.dirname(outFile), {
+      outFile = path4.resolve(defaultOutputPath, pluginOptions["output"]);
+      if (!fs4.existsSync(path4.dirname(outFile))) {
+        fs4.mkdirSync(path4.dirname(outFile), {
           recursive: true
         });
       }
@@ -2977,14 +3064,14 @@ var prisma_default = plugin;
 // src/plugins/typescript.ts
 import { TsSchemaGenerator } from "@zenstackhq/sdk";
 import fs5 from "fs";
-import path4 from "path";
+import path5 from "path";
 var plugin2 = {
   name: "TypeScript Schema Generator",
   statusText: "Generating TypeScript schema",
   async generate({ model, defaultOutputPath, pluginOptions }) {
     let outDir = defaultOutputPath;
     if (typeof pluginOptions["output"] === "string") {
-      outDir = path4.resolve(defaultOutputPath, pluginOptions["output"]);
+      outDir = path5.resolve(defaultOutputPath, pluginOptions["output"]);
       if (!fs5.existsSync(outDir)) {
         fs5.mkdirSync(outDir, {
           recursive: true
@@ -3108,7 +3195,7 @@ async function pureGenerate(options, fromWatch) {
 
 \`\`\`ts
 import { ZenStackClient } from '@zenstackhq/orm';
-import { schema } from '${path5.relative(".", outputPath)}/schema';
+import { schema } from '${path6.relative(".", outputPath)}/schema';
 
 const client = new ZenStackClient(schema, {
     dialect: { ... }
@@ -3122,7 +3209,7 @@ Check documentation: https://zenstack.dev/docs/`);
 }
 __name(pureGenerate, "pureGenerate");
 async function runPlugins(schemaFile, model, outputPath, options) {
-  const plugins = model.declarations.filter(isPlugin);
+  const plugins = model.declarations.filter(isPlugin2);
   const processedPlugins = [];
   for (const plugin3 of plugins) {
     const provider = getPluginProvider(plugin3);
@@ -3133,7 +3220,7 @@ async function runPlugins(schemaFile, model, outputPath, options) {
         throw new CliError(`Unknown core plugin: ${provider}`);
       }
     } else {
-      cliPlugin = await loadPluginModule(provider, path5.dirname(schemaFile));
+      cliPlugin = await loadPluginModule(provider, path6.dirname(schemaFile));
     }
     if (cliPlugin) {
       const pluginOptions = getPluginOptions(plugin3);
@@ -3177,7 +3264,7 @@ async function runPlugins(schemaFile, model, outputPath, options) {
     }
   });
   for (const { cliPlugin, pluginOptions } of processedPlugins) {
-    invariant(typeof cliPlugin.generate === "function", `Plugin ${cliPlugin.name} does not have a generate function`);
+    invariant2(typeof cliPlugin.generate === "function", `Plugin ${cliPlugin.name} does not have a generate function`);
     let spinner;
     if (!options.silent) {
       spinner = ora2(cliPlugin.statusText ?? `Running plugin ${cliPlugin.name}`).start();
@@ -3197,13 +3284,6 @@ async function runPlugins(schemaFile, model, outputPath, options) {
   }
 }
 __name(runPlugins, "runPlugins");
-function getPluginProvider(plugin3) {
-  const providerField = plugin3.fields.find((f) => f.name === "provider");
-  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) {
@@ -3220,65 +3300,6 @@ function getPluginOptions(plugin3) {
   return result;
 }
 __name(getPluginOptions, "getPluginOptions");
-async function loadPluginModule(provider, basePath) {
-  let moduleSpec = provider;
-  if (moduleSpec.startsWith(".")) {
-    moduleSpec = path5.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 = path5.join(moduleSpec, `index${suffix}`);
-    if (fs6.existsSync(indexPath)) {
-      return await importAsEsm(pathToFileURL(indexPath).toString());
-    }
-  }
-  for (const suffix of tsSuffixes) {
-    const indexPath = path5.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");
 async function checkForMismatchedPackages(projectPath) {
   const packages = await getZenStackPackages(projectPath);
   if (!packages.length) {
@@ -3338,8 +3359,8 @@ __name(run5, "run");
 
 // src/actions/init.ts
 import colors8 from "colors";
-import fs7 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path7 from "path";
 import ora3 from "ora";
 import { detect, resolveCommand } from "package-manager-detector";
 
@@ -3379,6 +3400,10 @@ async function run6(projectPath) {
       name: "@zenstackhq/cli@latest",
       dev: true
     },
+    {
+      name: "@zenstackhq/schema@latest",
+      dev: false
+    },
     {
       name: "@zenstackhq/orm@latest",
       dev: false
@@ -3414,11 +3439,11 @@ async function run6(projectPath) {
     }
   }
   const generationFolder = "zenstack";
-  if (!fs7.existsSync(path6.join(projectPath, generationFolder))) {
-    fs7.mkdirSync(path6.join(projectPath, generationFolder));
+  if (!fs6.existsSync(path7.join(projectPath, generationFolder))) {
+    fs6.mkdirSync(path7.join(projectPath, generationFolder));
   }
-  if (!fs7.existsSync(path6.join(projectPath, generationFolder, "schema.zmodel"))) {
-    fs7.writeFileSync(path6.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
+  if (!fs6.existsSync(path7.join(projectPath, generationFolder, "schema.zmodel"))) {
+    fs6.writeFileSync(path7.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
   } else {
     console.log(colors8.yellow("Schema file already exists. Skipping generation of sample."));
   }
@@ -3429,8 +3454,8 @@ async function run6(projectPath) {
 __name(run6, "run");
 
 // src/actions/migrate.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path8 from "path";
 
 // src/actions/seed.ts
 import colors9 from "colors";
@@ -3463,7 +3488,7 @@ __name(run7, "run");
 async function run8(command, options) {
   const schemaFile = getSchemaFile(options.schema);
   await requireDataSourceUrl(schemaFile);
-  const prismaSchemaDir = options.migrations ? path7.dirname(options.migrations) : void 0;
+  const prismaSchemaDir = options.migrations ? path8.dirname(options.migrations) : void 0;
   const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
   try {
     switch (command) {
@@ -3484,8 +3509,8 @@ async function run8(command, options) {
         break;
     }
   } finally {
-    if (fs8.existsSync(prismaSchemaFile)) {
-      fs8.unlinkSync(prismaSchemaFile);
+    if (fs7.existsSync(prismaSchemaFile)) {
+      fs7.unlinkSync(prismaSchemaFile);
     }
   }
 }
@@ -3586,20 +3611,20 @@ import colors11 from "colors";
 import cors from "cors";
 import express from "express";
 import { createJiti as createJiti2 } from "jiti";
-import path9 from "path";
+import path10 from "path";
 
 // src/utils/version-utils.ts
 import colors10 from "colors";
-import fs9 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import semver2 from "semver";
 var CHECK_VERSION_TIMEOUT = 2e3;
 var VERSION_CHECK_TAG = "latest";
 function getVersion() {
   try {
-    const _dirname = typeof __dirname !== "undefined" ? __dirname : path8.dirname(fileURLToPath2(import.meta.url));
-    return JSON.parse(fs9.readFileSync(path8.join(_dirname, "../package.json"), "utf8")).version;
+    const _dirname = typeof __dirname !== "undefined" ? __dirname : path9.dirname(fileURLToPath2(import.meta.url));
+    return JSON.parse(fs8.readFileSync(path9.join(_dirname, "../package.json"), "utf8")).version;
   } catch {
     return void 0;
   }
@@ -3646,8 +3671,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 (!path9.isAbsolute(outputPath)) {
-    outputPath = path9.resolve(process.cwd(), outputPath);
+  if (!path10.isAbsolute(outputPath)) {
+    outputPath = path10.resolve(process.cwd(), outputPath);
   }
   const model = await loadSchemaDocument(schemaFile);
   const dataSource = model.declarations.find(isDataSource2);
@@ -3663,18 +3688,18 @@ async function run9(options) {
   const dialect = await createDialect(provider, databaseUrl, outputPath);
   const fileUrl = typeof __filename !== "undefined" ? __filename : import.meta.url;
   const jiti = createJiti2(fileUrl);
-  const schemaModule = await jiti.import(path9.join(outputPath, "schema"));
+  const schemaModule = await jiti.import(path10.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 ZenStackClient(schema, {
@@ -3734,8 +3759,8 @@ async function createDialect(provider, databaseUrl, outputPath) {
       let resolvedUrl = databaseUrl.trim();
       if (resolvedUrl.startsWith("file:")) {
         const filePath = resolvedUrl.substring("file:".length);
-        if (!path9.isAbsolute(filePath)) {
-          resolvedUrl = path9.join(outputPath, filePath);
+        if (!path10.isAbsolute(filePath)) {
+          resolvedUrl = path10.join(outputPath, filePath);
         }
       }
       console.log(colors11.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
@@ -3833,7 +3858,7 @@ __name(startServer, "startServer");
 // src/telemetry.ts
 import { init } from "mixpanel";
 import { randomUUID as randomUUID2 } from "crypto";
-import fs13 from "fs";
+import fs12 from "fs";
 import * as os2 from "os";
 
 // src/constants.ts
@@ -3844,14 +3869,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 fs11 from "fs";
+import fs10 from "fs";
 
 // src/utils/is-docker.ts
-import fs10 from "fs";
+import fs9 from "fs";
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    fs10.statSync("/.dockerenv");
+    fs9.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -3860,7 +3885,7 @@ function hasDockerEnv() {
 __name(hasDockerEnv, "hasDockerEnv");
 function hasDockerCGroup() {
   try {
-    return fs10.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs9.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -3878,7 +3903,7 @@ __name(isDocker, "isDocker");
 var cachedResult;
 var hasContainerEnv = /* @__PURE__ */ __name(() => {
   try {
-    fs11.statSync("/run/.containerenv");
+    fs10.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -3895,7 +3920,7 @@ __name(isInContainer, "isInContainer");
 // src/utils/is-wsl.ts
 import process2 from "process";
 import os from "os";
-import fs12 from "fs";
+import fs11 from "fs";
 var isWsl = /* @__PURE__ */ __name(() => {
   if (process2.platform !== "linux") {
     return false;
@@ -3904,7 +3929,7 @@ var isWsl = /* @__PURE__ */ __name(() => {
     return true;
   }
   try {
-    return fs12.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    return fs11.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
   } catch {
     return false;
   }
@@ -4060,7 +4085,7 @@ var Telemetry = class {
     try {
       const packageJsonPath = import.meta.resolve("prisma/package.json");
       const packageJsonUrl = new URL(packageJsonPath);
-      const packageJson = JSON.parse(fs13.readFileSync(packageJsonUrl, "utf8"));
+      const packageJson = JSON.parse(fs12.readFileSync(packageJsonUrl, "utf8"));
       return packageJson.version;
     } catch {
       return void 0;