@prisma/config 6.13.0-dev.10 → 6.13.0-dev.12

package/dist/index.d.ts

@@ -221,12 +221,15 @@ declare type IsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABL
 export declare function loadConfigFromFile({ configFile, configRoot, }: LoadConfigFromFileInput): Promise<ConfigFromFile>;
 
 export declare type LoadConfigFromFileError = {
+    /**
+     * The config file was not found at the specified path.
+     */
     _tag: 'ConfigFileNotFound';
 } | {
-    _tag: 'TypeScriptImportFailed';
+    _tag: 'ConfigLoadError';
     error: Error;
 } | {
-    _tag: 'ConfigFileParseError';
+    _tag: 'ConfigFileSyntaxError';
     error: Error;
 } | {
     _tag: 'UnknownError';

package/dist/index.js

@@ -22991,33 +22991,18 @@ function defaultTestConfig() {
 }
 
 // src/loadConfigFromFile.ts
-var import_node_fs = __toESM(require("node:fs"));
 var import_node_path = __toESM(require("node:path"));
 var import_node_process = __toESM(require("node:process"));
-var import_jiti = require("jiti");
 var debug4 = Debug("prisma:config:loadConfigFromFile");
+var SUPPORTED_EXTENSIONS = [".js", ".ts", ".mjs", ".cjs", ".mts", ".cts"];
 async function loadConfigFromFile({
   configFile,
   configRoot = import_node_process.default.cwd()
 }) {
   const start = performance.now();
   const getTime = () => `${(performance.now() - start).toFixed(2)}ms`;
-  let resolvedPath;
-  if (configFile) {
-    resolvedPath = import_node_path.default.resolve(configRoot, configFile);
-    if (!import_node_fs.default.existsSync(resolvedPath)) {
-      debug4(`The given config file was not found at %s`, resolvedPath);
-      return { resolvedPath, error: { _tag: "ConfigFileNotFound" } };
-    }
-  } else {
-    resolvedPath = ["prisma.config.ts"].map((file) => import_node_path.default.resolve(configRoot, file)).find((file) => import_node_fs.default.existsSync(file)) ?? null;
-    if (resolvedPath === null) {
-      debug4(`No config file found in the current working directory %s`, configRoot);
-      return { resolvedPath, config: defaultConfig() };
-    }
-  }
   try {
-    const { required: required3, error } = await requireTypeScriptFile(resolvedPath);
+    const { configModule, resolvedPath, error } = await loadConfigTsOrJs(configRoot, configFile);
     if (error) {
       return {
         resolvedPath,
@@ -23025,22 +23010,26 @@ async function loadConfigFromFile({
       };
     }
     debug4(`Config file loaded in %s`, getTime());
-    let defaultExport;
+    if (resolvedPath === null) {
+      debug4(`No config file found in the current working directory %s`, configRoot);
+      return { resolvedPath: null, config: defaultConfig() };
+    }
+    let parsedConfig;
     try {
-      defaultExport = parseDefaultExport(required3["default"]);
+      parsedConfig = parseDefaultExport(configModule);
     } catch (e) {
       const error2 = e;
       return {
         resolvedPath,
         error: {
-          _tag: "ConfigFileParseError",
+          _tag: "ConfigFileSyntaxError",
           error: error2
         }
       };
     }
     import_node_process.default.stdout.write(`Loaded Prisma config from "${resolvedPath}".
 `);
-    const prismaConfig = transformPathsInConfigToAbsolute(defaultExport, resolvedPath);
+    const prismaConfig = transformPathsInConfigToAbsolute(parsedConfig, resolvedPath);
     return {
       config: {
         ...prismaConfig,
@@ -23051,7 +23040,7 @@ async function loadConfigFromFile({
   } catch (e) {
     const error = e;
     return {
-      resolvedPath,
+      resolvedPath: configRoot,
       error: {
         _tag: "UnknownError",
         error
@@ -23059,25 +23048,79 @@ async function loadConfigFromFile({
     };
   }
 }
-async function requireTypeScriptFile(resolvedPath) {
+async function loadConfigTsOrJs(configRoot, configFile) {
+  const { loadConfig: loadConfigWithC12 } = await import("c12");
+  const { deepmerge } = await import("deepmerge-ts");
   try {
-    const jiti = (0, import_jiti.createJiti)(__filename, {
-      interopDefault: true,
-      moduleCache: false
+    const {
+      config: config2,
+      configFile: _resolvedPath,
+      meta
+    } = await loadConfigWithC12({
+      cwd: configRoot,
+      // configuration base name
+      name: "prisma",
+      // the config file to load (without file extensions), defaulting to `${cwd}.${name}`
+      configFile,
+      // do not load .env files
+      dotenv: false,
+      // do not load RC config
+      rcFile: false,
+      // do not extend remote config files
+      giget: false,
+      // do not extend the default config
+      extend: false,
+      // do not load from nearest package.json
+      packageJson: false,
+      // @ts-expect-error: this is a type-error in `c12` itself
+      merger: deepmerge,
+      jitiOptions: {
+        interopDefault: true,
+        moduleCache: false,
+        extensions: SUPPORTED_EXTENSIONS
+      }
     });
-    const configExport = await jiti.import(resolvedPath);
+    const resolvedPath = _resolvedPath ? import_node_path.default.normalize(_resolvedPath) : void 0;
+    const doesConfigFileExist = resolvedPath !== void 0 && meta !== void 0;
+    if (configFile && !doesConfigFileExist) {
+      debug4(`The given config file was not found at %s`, resolvedPath);
+      return {
+        require: null,
+        resolvedPath: import_node_path.default.join(configRoot, configFile),
+        error: { _tag: "ConfigFileNotFound" }
+      };
+    }
+    if (doesConfigFileExist) {
+      const extension = import_node_path.default.extname(import_node_path.default.basename(resolvedPath));
+      if (!SUPPORTED_EXTENSIONS.includes(extension)) {
+        return {
+          configModule: config2,
+          resolvedPath,
+          error: {
+            _tag: "ConfigLoadError",
+            error: new Error(`Unsupported Prisma config file extension: ${extension}`)
+          }
+        };
+      }
+    }
     return {
-      required: configExport,
+      configModule: config2,
+      resolvedPath: doesConfigFileExist ? resolvedPath : null,
       error: null
     };
   } catch (e) {
     const error = e;
     debug4("jiti import failed: %s", error.message);
+    const configFileMatch = error.message.match(/prisma\.config\.(\w+)/);
+    const extension = configFileMatch?.[1];
+    const filenameWithExtension = import_node_path.default.join(configRoot, extension ? `prisma.config.${extension}` : "");
+    debug4("faulty config file: %s", filenameWithExtension);
     return {
       error: {
-        _tag: "TypeScriptImportFailed",
+        _tag: "ConfigLoadError",
         error
-      }
+      },
+      resolvedPath: filenameWithExtension
     };
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/config",
-  "version": "6.13.0-dev.10",
+  "version": "6.13.0-dev.12",
   "description": "Internal package used to define and read Prisma configuration files",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,13 +12,14 @@
   "license": "Apache-2.0",
   "author": "Alberto Schiabel <schiabel@prisma.io>",
   "dependencies": {
-    "jiti": "2.4.2"
+    "c12": "3.1.0",
+    "deepmerge-ts": "7.1.5"
   },
   "devDependencies": {
     "effect": "3.16.12",
     "vitest": "3.2.4",
-    "@prisma/get-platform": "6.13.0-dev.10",
-    "@prisma/driver-adapter-utils": "6.13.0-dev.10"
+    "@prisma/driver-adapter-utils": "6.13.0-dev.12",
+    "@prisma/get-platform": "6.13.0-dev.12"
   },
   "files": [
     "dist"