@prisma/internals 6.6.0-dev.33 → 6.6.0-dev.35

package/dist/{chunk-UBYXOLCN.js → chunk-O3MUXTZX.js}

@@ -26,8 +26,8 @@ var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__g
   mod
 ));
 var __toCommonJS2 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_UBYXOLCN_exports = {};
-__export2(chunk_UBYXOLCN_exports, {
+var chunk_O3MUXTZX_exports = {};
+__export2(chunk_O3MUXTZX_exports, {
   checkTypeScriptVersion: () => checkTypeScriptVersion,
   checkUnsupportedDataProxy: () => checkUnsupportedDataProxy,
   debug: () => debug5,
@@ -52,15 +52,15 @@ __export2(chunk_UBYXOLCN_exports, {
   loadEnvFile: () => loadEnvFile,
   loadSchemaContext: () => loadSchemaContext,
   prismaClientResolver: () => prismaClientResolver,
+  processSchemaResult: () => processSchemaResult,
   sendPanic: () => sendPanic,
   skipIndex: () => skipIndex
 });
-module.exports = __toCommonJS2(chunk_UBYXOLCN_exports);
-var import_chunk_ETNCBIDF = require("./chunk-ETNCBIDF.js");
+module.exports = __toCommonJS2(chunk_O3MUXTZX_exports);
 var import_chunk_GHHABGYW = require("./chunk-GHHABGYW.js");
 var import_chunk_EUTJYQDW = require("./chunk-EUTJYQDW.js");
-var import_chunk_IPKE37QC = require("./chunk-IPKE37QC.js");
 var import_chunk_DGZO4GAJ = require("./chunk-DGZO4GAJ.js");
+var import_chunk_ETNCBIDF = require("./chunk-ETNCBIDF.js");
 var import_chunk_72UZXEBG = require("./chunk-72UZXEBG.js");
 var import_chunk_X77CS5RK = require("./chunk-X77CS5RK.js");
 var import_chunk_EIERU2IM = require("./chunk-EIERU2IM.js");
@@ -78,14 +78,14 @@ var import_chunk_FNA4EAZ6 = require("./chunk-FNA4EAZ6.js");
 var import_chunk_J77ZIDXB = require("./chunk-J77ZIDXB.js");
 var import_chunk_2T4NJDHK = require("./chunk-2T4NJDHK.js");
 var import_chunk_R3J2O23S = require("./chunk-R3J2O23S.js");
-var import_chunk_TSJICM5S = require("./chunk-TSJICM5S.js");
-var import_chunk_25XBBR4V = require("./chunk-25XBBR4V.js");
-var import_chunk_P62PZLW4 = require("./chunk-P62PZLW4.js");
-var import_chunk_Y5IIJ464 = require("./chunk-Y5IIJ464.js");
-var import_chunk_N4QYGJOZ = require("./chunk-N4QYGJOZ.js");
+var import_chunk_CRVLHWC5 = require("./chunk-CRVLHWC5.js");
+var import_chunk_NZDLSDLM = require("./chunk-NZDLSDLM.js");
+var import_chunk_GNK3AD6X = require("./chunk-GNK3AD6X.js");
+var import_chunk_DJYSR6QD = require("./chunk-DJYSR6QD.js");
+var import_chunk_OKJT45NT = require("./chunk-OKJT45NT.js");
 var import_chunk_YRBRUREX = require("./chunk-YRBRUREX.js");
 var import_chunk_XKZ6CBLA = require("./chunk-XKZ6CBLA.js");
-var import_chunk_LN2AVE5M = require("./chunk-LN2AVE5M.js");
+var import_chunk_LR3WWKZI = require("./chunk-LR3WWKZI.js");
 var import_chunk_CCQRDM7X = require("./chunk-CCQRDM7X.js");
 var import_chunk_2B26F5N3 = require("./chunk-2B26F5N3.js");
 var import_chunk_RAYPCPVU = require("./chunk-RAYPCPVU.js");
@@ -14013,8 +14013,8 @@ var require_dist = (0, import_chunk_2ESYSVXG.__commonJS)({
           status: "disabled"
         };
       }
-      const config2 = await Config.new(state);
-      const cacheResponse = await config2.checkCache(state);
+      const config = await Config.new(state);
+      const cacheResponse = await config.checkCache(state);
       state.check_if_update_available = cacheResponse.stale === true || !cacheResponse.cache;
       const child = spawn(state);
       if (state.unref) {
@@ -14029,7 +14029,7 @@ var require_dist = (0, import_chunk_2ESYSVXG.__commonJS)({
       }
       for (const key of Object.keys(state)) {
         if (state[key]) {
-          await config2.set({
+          await config.set({
             [key]: state[key]
           });
         }
@@ -14041,7 +14041,7 @@ var require_dist = (0, import_chunk_2ESYSVXG.__commonJS)({
           data: cacheResponse.cache.output
         };
       }
-      await config2.set({
+      await config.set({
         last_reminder: state.now()
       });
       return {
@@ -14532,12 +14532,12 @@ async function readSchemaFromDirectory(schemaPath2) {
   }
   const files = await (0, import_schema_files_loader.loadSchemaFiles)(schemaPath2);
   debug2("Loading config");
-  const config2 = await (0, import_chunk_Y5IIJ464.getConfig)({
+  const config = await (0, import_chunk_DJYSR6QD.getConfig)({
     datamodel: files,
     ignoreEnvVarErrors: true
   });
   debug2("Ok");
-  if (!(0, import_schema_files_loader.usesPrismaSchemaFolder)(config2)) {
+  if (!(0, import_schema_files_loader.usesPrismaSchemaFolder)(config)) {
     return { ok: false, error: { kind: "FolderPreviewNotEnabled", path: schemaPath2 } };
   }
   return { ok: true, schema: { schemaPath: schemaPath2, schemaRootDir: schemaPath2, schemas: files } };
@@ -14640,23 +14640,23 @@ async function readSchemaFromPrismaConfigBasedLocation(schemaPathFromConfig) {
       error: { kind: "PrismaConfigNotConfigured" }
     };
   }
-  let schemaResult2;
+  let schemaResult;
   if (schemaPathFromConfig.kind === "single") {
-    schemaResult2 = await readSchemaFromSingleFile(schemaPathFromConfig.filePath);
-    if (!schemaResult2.ok) {
+    schemaResult = await readSchemaFromSingleFile(schemaPathFromConfig.filePath);
+    if (!schemaResult.ok) {
       throw new Error(
-        `Could not load schema from file \`${schemaPathFromConfig.filePath}\` provided by "prisma.config.ts"\`: ${renderLookupError(schemaResult2.error)}`
+        `Could not load schema from file \`${schemaPathFromConfig.filePath}\` provided by "prisma.config.ts"\`: ${renderLookupError(schemaResult.error)}`
       );
     }
   } else {
-    schemaResult2 = await readSchemaFromDirectory(schemaPathFromConfig.folderPath);
-    if (!schemaResult2.ok) {
+    schemaResult = await readSchemaFromDirectory(schemaPathFromConfig.folderPath);
+    if (!schemaResult.ok) {
       throw new Error(
-        `Could not load schema from folder \`${schemaPathFromConfig.folderPath}\` provided by "prisma.config.ts"\`: ${renderLookupError(schemaResult2.error)}`
+        `Could not load schema from folder \`${schemaPathFromConfig.folderPath}\` provided by "prisma.config.ts"\`: ${renderLookupError(schemaResult.error)}`
       );
     }
   }
-  return schemaResult2;
+  return schemaResult;
 }
 async function getSchemaFromPackageJson(cwd) {
   const prismaConfig = await getPrismaConfigFromPackageJson(cwd);
@@ -14826,10 +14826,10 @@ function schemaPathToEnvPath(schemaPath2) {
 }
 async function loadEnvFile({
   schemaPath: schemaPath2,
-  config: config2,
+  config,
   printMessage = false
 }) {
-  if (config2.loadedFromFile) {
+  if (config.loadedFromFile) {
     process.stdout.write(`Prisma config detected, skipping environment variable loading.
 `);
     return;
@@ -14858,8 +14858,8 @@ async function checkUnsupportedDataProxyMessage(command, args, schemaPathFromCon
     if (argName.includes("schema")) {
       await loadEnvFile({ schemaPath: argValue, printMessage: false, config: (0, import_config.defaultTestConfig)() });
       const datamodel = await import_fs.default.promises.readFile(argValue, "utf-8");
-      const config2 = await (0, import_chunk_Y5IIJ464.getConfig)({ datamodel, ignoreEnvVarErrors: true });
-      const url = (0, import_chunk_Y5IIJ464.resolveUrl)((0, import_chunk_Y5IIJ464.getEffectiveUrl)(config2.datasources[0]));
+      const config = await (0, import_chunk_DJYSR6QD.getConfig)({ datamodel, ignoreEnvVarErrors: true });
+      const url = (0, import_chunk_DJYSR6QD.resolveUrl)((0, import_chunk_DJYSR6QD.getEffectiveUrl)(config.datasources[0]));
       if (url?.startsWith("prisma://")) {
         return forbiddenCmdWithDataProxyFlagMessage(command);
       }
@@ -14885,35 +14885,39 @@ async function loadSchemaContext({
   schemaPathFromArg,
   schemaPathFromConfig,
   printLoadMessage = true,
+  ignoreEnvVarErrors = false,
   allowNull = false
-}) {
-  let schemaResult2 = null;
+} = {}) {
+  let schemaResult = null;
   if (allowNull) {
-    schemaResult2 = await getSchemaWithPathOptional(schemaPathFromArg, schemaPathFromConfig);
-    if (!schemaResult2) return null;
+    schemaResult = await getSchemaWithPathOptional(schemaPathFromArg, schemaPathFromConfig);
+    if (!schemaResult) return null;
   } else {
-    schemaResult2 = await getSchemaWithPath(schemaPathFromArg, schemaPathFromConfig);
+    schemaResult = await getSchemaWithPath(schemaPathFromArg, schemaPathFromConfig);
   }
-  return processSchemaResult({ schemaResult: schemaResult2, printLoadMessage });
+  return processSchemaResult({ schemaResult, printLoadMessage, ignoreEnvVarErrors });
 }
 async function processSchemaResult({
-  schemaResult: schemaResult2,
-  printLoadMessage
+  schemaResult,
+  printLoadMessage = true,
+  ignoreEnvVarErrors = false
 }) {
   const cwd = process.cwd();
-  const loadedFromPathForLogMessages = import_path3.default.relative(cwd, schemaResult2.schemaPath);
+  const loadedFromPathForLogMessages = import_path3.default.relative(cwd, schemaResult.schemaPath);
   if (printLoadMessage) {
     process.stdout.write((0, import_chunk_PG5FDKSF.dim)(`Prisma schema loaded from ${loadedFromPathForLogMessages}`) + "\n");
   }
-  const configFromPsl = await (0, import_chunk_Y5IIJ464.getConfig)({ datamodel: schemaResult2.schemas });
+  const configFromPsl = await (0, import_chunk_DJYSR6QD.getConfig)({ datamodel: schemaResult.schemas, ignoreEnvVarErrors });
   const primaryDatasource = configFromPsl.datasources.at(0);
   return {
-    schemaFiles: schemaResult2.schemas,
-    schemaPath: schemaResult2.schemaPath,
-    schemaRootDir: schemaResult2.schemaRootDir || cwd,
+    schemaFiles: schemaResult.schemas,
+    schemaPath: schemaResult.schemaPath,
+    schemaRootDir: schemaResult.schemaRootDir || cwd,
+    datasources: configFromPsl.datasources,
     generators: configFromPsl.generators,
     primaryDatasource,
-    primaryDatasourceDirectory: primaryDatasourceDirectory(primaryDatasource) || schemaResult2.schemaRootDir || cwd,
+    primaryDatasourceDirectory: primaryDatasourceDirectory(primaryDatasource) || schemaResult.schemaRootDir || cwd,
+    warnings: configFromPsl.warnings,
     loadedFromPathForLogMessages
   };
 }
@@ -15045,21 +15049,14 @@ async function getGenerators(options) {
     allowNoModels,
     typedSql
   } = options;
-  if (!schemaPath) {
-    throw new Error(`schemaPath for getGenerators got invalid value ${schemaPath}`);
+  const schemaContext = !options.schemaContext && schemaPath ? await loadSchemaContext({ schemaPathFromArg: schemaPath, ignoreEnvVarErrors: true }) : options.schemaContext;
+  if (!schemaContext) {
+    throw new Error(`no schema provided for getGenerators`);
   }
-  let schemaResult = null;
-  try {
-    schemaResult = await getSchemaWithPath(schemaPath);
-  } catch (_2) {
-    throw new Error(`${schemaPath} does not exist`);
-  }
-  const { schemas } = schemaResult;
   const binaryTarget = await (0, import_get_platform.getBinaryTargetForCurrentPlatform)();
   const queryEngineBinaryType = (0, import_engines.getCliQueryEngineBinaryType)();
   const queryEngineType = (0, import_chunk_RS2R7COT.binaryTypeToEngineType)(queryEngineBinaryType);
-  let prismaPath = binaryPathsOverride?.[queryEngineType];
-  if (version && !prismaPath) {
+  if (version && !binaryPathsOverride?.[queryEngineType]) {
     const potentialPath = eval(`require('path').join(__dirname, '..')`);
     if (!potentialPath.match(import_chunk_M3GBKLGE.vercelPkgPathRegex)) {
       const downloadParams = {
@@ -15071,35 +15068,25 @@ async function getGenerators(options) {
         version,
         skipDownload
       };
-      const binaryPathsWithEngineType = await (0, import_fetch_engine.download)(downloadParams);
-      prismaPath = binaryPathsWithEngineType[queryEngineBinaryType][binaryTarget];
+      await (0, import_fetch_engine.download)(downloadParams);
     }
   }
-  const config = await (0, import_chunk_Y5IIJ464.getConfig)({
-    datamodel: schemas,
-    datamodelPath: schemaPath,
-    prismaPath,
-    ignoreEnvVarErrors: true
-  });
-  if (config.datasources.length === 0) {
+  if (!schemaContext.primaryDatasource) {
     throw new Error(import_chunk_2ZPYYZJB.missingDatasource);
   }
-  (0, import_chunk_5FJ3MENK.printConfigWarnings)(config.warnings);
-  const previewFeatures = (0, import_chunk_TSJICM5S.extractPreviewFeatures)(config);
-  const dmmf = await (0, import_chunk_N4QYGJOZ.getDMMF)({
-    datamodel: schemas,
-    datamodelPath: schemaPath,
-    prismaPath,
+  (0, import_chunk_5FJ3MENK.printConfigWarnings)(schemaContext.warnings);
+  const previewFeatures = (0, import_chunk_CRVLHWC5.extractPreviewFeatures)(schemaContext.generators);
+  const dmmf = await (0, import_chunk_OKJT45NT.getDMMF)({
+    datamodel: schemaContext.schemaFiles,
     previewFeatures
   });
   if (dmmf.datamodel.models.length === 0 && !allowNoModels) {
-    if (config.datasources.some((d2) => d2.provider === "mongodb")) {
+    if (schemaContext.primaryDatasource.provider === "mongodb") {
       throw new Error(import_chunk_HL5VFJX4.missingModelMessageMongoDB);
     }
     throw new Error(import_chunk_HL5VFJX4.missingModelMessage);
   }
-  (0, import_chunk_IPKE37QC.checkFeatureFlags)(config, options);
-  const generatorConfigs = filterGenerators(overrideGenerators || config.generators, generatorNames);
+  const generatorConfigs = filterGenerators(overrideGenerators || schemaContext.generators, generatorNames);
   await validateGenerators(generatorConfigs);
   const runningGenerators = [];
   try {
@@ -15108,7 +15095,7 @@ async function getGenerators(options) {
       async (generator, index2) => {
         let generatorPath = (0, import_chunk_IOIAK7V7.parseEnvValue)(generator.provider);
         let paths2;
-        const baseDir = import_path4.default.dirname(generator.sourceFilePath ?? schemaPath);
+        const baseDir = import_path4.default.dirname(generator.sourceFilePath ?? schemaContext.schemaRootDir);
         const providerValue = (0, import_chunk_IOIAK7V7.parseEnvValue)(generator.provider);
         if (aliases && aliases[providerValue]) {
           generatorPath = aliases[providerValue].generatorPath;
@@ -15147,15 +15134,16 @@ The generator needs to either define the \`defaultOutput\` path in the manifest
             fromEnvVar: null
           };
         }
-        const datamodel = (0, import_chunk_P62PZLW4.mergeSchemas)({ schemas });
-        const envPaths2 = await getEnvPaths(schemaPath, { cwd: generator.output.value });
+        const datamodel = (0, import_chunk_GNK3AD6X.mergeSchemas)({ schemas: schemaContext.schemaFiles });
+        const envPaths2 = await getEnvPaths(schemaContext.schemaPath, { cwd: generator.output.value });
         const options2 = {
           datamodel,
-          datasources: config.datasources,
+          datasources: schemaContext.datasources,
           generator,
           dmmf,
           otherGenerators: skipIndex(generatorConfigs, index2),
-          schemaPath,
+          schemaPath: schemaContext.schemaPath,
+          // TODO:(schemaPath) can we get rid of schema path passing here?
           version: version || import_engines.enginesVersion,
           // this version makes no sense anymore and should be ignored
           postinstall,
@@ -15230,10 +15218,8 @@ generator gen {
         debug6({ generatorBinaryPaths });
         generator.setBinaryPaths(generatorBinaryPaths);
         if (engineVersion !== version && generator.options && generator.manifest.requiresEngines.includes(queryEngineType) && generatorBinaryPaths[queryEngineType] && generatorBinaryPaths[queryEngineType]?.[binaryTarget]) {
-          const customDmmf = await (0, import_chunk_N4QYGJOZ.getDMMF)({
-            datamodel: schemas,
-            datamodelPath: schemaPath,
-            prismaPath: generatorBinaryPaths[queryEngineType]?.[binaryTarget],
+          const customDmmf = await (0, import_chunk_OKJT45NT.getDMMF)({
+            datamodel: schemaContext.schemaFiles,
             previewFeatures
           });
           const options2 = { ...generator.options, dmmf: customDmmf };
@@ -15524,13 +15510,13 @@ ${(0, import_chunk_PG5FDKSF.bold)("Thanks a lot for your help! \u{1F64F}")}`);
   process.exit(1);
 }
 var debug7 = (0, import_debug.default)("prisma:format");
-async function formatSchema({ schemas: schemas2 }, inputFormattingOptions) {
+async function formatSchema({ schemas }, inputFormattingOptions) {
   if (process.env.FORCE_PANIC_PRISMA_SCHEMA) {
     handleFormatPanic(
       () => {
-        import_chunk_LN2AVE5M.prismaSchemaWasm.debug_panic();
+        import_chunk_LR3WWKZI.prismaSchemaWasm.debug_panic();
       },
-      { schemas: schemas2 }
+      { schemas }
     );
   }
   const defaultFormattingOptions = {
@@ -15546,20 +15532,20 @@ async function formatSchema({ schemas: schemas2 }, inputFormattingOptions) {
   };
   const { formattedMultipleSchemas, lintDiagnostics } = handleFormatPanic(
     () => {
-      const formattedMultipleSchemasRaw = formatWasm(JSON.stringify(schemas2), documentFormattingParams);
+      const formattedMultipleSchemasRaw = formatWasm(JSON.stringify(schemas), documentFormattingParams);
       const formattedMultipleSchemas2 = JSON.parse(formattedMultipleSchemasRaw);
-      const lintDiagnostics2 = (0, import_chunk_25XBBR4V.lintSchema)({ schemas: formattedMultipleSchemas2 });
+      const lintDiagnostics2 = (0, import_chunk_NZDLSDLM.lintSchema)({ schemas: formattedMultipleSchemas2 });
       return { formattedMultipleSchemas: formattedMultipleSchemas2, lintDiagnostics: lintDiagnostics2 };
     },
-    { schemas: schemas2 }
+    { schemas }
   );
-  const lintWarnings = (0, import_chunk_25XBBR4V.getLintWarningsAsText)(lintDiagnostics);
+  const lintWarnings = (0, import_chunk_NZDLSDLM.getLintWarningsAsText)(lintDiagnostics);
   if (lintWarnings && import_chunk_MBB2KJWX.logger_exports.should.warn()) {
     console.warn(lintWarnings);
   }
   return Promise.resolve(formattedMultipleSchemas);
 }
-function handleFormatPanic(tryCb, { schemas: schemas2 }) {
+function handleFormatPanic(tryCb, { schemas }) {
   try {
     return tryCb();
   } catch (e) {
@@ -15575,15 +15561,15 @@ function handleFormatPanic(tryCb, { schemas: schemas2 }) {
       "@prisma/prisma-schema-wasm format",
       "FMT_CLI",
       /* schemaPath */
-      (0, import_chunk_YRBRUREX.debugMultipleSchemaPaths)(schemas2),
+      (0, import_chunk_YRBRUREX.debugMultipleSchemaPaths)(schemas),
       /* schema */
-      schemas2
+      schemas
     );
     throw panic;
   }
 }
 function formatWasm(schema, documentFormattingParams) {
-  const formattedSchema = import_chunk_LN2AVE5M.prismaSchemaWasm.format(schema, JSON.stringify(documentFormattingParams));
+  const formattedSchema = import_chunk_LR3WWKZI.prismaSchemaWasm.format(schema, JSON.stringify(documentFormattingParams));
   return formattedSchema;
 }
 /*! Bundled license information:

package/dist/{chunk-N4QYGJOZ.js → chunk-OKJT45NT.js}

@@ -26,24 +26,23 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_N4QYGJOZ_exports = {};
-__export(chunk_N4QYGJOZ_exports, {
+var chunk_OKJT45NT_exports = {};
+__export(chunk_OKJT45NT_exports, {
   GetDmmfError: () => GetDmmfError,
   getDMMF: () => getDMMF
 });
-module.exports = __toCommonJS(chunk_N4QYGJOZ_exports);
+module.exports = __toCommonJS(chunk_OKJT45NT_exports);
 var import_chunk_YRBRUREX = require("./chunk-YRBRUREX.js");
-var import_chunk_PSYMCJ4B = require("./chunk-PSYMCJ4B.js");
+var import_chunk_CMIKSBKL = require("./chunk-CMIKSBKL.js");
 var import_chunk_ZGAIRZ32 = require("./chunk-ZGAIRZ32.js");
-var import_chunk_SXCF4HKZ = require("./chunk-SXCF4HKZ.js");
+var import_chunk_OQZDUJAJ = require("./chunk-OQZDUJAJ.js");
 var import_chunk_XKZ6CBLA = require("./chunk-XKZ6CBLA.js");
-var import_chunk_LN2AVE5M = require("./chunk-LN2AVE5M.js");
+var import_chunk_LR3WWKZI = require("./chunk-LR3WWKZI.js");
 var import_chunk_CCQRDM7X = require("./chunk-CCQRDM7X.js");
-var import_chunk_7MD6344A = require("./chunk-7MD6344A.js");
+var import_chunk_5DBOS77Y = require("./chunk-5DBOS77Y.js");
 var import_chunk_PG5FDKSF = require("./chunk-PG5FDKSF.js");
 var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
 var import_debug = __toESM(require("@prisma/debug"));
-var import_fs = __toESM(require("fs"));
 var import_function = (0, import_chunk_2ESYSVXG.__toESM)((0, import_chunk_ZGAIRZ32.require_function)());
 var debug = (0, import_debug.default)("prisma:getDMMF");
 var GetDmmfError = class extends Error {
@@ -60,84 +59,56 @@ ${detailsHeader} ${message}`;
     }).exhaustive();
     const errorMessageWithContext = `${constructedErrorMessage}
 [Context: getDmmf]`;
-    super((0, import_chunk_SXCF4HKZ.addVersionDetailsToErrorMessage)(errorMessageWithContext));
+    super((0, import_chunk_OQZDUJAJ.addVersionDetailsToErrorMessage)(errorMessageWithContext));
     this.name = "GetDmmfError";
   }
 };
 async function getDMMF(options) {
-  const debugErrorType = (0, import_chunk_PSYMCJ4B.createDebugErrorType)(debug, "getDmmfWasm");
+  const debugErrorType = (0, import_chunk_CMIKSBKL.createDebugErrorType)(debug, "getDmmfWasm");
   debug(`Using getDmmf Wasm`);
   const dmmfPipeline = (0, import_function.pipe)(
-    (0, import_chunk_7MD6344A.tryCatch2)(
+    (0, import_chunk_5DBOS77Y.tryCatch)(
       () => {
-        if (options.datamodel) {
-          debug("Using given datamodel");
-          return Promise.resolve(options.datamodel);
+        if (process.env.FORCE_PANIC_QUERY_ENGINE_GET_DMMF) {
+          debug("Triggering a Rust panic...");
+          import_chunk_LR3WWKZI.prismaSchemaWasm.debug_panic();
         }
-        debug(`Reading datamodel from the given datamodel path ${options.datamodelPath}`);
-        return import_fs.default.promises.readFile(options.datamodelPath, { encoding: "utf-8" });
+        const params = JSON.stringify({
+          prismaSchema: options.datamodel,
+          noColor: Boolean(process.env.NO_COLOR)
+        });
+        const data = import_chunk_LR3WWKZI.prismaSchemaWasm.get_dmmf(params);
+        return data;
       },
       (e) => ({
-        type: "read-datamodel-path",
-        reason: "Error while trying to read the datamodel path",
-        error: e,
-        datamodelPath: options.datamodelPath
+        type: "wasm-error",
+        reason: "(get-dmmf wasm)",
+        error: e
       })
     ),
-    (0, import_chunk_7MD6344A.chainW2)((datamodel) => {
-      return (0, import_function.pipe)(
-        (0, import_chunk_7MD6344A.tryCatch)(
-          () => {
-            if (process.env.FORCE_PANIC_QUERY_ENGINE_GET_DMMF) {
-              debug("Triggering a Rust panic...");
-              import_chunk_LN2AVE5M.prismaSchemaWasm.debug_panic();
-            }
-            const params = JSON.stringify({
-              prismaSchema: datamodel,
-              noColor: Boolean(process.env.NO_COLOR)
-            });
-            const data = import_chunk_LN2AVE5M.prismaSchemaWasm.get_dmmf(params);
-            return data;
-          },
+    (0, import_chunk_5DBOS77Y.map)((result) => ({ result })),
+    (0, import_chunk_5DBOS77Y.chainW)(
+      ({ result }) => (
+        // NOTE: this should never fail, as we expect returned values to be valid JSON-serializable strings
+        (0, import_chunk_5DBOS77Y.tryCatch)(
+          () => JSON.parse(result),
           (e) => ({
-            type: "wasm-error",
-            reason: "(get-dmmf wasm)",
+            type: "parse-json",
+            reason: "Unable to parse JSON",
             error: e
           })
-        ),
-        (0, import_chunk_7MD6344A.map)((result) => ({ result })),
-        (0, import_chunk_7MD6344A.chainW)(
-          ({ result }) => (
-            // NOTE: this should never fail, as we expect returned values to be valid JSON-serializable strings
-            (0, import_chunk_7MD6344A.tryCatch)(
-              () => JSON.parse(result),
-              (e) => ({
-                type: "parse-json",
-                reason: "Unable to parse JSON",
-                error: e
-              })
-            )
-          )
-        ),
-        import_chunk_7MD6344A.fromEither
-      );
-    })
+        )
+      )
+    ),
+    import_chunk_5DBOS77Y.fromEither
   );
   const dmmfEither = await dmmfPipeline();
-  if ((0, import_chunk_7MD6344A.isRight)(dmmfEither)) {
+  if ((0, import_chunk_5DBOS77Y.isRight)(dmmfEither)) {
     debug("dmmf data retrieved without errors in getDmmf Wasm");
     const { right: data } = dmmfEither;
     return Promise.resolve(data);
   }
-  const error = (0, import_chunk_XKZ6CBLA.z)(dmmfEither.left).with({ type: "read-datamodel-path" }, (e) => {
-    debugErrorType(e);
-    return new GetDmmfError({
-      _tag: "unparsed",
-      message: `${e.error.message}
-Datamodel path: "${e.datamodelPath}"`,
-      reason: e.reason
-    });
-  }).with({ type: "wasm-error" }, (e) => {
+  const error = (0, import_chunk_XKZ6CBLA.z)(dmmfEither.left).with({ type: "wasm-error" }, (e) => {
     debugErrorType(e);
     if ((0, import_chunk_CCQRDM7X.isWasmPanic)(e.error)) {
       const { message, stack } = (0, import_chunk_CCQRDM7X.getWasmError)(e.error);
@@ -150,14 +121,14 @@ Datamodel path: "${e.datamodelPath}"`,
         "@prisma/prisma-schema-wasm get_dmmf",
         "FMT_CLI",
         /* schemaPath */
-        options.prismaPath,
+        void 0,
         /* schema */
         (0, import_chunk_YRBRUREX.toMultipleSchemas)(options.datamodel)
       );
       return panic;
     }
     const errorOutput = e.error.message;
-    return new GetDmmfError((0, import_chunk_PSYMCJ4B.parseQueryEngineError)({ errorOutput, reason: e.reason }));
+    return new GetDmmfError((0, import_chunk_CMIKSBKL.parseQueryEngineError)({ errorOutput, reason: e.reason }));
   }).with({ type: "parse-json" }, (e) => {
     debugErrorType(e);
     return new GetDmmfError({ _tag: "unparsed", message: e.error.message, reason: e.reason });

package/dist/{chunk-SXCF4HKZ.js → chunk-OQZDUJAJ.js}

@@ -16,15 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_SXCF4HKZ_exports = {};
-__export(chunk_SXCF4HKZ_exports, {
+var chunk_OQZDUJAJ_exports = {};
+__export(chunk_OQZDUJAJ_exports, {
   addVersionDetailsToErrorMessage: () => addVersionDetailsToErrorMessage
 });
-module.exports = __toCommonJS(chunk_SXCF4HKZ_exports);
-var import_chunk_US3GVDJU = require("./chunk-US3GVDJU.js");
+module.exports = __toCommonJS(chunk_OQZDUJAJ_exports);
+var import_chunk_2WQVHYBS = require("./chunk-2WQVHYBS.js");
 var import_chunk_QN6PSQY7 = require("./chunk-QN6PSQY7.js");
 function addVersionDetailsToErrorMessage(message) {
-  const rows = [["Prisma CLI Version", import_chunk_US3GVDJU.version]];
+  const rows = [["Prisma CLI Version", import_chunk_2WQVHYBS.version]];
   return `${message}
 
 ${(0, import_chunk_QN6PSQY7.formatTable)(rows)}`;