@prisma/config 6.20.0-integration-next.3 → 6.20.0-integration-merge-release-workflows.2

package/dist/index.d.ts

@@ -204,6 +204,20 @@ declare type LoadConfigFromFileInput = {
     configRoot?: string;
 };
 
+/**
+ * User's Prisma configuration should live in `prisma.config.ts` instead of `package.json#prisma`.
+ * See: https://pris.ly/prisma-config.
+ *
+ * This function returns `null` if no `package.json` is found, or if the `prisma` property is not defined therein.
+ *
+ * TODO: remove in Prisma 7.
+ * @deprecated
+ */
+export declare function loadConfigFromPackageJson(cwd?: string): Promise<{
+    config: PrismaConfigPackageJson;
+    loadedFromFile: string;
+} | null>;
+
 declare type MappedError = {
     kind: 'GenericJs';
     id: number;
@@ -355,6 +369,25 @@ export declare type PrismaConfigInternal = _PrismaConfigInternal & {
 
 declare type _PrismaConfigInternal = Omit<PrismaConfig, 'engine' | 'datasource' | 'adapter'> & {
     loadedFromFile: string | null;
+    /**
+     * The deprecated Prisma configuration from `package.json#prisma`.
+     * This is set to `null` if no `package.json#prisma` config was found.
+     * The configuration read from the Prisma config file (e.g., `prisma.config.ts`) takes precedence over
+     * this `package.json#prisma` config.
+     * @deprecated
+     */
+    deprecatedPackageJson: {
+        /**
+         * The Prisma configuration from `package.json#prisma`.
+         * @deprecated
+         */
+        config: PrismaConfigPackageJson;
+        /**
+         * The path from where the `package.json` config was loaded.
+         * @deprecated
+         */
+        loadedFromFile: string;
+    } | null;
 } & ({
     engine: 'classic';
     datasource: {
@@ -368,6 +401,20 @@ declare type _PrismaConfigInternal = Omit<PrismaConfig, 'engine' | 'datasource'
     engine?: never;
 });
 
+/**
+ * Example:
+ * ```json
+ * {
+ *   "schema": "./prisma/schema.prisma",
+ *   "seed": "tsx ./prisma/seed.ts"
+ * }
+ * ```
+ */
+declare type PrismaConfigPackageJson = {
+    schema?: string;
+    seed?: string;
+};
+
 declare type PrismaConfigUnconditional = {
     /**
      * Experimental feature gates. Each experimental feature must be explicitly enabled.

package/dist/index.js

@@ -34,7 +34,8 @@ __export(index_exports, {
   defaultTestConfig: () => defaultTestConfig,
   defineConfig: () => defineConfig,
   env: () => env,
-  loadConfigFromFile: () => loadConfigFromFile
+  loadConfigFromFile: () => loadConfigFromFile,
+  loadConfigFromPackageJson: () => loadConfigFromPackageJson
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -357,7 +358,7 @@ var mockAdapterErrors = {
 };
 
 // src/PrismaConfig.ts
-var import_effect2 = require("effect");
+var import_effect3 = require("effect");
 var import_Function = require("effect/Function");
 
 // src/defineConfig.ts
@@ -366,7 +367,8 @@ var import_effect = require("effect");
 // src/defaultConfig.ts
 function defaultConfig() {
   return makePrismaConfigInternal({
-    loadedFromFile: null
+    loadedFromFile: null,
+    deprecatedPackageJson: null
   });
 }
 
@@ -511,105 +513,133 @@ function defineExtensionsConfig(config, configInput) {
   debug2("[config.extensions]: %o", config["extensions"]);
 }
 
+// src/loadConfigFromPackageJson.ts
+var import_promises = require("node:fs/promises");
+var import_node_process = __toESM(require("node:process"));
+var import_effect2 = require("effect");
+var import_package = require("empathic/package");
+var PrismaConfigPackageJsonShape = import_effect2.Schema.Struct({
+  schema: import_effect2.Schema.optional(import_effect2.Schema.String),
+  seed: import_effect2.Schema.optional(import_effect2.Schema.NonEmptyString)
+});
+async function loadConfigFromPackageJson(cwd = import_node_process.default.cwd()) {
+  const pkgPath = (0, import_package.up)({ cwd });
+  if (pkgPath === void 0) {
+    return null;
+  }
+  const pkgJson = await (0, import_promises.readFile)(pkgPath, { encoding: "utf-8" }).then((p) => JSON.parse(p));
+  const deprecatedConfig = pkgJson["prisma"];
+  if (deprecatedConfig === void 0) {
+    return null;
+  }
+  if (Object.keys(deprecatedConfig).length === 1 && deprecatedConfig["prismaCommit"] !== void 0) {
+    return null;
+  }
+  return {
+    config: deprecatedConfig,
+    loadedFromFile: pkgPath
+  };
+}
+
 // src/PrismaConfig.ts
 var debug3 = Debug("prisma:config:PrismaConfig");
-var SqlMigrationAwareDriverAdapterFactoryShape = import_effect2.Schema.declare(
+var SqlMigrationAwareDriverAdapterFactoryShape = import_effect3.Schema.declare(
   (input) => {
     return typeof input === "function";
   },
   {
     identifier: "SqlMigrationAwareDriverAdapterFactory",
-    encode: import_effect2.identity,
-    decode: import_effect2.identity
+    encode: import_effect3.identity,
+    decode: import_effect3.identity
   }
 );
-var ErrorCapturingSqlMigrationAwareDriverAdapterFactoryShape = import_effect2.Schema.declare(
+var ErrorCapturingSqlMigrationAwareDriverAdapterFactoryShape = import_effect3.Schema.declare(
   (input) => {
     return typeof input === "function";
   },
   {
     identifier: "ErrorCapturingSqlMigrationAwareDriverAdapterFactory",
-    encode: import_effect2.identity,
-    decode: import_effect2.identity
+    encode: import_effect3.identity,
+    decode: import_effect3.identity
   }
 );
-var SchemaEngineConfigClassicShape = import_effect2.Schema.Struct({
-  engine: import_effect2.Schema.Literal("classic"),
-  datasource: import_effect2.Schema.Struct({
-    url: import_effect2.Schema.String,
-    directUrl: import_effect2.Schema.optional(import_effect2.Schema.String),
-    shadowDatabaseUrl: import_effect2.Schema.optional(import_effect2.Schema.String)
+var SchemaEngineConfigClassicShape = import_effect3.Schema.Struct({
+  engine: import_effect3.Schema.Literal("classic"),
+  datasource: import_effect3.Schema.Struct({
+    url: import_effect3.Schema.String,
+    directUrl: import_effect3.Schema.optional(import_effect3.Schema.String),
+    shadowDatabaseUrl: import_effect3.Schema.optional(import_effect3.Schema.String)
   })
 });
-var SchemaEngineConfigJsShape = import_effect2.Schema.Struct({
-  engine: import_effect2.Schema.Literal("js"),
+var SchemaEngineConfigJsShape = import_effect3.Schema.Struct({
+  engine: import_effect3.Schema.Literal("js"),
   adapter: SqlMigrationAwareDriverAdapterFactoryShape
 });
-var SchemaEngineConfigAbsentShape = import_effect2.Schema.Struct({
-  engine: import_effect2.Schema.optional(import_effect2.Schema.Never)
+var SchemaEngineConfigAbsentShape = import_effect3.Schema.Struct({
+  engine: import_effect3.Schema.optional(import_effect3.Schema.Never)
 });
-var SchemaEngineConfigShape = import_effect2.Schema.Union(
+var SchemaEngineConfigShape = import_effect3.Schema.Union(
   SchemaEngineConfigClassicShape,
   SchemaEngineConfigJsShape,
   SchemaEngineConfigAbsentShape
 );
-var SchemaEngineConfigJsInternal = import_effect2.Schema.Struct({
-  engine: import_effect2.Schema.Literal("js"),
+var SchemaEngineConfigJsInternal = import_effect3.Schema.Struct({
+  engine: import_effect3.Schema.Literal("js"),
   adapter: ErrorCapturingSqlMigrationAwareDriverAdapterFactoryShape
 });
-var SchemaEngineConfigInternal = import_effect2.Schema.Union(
+var SchemaEngineConfigInternal = import_effect3.Schema.Union(
   SchemaEngineConfigClassicShape,
   SchemaEngineConfigJsInternal,
   SchemaEngineConfigAbsentShape
 );
-var ExperimentalConfigShape = import_effect2.Schema.Struct({
-  adapter: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
-  studio: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
-  externalTables: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
-  extensions: import_effect2.Schema.optional(import_effect2.Schema.Boolean)
+var ExperimentalConfigShape = import_effect3.Schema.Struct({
+  adapter: import_effect3.Schema.optional(import_effect3.Schema.Boolean),
+  studio: import_effect3.Schema.optional(import_effect3.Schema.Boolean),
+  externalTables: import_effect3.Schema.optional(import_effect3.Schema.Boolean),
+  extensions: import_effect3.Schema.optional(import_effect3.Schema.Boolean)
 });
 if (false) {
   __testExperimentalConfigShapeValueA;
   __testExperimentalConfigShapeValueB;
 }
-var MigrationsConfigShape = import_effect2.Schema.Struct({
-  path: import_effect2.Schema.optional(import_effect2.Schema.String),
-  initShadowDb: import_effect2.Schema.optional(import_effect2.Schema.String),
-  seed: import_effect2.Schema.optional(import_effect2.Schema.NonEmptyString)
+var MigrationsConfigShape = import_effect3.Schema.Struct({
+  path: import_effect3.Schema.optional(import_effect3.Schema.String),
+  initShadowDb: import_effect3.Schema.optional(import_effect3.Schema.String),
+  seed: import_effect3.Schema.optional(import_effect3.Schema.NonEmptyString)
 });
 if (false) {
   __testMigrationsConfigShapeValueA;
   __testMigrationsConfigShapeValueB;
 }
-var TablesConfigShape = import_effect2.Schema.Struct({
-  external: import_effect2.Schema.optional(import_effect2.Schema.mutable(import_effect2.Schema.Array(import_effect2.Schema.String)))
+var TablesConfigShape = import_effect3.Schema.Struct({
+  external: import_effect3.Schema.optional(import_effect3.Schema.mutable(import_effect3.Schema.Array(import_effect3.Schema.String)))
 });
 if (false) {
   __testTablesConfigShapeValueA;
   __testTablesConfigShapeValueB;
 }
-var EnumsConfigShape = import_effect2.Schema.Struct({
-  external: import_effect2.Schema.optional(import_effect2.Schema.mutable(import_effect2.Schema.Array(import_effect2.Schema.String)))
+var EnumsConfigShape = import_effect3.Schema.Struct({
+  external: import_effect3.Schema.optional(import_effect3.Schema.mutable(import_effect3.Schema.Array(import_effect3.Schema.String)))
 });
 if (false) {
   __testEnumsConfigShapeValueA;
   __testEnumsConfigShapeValueB;
 }
-var ViewsConfigShape = import_effect2.Schema.Struct({
-  path: import_effect2.Schema.optional(import_effect2.Schema.String)
+var ViewsConfigShape = import_effect3.Schema.Struct({
+  path: import_effect3.Schema.optional(import_effect3.Schema.String)
 });
 if (false) {
   __testViewsConfigShapeValueA;
   __testViewsConfigShapeValueB;
 }
-var TypedSqlConfigShape = import_effect2.Schema.Struct({
-  path: import_effect2.Schema.optional(import_effect2.Schema.String)
+var TypedSqlConfigShape = import_effect3.Schema.Struct({
+  path: import_effect3.Schema.optional(import_effect3.Schema.String)
 });
 if (false) {
   __testTypedSqlConfigShapeValueA;
   __testTypedSqlConfigShapeValueB;
 }
-var PrismaStudioConfigShape = import_effect2.Schema.Struct({
+var PrismaStudioConfigShape = import_effect3.Schema.Struct({
   /**
    * Instantiates the Prisma driver adapter to use for Prisma Studio.
    */
@@ -623,18 +653,18 @@ if (false) {
   __testPrismaConfig;
   __testPrismaConfigInternal;
 }
-var PrismaConfigUnconditionalShape = import_effect2.Schema.Struct({
-  experimental: import_effect2.Schema.optional(ExperimentalConfigShape),
-  schema: import_effect2.Schema.optional(import_effect2.Schema.String),
-  studio: import_effect2.Schema.optional(PrismaStudioConfigShape),
-  migrations: import_effect2.Schema.optional(MigrationsConfigShape),
-  tables: import_effect2.Schema.optional(TablesConfigShape),
-  enums: import_effect2.Schema.optional(EnumsConfigShape),
-  views: import_effect2.Schema.optional(ViewsConfigShape),
-  typedSql: import_effect2.Schema.optional(TypedSqlConfigShape),
-  extensions: import_effect2.Schema.optional(import_effect2.Schema.Any)
+var PrismaConfigUnconditionalShape = import_effect3.Schema.Struct({
+  experimental: import_effect3.Schema.optional(ExperimentalConfigShape),
+  schema: import_effect3.Schema.optional(import_effect3.Schema.String),
+  studio: import_effect3.Schema.optional(PrismaStudioConfigShape),
+  migrations: import_effect3.Schema.optional(MigrationsConfigShape),
+  tables: import_effect3.Schema.optional(TablesConfigShape),
+  enums: import_effect3.Schema.optional(EnumsConfigShape),
+  views: import_effect3.Schema.optional(ViewsConfigShape),
+  typedSql: import_effect3.Schema.optional(TypedSqlConfigShape),
+  extensions: import_effect3.Schema.optional(import_effect3.Schema.Any)
 });
-var PrismaConfigShape = import_effect2.Schema.extend(SchemaEngineConfigShape, PrismaConfigUnconditionalShape);
+var PrismaConfigShape = import_effect3.Schema.extend(SchemaEngineConfigShape, PrismaConfigUnconditionalShape);
 if (false) {
   __testPrismaConfigValueA;
   __testPrismaConfigValueB;
@@ -642,52 +672,58 @@ if (false) {
 function validateExperimentalFeatures2(config) {
   const experimental = config.experimental || {};
   if (config.engine === "js" && !experimental.adapter) {
-    return import_effect2.Either.left(
+    return import_effect3.Either.left(
       new Error("The `engine === 'js'` configuration requires `experimental.adapter` to be set to `true`.")
     );
   }
   if (config.studio && !experimental.studio) {
-    return import_effect2.Either.left(new Error("The `studio` configuration requires `experimental.studio` to be set to `true`."));
+    return import_effect3.Either.left(new Error("The `studio` configuration requires `experimental.studio` to be set to `true`."));
   }
   if (config.tables?.external && !experimental.externalTables) {
-    return import_effect2.Either.left(
+    return import_effect3.Either.left(
       new Error("The `tables.external` configuration requires `experimental.externalTables` to be set to `true`.")
     );
   }
   if (config.enums?.external && !experimental.externalTables) {
-    return import_effect2.Either.left(
+    return import_effect3.Either.left(
       new Error("The `enums.external` configuration requires `experimental.externalTables` to be set to `true`.")
     );
   }
   if (config.migrations?.initShadowDb && !experimental.externalTables) {
-    return import_effect2.Either.left(
+    return import_effect3.Either.left(
       new Error(
         "The `migrations.initShadowDb` configuration requires `experimental.externalTables` to be set to `true`."
       )
     );
   }
   if (config["extensions"] && !experimental.extensions) {
-    return import_effect2.Either.left(
+    return import_effect3.Either.left(
       new Error("The `extensions` configuration requires `experimental.extensions` to be set to `true`.")
     );
   }
-  return import_effect2.Either.right(config);
+  return import_effect3.Either.right(config);
 }
 function parsePrismaConfigShape(input) {
   return (0, import_Function.pipe)(
-    import_effect2.Schema.decodeUnknownEither(PrismaConfigShape, {})(input, {
+    import_effect3.Schema.decodeUnknownEither(PrismaConfigShape, {})(input, {
       onExcessProperty: "error"
     }),
-    import_effect2.Either.flatMap(validateExperimentalFeatures2)
+    import_effect3.Either.flatMap(validateExperimentalFeatures2)
   );
 }
 var PRISMA_CONFIG_INTERNAL_BRAND = Symbol.for("PrismaConfigInternal");
-var PrismaConfigInternalShape = import_effect2.Schema.extend(
+var PrismaConfigInternalShape = import_effect3.Schema.extend(
   PrismaConfigUnconditionalShape,
-  import_effect2.Schema.extend(
+  import_effect3.Schema.extend(
     SchemaEngineConfigInternal,
-    import_effect2.Schema.Struct({
-      loadedFromFile: import_effect2.Schema.NullOr(import_effect2.Schema.String)
+    import_effect3.Schema.Struct({
+      loadedFromFile: import_effect3.Schema.NullOr(import_effect3.Schema.String),
+      deprecatedPackageJson: import_effect3.Schema.NullOr(
+        import_effect3.Schema.Struct({
+          config: PrismaConfigPackageJsonShape,
+          loadedFromFile: import_effect3.Schema.String
+        })
+      )
     })
   )
 );
@@ -704,10 +740,10 @@ function parsePrismaConfigInternalShape(input) {
   debug3("Parsing PrismaConfigInternal: %o", input);
   if (typeof input === "object" && input !== null && input["__brand"] === PRISMA_CONFIG_INTERNAL_BRAND) {
     debug3("Short-circuit: input is already a PrismaConfigInternal object");
-    return import_effect2.Either.right(input);
+    return import_effect3.Either.right(input);
   }
   return (0, import_Function.pipe)(
-    import_effect2.Schema.decodeUnknownEither(PrismaConfigInternalShape, {})(input, {
+    import_effect3.Schema.decodeUnknownEither(PrismaConfigInternalShape, {})(input, {
       onExcessProperty: "error"
     }),
     // Brand the output type to make `PrismaConfigInternal` opaque, without exposing the `Effect/Brand` type
@@ -716,7 +752,7 @@ function parsePrismaConfigInternalShape(input) {
     // - https://github.com/microsoft/rushstack/issues/1308
     // - https://github.com/microsoft/rushstack/issues/4034
     // - https://github.com/microsoft/TypeScript/issues/58914
-    import_effect2.Either.map(brandPrismaConfigInternal)
+    import_effect3.Either.map(brandPrismaConfigInternal)
   );
 }
 function makePrismaConfigInternal(makeArgs) {
@@ -726,14 +762,14 @@ function parseDefaultExport(defaultExport) {
   const parseResultEither = (0, import_Function.pipe)(
     // If the given config conforms to the `PrismaConfig` shape, feed it to `defineConfig`.
     parsePrismaConfigShape(defaultExport),
-    import_effect2.Either.map((config) => {
+    import_effect3.Either.map((config) => {
       debug3("Parsed `PrismaConfig` shape: %o", config);
       return defineConfig(config);
     }),
     // Otherwise, try to parse it as a `PrismaConfigInternal` shape.
-    import_effect2.Either.orElse(() => parsePrismaConfigInternalShape(defaultExport))
+    import_effect3.Either.orElse(() => parsePrismaConfigInternalShape(defaultExport))
   );
-  if (import_effect2.Either.isLeft(parseResultEither)) {
+  if (import_effect3.Either.isLeft(parseResultEither)) {
     throw parseResultEither.left;
   }
   return parseResultEither.right;
@@ -742,7 +778,8 @@ function parseDefaultExport(defaultExport) {
 // src/defaultTestConfig.ts
 function defaultTestConfig() {
   return makePrismaConfigInternal({
-    loadedFromFile: null
+    loadedFromFile: null,
+    deprecatedPackageJson: null
   });
 }
 
@@ -763,16 +800,27 @@ function env(name) {
 
 // src/loadConfigFromFile.ts
 var import_node_path = __toESM(require("node:path"));
-var import_node_process = __toESM(require("node:process"));
+var import_node_process2 = __toESM(require("node:process"));
 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()
+  configRoot = import_node_process2.default.cwd()
 }) {
   const start = performance.now();
   const getTime = () => `${(performance.now() - start).toFixed(2)}ms`;
   const diagnostics = [];
+  const deprecatedPrismaConfigFromJson = await loadConfigFromPackageJson(configRoot);
+  if (deprecatedPrismaConfigFromJson) {
+    diagnostics.push({
+      _tag: "warn",
+      value: ({ warn, link }) => () => warn(
+        `The configuration property \`package.json#prisma\` is deprecated and will be removed in Prisma 7. Please migrate to a Prisma config file (e.g., \`prisma.config.ts\`).
+For more information, see: ${link("https://pris.ly/prisma-config")}
+`
+      )
+    });
+  }
   try {
     const { configModule, resolvedPath, error } = await loadConfigTsOrJs(configRoot, configFile);
     if (error) {
@@ -807,6 +855,20 @@ async function loadConfigFromFile({
 `))
     });
     const prismaConfig = transformPathsInConfigToAbsolute(parsedConfig, resolvedPath);
+    if (deprecatedPrismaConfigFromJson) {
+      diagnostics.push({
+        _tag: "warn",
+        value: ({ warn, link }) => () => warn(`The Prisma config file in ${import_node_path.default.relative(
+          configRoot,
+          resolvedPath
+        )} overrides the deprecated \`package.json#prisma\` property in ${import_node_path.default.relative(
+          configRoot,
+          deprecatedPrismaConfigFromJson.loadedFromFile
+        )}.
+  For more information, see: ${link("https://pris.ly/prisma-config")}
+`)
+      });
+    }
     return {
       config: {
         ...prismaConfig,
@@ -933,5 +995,6 @@ function transformPathsInConfigToAbsolute(prismaConfig, resolvedPath) {
   defaultTestConfig,
   defineConfig,
   env,
-  loadConfigFromFile
+  loadConfigFromFile,
+  loadConfigFromPackageJson
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/config",
-  "version": "6.20.0-integration-next.3",
+  "version": "6.20.0-integration-merge-release-workflows.2",
   "description": "Internal package used to define and read Prisma configuration files",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,8 +19,8 @@
   },
   "devDependencies": {
     "vitest": "3.2.4",
-    "@prisma/driver-adapter-utils": "6.20.0-integration-next.3",
-    "@prisma/get-platform": "6.20.0-integration-next.3"
+    "@prisma/driver-adapter-utils": "6.20.0-integration-merge-release-workflows.2",
+    "@prisma/get-platform": "6.20.0-integration-merge-release-workflows.2"
   },
   "files": [
     "dist"