@prisma/config 6.13.0-dev.1 → 6.13.0-dev.11

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';
@@ -280,6 +283,10 @@ export declare type PrismaConfig = {
      * Configuration for Prisma migrations.
      */
     migrations?: Simplify<MigrationsConfigShape>;
+    /**
+     * Configuration for the database table entities.
+     */
+    tables?: Simplify<TablesConfigShape>;
     /**
      * Configuration for the database view entities.
      */
@@ -414,6 +421,15 @@ declare interface SqlResultSet {
     lastInsertId?: string;
 }
 
+declare type TablesConfigShape = {
+    /**
+     * List of tables that are externally managed.
+     * Prisma will not modify the structure of these tables and not generate migrations for those tables.
+     * These tables will still be represented in schema.prisma file and be available in the client API.
+     */
+    external?: string[];
+};
+
 declare interface Transaction extends AdapterInfo, SqlQueryable {
     /**
      * Transaction options.

package/dist/index.js

@@ -22774,6 +22774,7 @@ function defineConfig(configInput) {
   defineAdapterConfig(config2, configInput);
   defineStudioConfig(config2, configInput);
   defineMigrationsConfig(config2, configInput);
+  defineTablesConfig(config2, configInput);
   defineTypedSqlConfig(config2, configInput);
   defineViewsConfig(config2, configInput);
   return config2;
@@ -22806,6 +22807,13 @@ function defineViewsConfig(config2, configInput) {
   config2.views = configInput.views;
   debug2("[config.views]: %o", config2.views);
 }
+function defineTablesConfig(config2, configInput) {
+  if (!configInput.tables) {
+    return;
+  }
+  config2.tables = configInput.tables;
+  debug2("[config.tables]: %o", config2.tables);
+}
 function defineStudioConfig(config2, configInput) {
   if (!configInput.studio?.adapter) {
     return;
@@ -22862,6 +22870,13 @@ if (false) {
   __testMigrationsConfigShapeValueA;
   __testMigrationsConfigShapeValueB;
 }
+var TablesConfigShape = Schema_exports.Struct({
+  external: Schema_exports.optional(Schema_exports.mutable(Schema_exports.Array(Schema_exports.String)))
+});
+if (false) {
+  __testTablesConfigShapeValueA;
+  __testTablesConfigShapeValueB;
+}
 var ViewsConfigShape = Schema_exports.Struct({
   path: Schema_exports.optional(Schema_exports.String)
 });
@@ -22896,6 +22911,7 @@ var PrismaConfigShape = Schema_exports.Struct({
   studio: Schema_exports.optional(PrismaStudioConfigShape),
   adapter: Schema_exports.optional(SqlMigrationAwareDriverAdapterFactoryShape),
   migrations: Schema_exports.optional(MigrationsConfigShape),
+  tables: Schema_exports.optional(TablesConfigShape),
   views: Schema_exports.optional(ViewsConfigShape),
   typedSql: Schema_exports.optional(TypedSqlConfigShape)
 });
@@ -22975,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,
@@ -23009,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,
@@ -23035,7 +23040,7 @@ async function loadConfigFromFile({
   } catch (e) {
     const error = e;
     return {
-      resolvedPath,
+      resolvedPath: configRoot,
       error: {
         _tag: "UnknownError",
         error
@@ -23043,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.1",
+  "version": "6.13.0-dev.11",
   "description": "Internal package used to define and read Prisma configuration files",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,17 +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": {
-    "@swc/core": "1.11.5",
-    "@swc/jest": "0.2.37",
-    "cross-env": "7.0.3",
     "effect": "3.16.12",
-    "jest": "29.7.0",
-    "jest-junit": "16.0.0",
-    "@prisma/get-platform": "6.13.0-dev.1",
-    "@prisma/driver-adapter-utils": "6.13.0-dev.1"
+    "vitest": "3.2.4",
+    "@prisma/driver-adapter-utils": "6.13.0-dev.11",
+    "@prisma/get-platform": "6.13.0-dev.11"
   },
   "files": [
     "dist"
@@ -31,6 +28,6 @@
   "scripts": {
     "dev": "DEV=true tsx helpers/build.ts",
     "build": "tsx helpers/build.ts",
-    "test": "cross-env NODE_OPTIONS='--experimental-vm-modules' jest"
+    "test": "vitest run"
   }
 }