@prisma/config 6.4.0-dev.60 → 6.4.0-dev.62

package/dist/PrismaConfig.d.ts

@@ -22,6 +22,45 @@ declare const PrismaSchemaConfigShape: Shape.Union<[Shape.Struct<{
     folderPath: typeof Shape.String;
 }>]>;
 export type PrismaSchemaConfigShape = typeof PrismaSchemaConfigShape.Type;
+export declare const createPrismaConfigShape: () => Shape.Struct<{
+    /**
+     * Whether features with an unstable API are enabled.
+     */
+    earlyAccess: Shape.Literal<[true]>;
+    /**
+     * The configuration for the Prisma schema file(s).
+     */
+    schema: Shape.optional<Shape.Union<[Shape.Struct<{
+        /**
+         * Tell Prisma to use a single `.prisma` schema file.
+         */
+        kind: Shape.Literal<["single"]>;
+        /**
+         * The path to a single `.prisma` schema file.
+         */
+        filePath: typeof Shape.String;
+    }>, Shape.Struct<{
+        /**
+         * Tell Prisma to use multiple `.prisma` schema files, via the `prismaSchemaFolder` preview feature.
+         */
+        kind: Shape.Literal<["multi"]>;
+        /**
+         * The path to a folder containing multiple `.prisma` schema files.
+         * All of the files in this folder will be used.
+         */
+        folderPath: typeof Shape.String;
+    }>]>>;
+}>;
+/**
+ * The configuration for the Prisma Development Kit, before it is passed to the `defineConfig` function.
+ * Thanks to the branding, this type is opaque and cannot be constructed directly.
+ */
+export type PrismaConfig = ReturnType<typeof createPrismaConfigShape>['Type'];
+/**
+ * Parse a given input object to ensure it conforms to the `PrismaConfig` type Shape.
+ * This function may fail, but it will never throw.
+ */
+export declare function parsePrismaConfigShape(input: unknown): Either<PrismaConfig, ParseError>;
 export declare const createPrismaConfigInternalShape: () => Shape.brand<Shape.Struct<{
     /**
      * Whether features with an unstable API are enabled.
@@ -63,7 +102,7 @@ export declare const createPrismaConfigInternalShape: () => Shape.brand<Shape.St
  */
 export type PrismaConfigInternal = ReturnType<typeof createPrismaConfigInternalShape>['Type'];
 /**
- * Parse a given input object to ensure it conforms to the `PrismaConfig` type Shape.
+ * Parse a given input object to ensure it conforms to the `PrismaConfigInternal` type Shape.
  * This function may fail, but it will never throw.
  */
 export declare function parsePrismaConfigInternalShape(input: unknown): Either<PrismaConfigInternal, ParseError>;

package/dist/PrismaConfig.js

@@ -30,7 +30,9 @@ var __privateSet = (obj, member, value3, setter) => (__accessCheck(obj, member,
 var PrismaConfig_exports = {};
 __export(PrismaConfig_exports, {
   createPrismaConfigInternalShape: () => createPrismaConfigInternalShape,
-  parsePrismaConfigInternalShape: () => parsePrismaConfigInternalShape
+  createPrismaConfigShape: () => createPrismaConfigShape,
+  parsePrismaConfigInternalShape: () => parsePrismaConfigInternalShape,
+  parsePrismaConfigShape: () => parsePrismaConfigShape
 });
 module.exports = __toCommonJS(PrismaConfig_exports);
 
@@ -22166,6 +22168,21 @@ var PrismaConfigSchemaMultiShape = Schema_exports.Struct({
   folderPath: Schema_exports.String
 });
 var PrismaSchemaConfigShape = Schema_exports.Union(PrismaConfigSchemaSingleShape, PrismaConfigSchemaMultiShape);
+var createPrismaConfigShape = () => Schema_exports.Struct({
+  /**
+   * Whether features with an unstable API are enabled.
+   */
+  earlyAccess: Schema_exports.Literal(true),
+  /**
+   * The configuration for the Prisma schema file(s).
+   */
+  schema: Schema_exports.optional(PrismaSchemaConfigShape)
+});
+function parsePrismaConfigShape(input) {
+  return Schema_exports.decodeUnknownEither(createPrismaConfigShape(), {})(input, {
+    onExcessProperty: "error"
+  });
+}
 var createPrismaConfigInternalShape = () => pipe(
   Schema_exports.Struct({
     /**
@@ -22192,5 +22209,7 @@ function parsePrismaConfigInternalShape(input) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createPrismaConfigInternalShape,
-  parsePrismaConfigInternalShape
+  createPrismaConfigShape,
+  parsePrismaConfigInternalShape,
+  parsePrismaConfigShape
 });

package/dist/defineConfig.d.ts

@@ -1,19 +1,5 @@
-import type { PrismaConfigInternal, PrismaSchemaConfigShape } from './PrismaConfig';
+import type { PrismaConfig, PrismaConfigInternal } from './PrismaConfig';
 export type { PrismaConfigInternal };
-/**
- * Define the input configuration for the Prisma Development Kit.
- */
-export type PrismaConfig = {
-    /**
-     * Whether to enable experimental features.
-     * Currently, every feature is considered experimental.
-     */
-    earlyAccess: true;
-    /**
-     * The location of the Prisma schema file(s).
-     */
-    schema?: PrismaSchemaConfigShape;
-};
 /**
  * Define the configuration for the Prisma Development Kit.
  */

package/dist/index.d.ts

@@ -2,4 +2,4 @@ export { defaultConfig } from './defaultConfig';
 export { defaultTestConfig } from './defaultTestConfig';
 export { defineConfig } from './defineConfig';
 export { type ConfigFromFile, loadConfigFromFile, type LoadConfigFromFileError } from './loadConfigFromFile';
-export type { PrismaConfigInternal } from './PrismaConfig';
+export type { PrismaConfig, PrismaConfigInternal } from './PrismaConfig';

package/dist/index.js

@@ -22296,6 +22296,21 @@ var PrismaConfigSchemaMultiShape = Schema_exports.Struct({
   folderPath: Schema_exports.String
 });
 var PrismaSchemaConfigShape = Schema_exports.Union(PrismaConfigSchemaSingleShape, PrismaConfigSchemaMultiShape);
+var createPrismaConfigShape = () => Schema_exports.Struct({
+  /**
+   * Whether features with an unstable API are enabled.
+   */
+  earlyAccess: Schema_exports.Literal(true),
+  /**
+   * The configuration for the Prisma schema file(s).
+   */
+  schema: Schema_exports.optional(PrismaSchemaConfigShape)
+});
+function parsePrismaConfigShape(input) {
+  return Schema_exports.decodeUnknownEither(createPrismaConfigShape(), {})(input, {
+    onExcessProperty: "error"
+  });
+}
 var createPrismaConfigInternalShape = () => pipe(
   Schema_exports.Struct({
     /**
@@ -22571,7 +22586,17 @@ async function loadConfigFromFile({
       };
     }
     debug2(`Config file loaded in %s`, getTime());
-    const parseResultEither = parsePrismaConfigInternalShape(required3["default"]);
+    const defaultExport = required3["default"];
+    const parseResultEither = pipe(
+      // If the given config conforms to the `PrismaConfig` shape, feed it to `defineConfig`.
+      parsePrismaConfigShape(defaultExport),
+      Either_exports.map((config2) => {
+        debug2("Parsed `PrismaConfig` shape: %o", config2);
+        return defineConfig(config2);
+      }),
+      // Otherwise, try to parse it as a `PrismaConfigInternal` shape.
+      Either_exports.orElse(() => parsePrismaConfigInternalShape(defaultExport))
+    );
     if (Either_exports.isLeft(parseResultEither)) {
       return {
         resolvedPath,

package/dist/loadConfigFromFile.d.ts

@@ -1,5 +1,5 @@
 import { ParseError } from 'effect/ParseResult';
-import type { PrismaConfigInternal } from './defineConfig';
+import { type PrismaConfigInternal } from './defineConfig';
 type LoadConfigFromFileInput = {
     /**
      * The path to the config file to load. If not provided, we will attempt to find a config file in the `configRoot` directory.

package/dist/loadConfigFromFile.js

@@ -22482,6 +22482,21 @@ var PrismaConfigSchemaMultiShape = Schema_exports.Struct({
   folderPath: Schema_exports.String
 });
 var PrismaSchemaConfigShape = Schema_exports.Union(PrismaConfigSchemaSingleShape, PrismaConfigSchemaMultiShape);
+var createPrismaConfigShape = () => Schema_exports.Struct({
+  /**
+   * Whether features with an unstable API are enabled.
+   */
+  earlyAccess: Schema_exports.Literal(true),
+  /**
+   * The configuration for the Prisma schema file(s).
+   */
+  schema: Schema_exports.optional(PrismaSchemaConfigShape)
+});
+function parsePrismaConfigShape(input) {
+  return Schema_exports.decodeUnknownEither(createPrismaConfigShape(), {})(input, {
+    onExcessProperty: "error"
+  });
+}
 var createPrismaConfigInternalShape = () => pipe(
   Schema_exports.Struct({
     /**
@@ -22506,8 +22521,31 @@ function parsePrismaConfigInternalShape(input) {
   });
 }
 
+// src/defaultConfig.ts
+function defaultConfig() {
+  return createPrismaConfigInternalShape().make({
+    earlyAccess: true,
+    loadedFromFile: null
+  });
+}
+
+// src/defineConfig.ts
+var debug = Debug("prisma:config:defineConfig");
+function defineConfig(configInput) {
+  const config2 = defaultConfig();
+  defineSchemaConfig(config2, configInput);
+  return config2;
+}
+function defineSchemaConfig(config2, configInput) {
+  if (!configInput.schema) {
+    return;
+  }
+  config2.schema = configInput.schema;
+  debug("Prisma config [schema]: %o", config2.schema);
+}
+
 // src/loadConfigFromFile.ts
-var debug = Debug("prisma:config:loadConfigFromFile");
+var debug2 = Debug("prisma:config:loadConfigFromFile");
 async function loadConfigFromFile({
   configFile,
   configRoot = import_node_process.default.cwd()
@@ -22518,13 +22556,13 @@ async function loadConfigFromFile({
   if (configFile) {
     resolvedPath = import_node_path.default.resolve(configRoot, configFile);
     if (!import_node_fs.default.existsSync(resolvedPath)) {
-      debug(`The given config file was not found at %s`, resolvedPath);
+      debug2(`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) {
-      debug(`No config file found in the current working directory %s`, configRoot);
+      debug2(`No config file found in the current working directory %s`, configRoot);
       return { resolvedPath };
     }
   }
@@ -22536,8 +22574,18 @@ async function loadConfigFromFile({
         error
       };
     }
-    debug(`Config file loaded in %s`, getTime());
-    const parseResultEither = parsePrismaConfigInternalShape(required3["default"]);
+    debug2(`Config file loaded in %s`, getTime());
+    const defaultExport = required3["default"];
+    const parseResultEither = pipe(
+      // If the given config conforms to the `PrismaConfig` shape, feed it to `defineConfig`.
+      parsePrismaConfigShape(defaultExport),
+      Either_exports.map((config2) => {
+        debug2("Parsed `PrismaConfig` shape: %o", config2);
+        return defineConfig(config2);
+      }),
+      // Otherwise, try to parse it as a `PrismaConfigInternal` shape.
+      Either_exports.orElse(() => parsePrismaConfigInternalShape(defaultExport))
+    );
     if (Either_exports.isLeft(parseResultEither)) {
       return {
         resolvedPath,
@@ -22583,7 +22631,7 @@ async function requireTypeScriptFile(resolvedPath) {
     };
   } catch (e) {
     const error = e;
-    debug("esbuild-register registration failed: %s", error.message);
+    debug2("esbuild-register registration failed: %s", error.message);
     return {
       error: {
         _tag: "TypeScriptImportFailed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/config",
-  "version": "6.4.0-dev.60",
+  "version": "6.4.0-dev.62",
   "description": "Internal package used to define and read Prisma configuration files",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,8 +18,8 @@
     "esbuild-register": "3.6.0",
     "jest": "29.7.0",
     "jest-junit": "16.0.0",
-    "@prisma/get-platform": "6.4.0-dev.60",
-    "@prisma/driver-adapter-utils": "6.4.0-dev.60"
+    "@prisma/get-platform": "6.4.0-dev.62",
+    "@prisma/driver-adapter-utils": "6.4.0-dev.62"
   },
   "files": [
     "dist"