Erster Docker-Stand

_node_modules/@prisma/config/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

_node_modules/@prisma/config/dist/index.d.ts

@@ -0,0 +1,224 @@
+export declare type ConfigDiagnostic = {
+    _tag: 'log';
+    value: (formatters: InjectFormatters) => () => void;
+} | {
+    _tag: 'warn';
+    value: (formatters: InjectFormatters) => () => void;
+};
+
+export declare type ConfigFromFile = {
+    resolvedPath: string;
+    config: PrismaConfigInternal;
+    error?: never;
+    diagnostics: ConfigDiagnostic[];
+} | {
+    resolvedPath: string;
+    config?: never;
+    error: LoadConfigFromFileError;
+    diagnostics: ConfigDiagnostic[];
+} | {
+    resolvedPath: null;
+    config: PrismaConfigInternal;
+    error?: never;
+    diagnostics: ConfigDiagnostic[];
+};
+
+export declare type Datasource = {
+    url?: string;
+    shadowDatabaseUrl?: string;
+};
+
+/**
+ * This default config can be used as basis for unit and integration tests.
+ */
+export declare function defaultTestConfig(): PrismaConfigInternal;
+
+/**
+ * Define the configuration for the Prisma Development Kit.
+ */
+export declare function defineConfig(configInput: PrismaConfig): PrismaConfigInternal;
+
+declare type EnumsConfigShape = {
+    /**
+     * List of enums that are externally managed.
+     * Prisma will not modify the structure of these enums and not generate migrations for those enums.
+     * These enums will still be represented in schema.prisma file and be available in the client API.
+     */
+    external?: string[];
+};
+
+export declare function env(name: string): string;
+
+export declare function env<Env>(name: EnvKey<Env> & string): string;
+
+declare type EnvKey<Env> = keyof {
+    [K in keyof Env as Env[K] extends string | undefined ? K : never]: Env[K];
+};
+
+declare type ExperimentalConfig = {
+    /**
+     * Enable experimental external tables support.
+     */
+    externalTables?: boolean;
+    /**
+     * Enable experimental extensions support. This is required to use the `extensions` config option.
+     */
+    extensions?: boolean;
+};
+
+export declare type InjectFormatters = {
+    dim: (data: string) => string;
+    log: (data: string) => void;
+    warn: (data: string) => void;
+    link: (data: string) => string;
+};
+
+/**
+ * Load a Prisma config file from the given directory.
+ * This function may fail, but it will never throw.
+ * The possible error is returned in the result object, so the caller can handle it as needed.
+ */
+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: 'ConfigLoadError';
+    error: Error;
+} | {
+    _tag: 'ConfigFileSyntaxError';
+    error: Error;
+} | {
+    _tag: 'UnknownError';
+    error: Error;
+};
+
+declare 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.
+     */
+    configFile?: string;
+    /**
+     * The directory to search for the config file in. Defaults to the current working directory.
+     */
+    configRoot?: string;
+};
+
+declare type MigrationsConfigShape = {
+    /**
+     * The path to the directory where Prisma should store migration files, and look for them.
+     */
+    path?: string;
+    /**
+     * Provide a SQL script that will be used to setup external tables and enums during migration diffing.
+     * Also see `tables.external` and `enums.external`.
+     */
+    initShadowDb?: string;
+    /**
+     * The command to run to seed the database after schema migrations are applied.
+     */
+    seed?: string;
+};
+
+declare const PRISMA_CONFIG_INTERNAL_BRAND: unique symbol;
+
+/**
+ * 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 declare type PrismaConfig = {
+    /**
+     * Experimental feature gates. Each experimental feature must be explicitly enabled.
+     */
+    experimental?: Simplify<ExperimentalConfig>;
+    /**
+     * The datasource configuration. Optional for most cases, but required for migration / introspection commands.
+     */
+    datasource?: Simplify<Datasource>;
+    /**
+     * The path to the schema file, or path to a folder that shall be recursively searched for *.prisma files.
+     */
+    schema?: string;
+    /**
+     * Configuration for Prisma migrations.
+     */
+    migrations?: Simplify<MigrationsConfigShape>;
+    /**
+     * Configuration for the database table entities.
+     */
+    tables?: Simplify<TablesConfigShape>;
+    /**
+     * Configuration for the database enum entities.
+     */
+    enums?: Simplify<EnumsConfigShape>;
+    /**
+     * Configuration for the database view entities.
+     */
+    views?: Simplify<ViewsConfigShape>;
+    /**
+     * Configuration for the `typedSql` preview feature.
+     */
+    typedSql?: Simplify<TypedSqlConfigShape>;
+};
+
+export declare class PrismaConfigEnvError extends Error {
+    constructor(name: string);
+}
+
+/**
+ * The configuration for the Prisma Development Kit, after it has been parsed and processed
+ * by the `defineConfig` function.
+ * Thanks to the branding, this type is opaque and cannot be constructed directly.
+ */
+export declare type PrismaConfigInternal = _PrismaConfigInternal & {
+    __brand: typeof PRISMA_CONFIG_INTERNAL_BRAND;
+};
+
+declare type _PrismaConfigInternal = PrismaConfig & {
+    loadedFromFile: string | null;
+};
+
+export declare type SchemaEngineConfigInternal = {
+    datasource?: Datasource;
+};
+
+/**
+ * Simplifies the type signature of a type.
+ * Re-exported from `effect/Types`.
+ *
+ * @example
+ * ```ts
+ * type Res = Simplify<{ a: number } & { b: number }> // { a: number; b: number; }
+ * ```
+ */
+declare type Simplify<A> = {
+    [K in keyof A]: A[K];
+} extends infer B ? B : never;
+
+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 type TypedSqlConfigShape = {
+    /**
+     * The path to the directory where Prisma should look for the `typedSql` queries, where *.sql files will be loaded.
+     */
+    path?: string;
+};
+
+declare type ViewsConfigShape = {
+    /**
+     * The path to the directory where Prisma should look for the view definitions, where *.sql files will be loaded.
+     */
+    path?: string;
+};
+
+export { }

_node_modules/@prisma/config/dist/index.js

@@ -0,0 +1,696 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PrismaConfigEnvError: () => PrismaConfigEnvError,
+  defaultTestConfig: () => defaultTestConfig,
+  defineConfig: () => defineConfig,
+  env: () => env,
+  loadConfigFromFile: () => loadConfigFromFile
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../debug/dist/index.mjs
+var __defProp2 = Object.defineProperty;
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var colors_exports = {};
+__export2(colors_exports, {
+  $: () => $,
+  bgBlack: () => bgBlack,
+  bgBlue: () => bgBlue,
+  bgCyan: () => bgCyan,
+  bgGreen: () => bgGreen,
+  bgMagenta: () => bgMagenta,
+  bgRed: () => bgRed,
+  bgWhite: () => bgWhite,
+  bgYellow: () => bgYellow,
+  black: () => black,
+  blue: () => blue,
+  bold: () => bold,
+  cyan: () => cyan,
+  dim: () => dim,
+  gray: () => gray,
+  green: () => green,
+  grey: () => grey,
+  hidden: () => hidden,
+  inverse: () => inverse,
+  italic: () => italic,
+  magenta: () => magenta,
+  red: () => red,
+  reset: () => reset,
+  strikethrough: () => strikethrough,
+  underline: () => underline,
+  white: () => white,
+  yellow: () => yellow
+});
+var FORCE_COLOR;
+var NODE_DISABLE_COLORS;
+var NO_COLOR;
+var TERM;
+var isTTY = true;
+if (typeof process !== "undefined") {
+  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+  isTTY = process.stdout && process.stdout.isTTY;
+}
+var $ = {
+  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
+};
+function init(x, y) {
+  let rgx = new RegExp(`\\x1b\\[${y}m`, "g");
+  let open = `\x1B[${x}m`, close = `\x1B[${y}m`;
+  return function(txt) {
+    if (!$.enabled || txt == null) return txt;
+    return open + (!!~("" + txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
+  };
+}
+var reset = init(0, 0);
+var bold = init(1, 22);
+var dim = init(2, 22);
+var italic = init(3, 23);
+var underline = init(4, 24);
+var inverse = init(7, 27);
+var hidden = init(8, 28);
+var strikethrough = init(9, 29);
+var black = init(30, 39);
+var red = init(31, 39);
+var green = init(32, 39);
+var yellow = init(33, 39);
+var blue = init(34, 39);
+var magenta = init(35, 39);
+var cyan = init(36, 39);
+var white = init(37, 39);
+var gray = init(90, 39);
+var grey = init(90, 39);
+var bgBlack = init(40, 49);
+var bgRed = init(41, 49);
+var bgGreen = init(42, 49);
+var bgYellow = init(43, 49);
+var bgBlue = init(44, 49);
+var bgMagenta = init(45, 49);
+var bgCyan = init(46, 49);
+var bgWhite = init(47, 49);
+var MAX_ARGS_HISTORY = 100;
+var COLORS = ["green", "yellow", "blue", "magenta", "cyan", "red"];
+var argsHistory = [];
+var lastTimestamp = Date.now();
+var lastColor = 0;
+var processEnv = typeof process !== "undefined" ? process.env : {};
+globalThis.DEBUG ??= processEnv.DEBUG ?? "";
+globalThis.DEBUG_COLORS ??= processEnv.DEBUG_COLORS ? processEnv.DEBUG_COLORS === "true" : true;
+var topProps = {
+  enable(namespace) {
+    if (typeof namespace === "string") {
+      globalThis.DEBUG = namespace;
+    }
+  },
+  disable() {
+    const prev = globalThis.DEBUG;
+    globalThis.DEBUG = "";
+    return prev;
+  },
+  // this is the core logic to check if logging should happen or not
+  enabled(namespace) {
+    const listenedNamespaces = globalThis.DEBUG.split(",").map((s) => {
+      return s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    });
+    const isListened = listenedNamespaces.some((listenedNamespace) => {
+      if (listenedNamespace === "" || listenedNamespace[0] === "-") return false;
+      return namespace.match(RegExp(listenedNamespace.split("*").join(".*") + "$"));
+    });
+    const isExcluded = listenedNamespaces.some((listenedNamespace) => {
+      if (listenedNamespace === "" || listenedNamespace[0] !== "-") return false;
+      return namespace.match(RegExp(listenedNamespace.slice(1).split("*").join(".*") + "$"));
+    });
+    return isListened && !isExcluded;
+  },
+  log: (...args) => {
+    const [namespace, format, ...rest] = args;
+    const logWithFormatting = console.warn ?? console.log;
+    logWithFormatting(`${namespace} ${format}`, ...rest);
+  },
+  formatters: {}
+  // not implemented
+};
+function debugCreate(namespace) {
+  const instanceProps = {
+    color: COLORS[lastColor++ % COLORS.length],
+    enabled: topProps.enabled(namespace),
+    namespace,
+    log: topProps.log,
+    extend: () => {
+    }
+    // not implemented
+  };
+  const debugCall = (...args) => {
+    const { enabled, namespace: namespace2, color, log } = instanceProps;
+    if (args.length !== 0) {
+      argsHistory.push([namespace2, ...args]);
+    }
+    if (argsHistory.length > MAX_ARGS_HISTORY) {
+      argsHistory.shift();
+    }
+    if (topProps.enabled(namespace2) || enabled) {
+      const stringArgs = args.map((arg) => {
+        if (typeof arg === "string") {
+          return arg;
+        }
+        return safeStringify(arg);
+      });
+      const ms = `+${Date.now() - lastTimestamp}ms`;
+      lastTimestamp = Date.now();
+      if (globalThis.DEBUG_COLORS) {
+        log(colors_exports[color](bold(namespace2)), ...stringArgs, colors_exports[color](ms));
+      } else {
+        log(namespace2, ...stringArgs, ms);
+      }
+    }
+  };
+  return new Proxy(debugCall, {
+    get: (_, prop) => instanceProps[prop],
+    set: (_, prop, value) => instanceProps[prop] = value
+  });
+}
+var Debug = new Proxy(debugCreate, {
+  get: (_, prop) => topProps[prop],
+  set: (_, prop, value) => topProps[prop] = value
+});
+function safeStringify(value, indent = 2) {
+  const cache = /* @__PURE__ */ new Set();
+  return JSON.stringify(
+    value,
+    (key, value2) => {
+      if (typeof value2 === "object" && value2 !== null) {
+        if (cache.has(value2)) {
+          return `[Circular *]`;
+        }
+        cache.add(value2);
+      } else if (typeof value2 === "bigint") {
+        return value2.toString();
+      }
+      return value2;
+    },
+    indent
+  );
+}
+
+// src/PrismaConfig.ts
+var import_effect2 = require("effect");
+var import_Function = require("effect/Function");
+
+// src/defineConfig.ts
+var import_effect = require("effect");
+
+// src/defaultConfig.ts
+function defaultConfig() {
+  return makePrismaConfigInternal({
+    loadedFromFile: null
+  });
+}
+
+// src/defineConfig.ts
+function validateExperimentalFeatures(config) {
+  const experimental = config.experimental || {};
+  if (config.tables?.external && !experimental.externalTables) {
+    return import_effect.Either.left(
+      new Error("The `tables.external` configuration requires `experimental.externalTables` to be set to `true`.")
+    );
+  }
+  if (config.migrations?.initShadowDb && !experimental.externalTables) {
+    return import_effect.Either.left(
+      new Error(
+        "The `migrations.initShadowDb` configuration requires `experimental.externalTables` to be set to `true`."
+      )
+    );
+  }
+  if (config["extensions"] !== void 0 && !experimental.extensions) {
+    return import_effect.Either.left(
+      new Error("The `extensions` configuration requires `experimental.extensions` to be set to `true`.")
+    );
+  }
+  return import_effect.Either.right(config);
+}
+var debug = Debug("prisma:config:defineConfig");
+function defineConfig(configInput) {
+  const validationResult = validateExperimentalFeatures(configInput);
+  if (validationResult._tag === "Left") {
+    throw validationResult.left;
+  }
+  const config = defaultConfig();
+  debug("[default]: %o", config);
+  defineExperimentalConfig(config, configInput);
+  defineSchemaConfig(config, configInput);
+  defineDatasource(config, configInput);
+  defineMigrationsConfig(config, configInput);
+  defineTablesConfig(config, configInput);
+  defineEnumsConfig(config, configInput);
+  defineTypedSqlConfig(config, configInput);
+  defineViewsConfig(config, configInput);
+  defineExtensionsConfig(config, configInput);
+  return config;
+}
+function defineExperimentalConfig(config, configInput) {
+  if (!configInput.experimental) {
+    return;
+  }
+  config.experimental = configInput.experimental;
+  debug("[config.experimental]: %o", config.experimental);
+}
+function defineSchemaConfig(config, configInput) {
+  if (!configInput.schema) {
+    return;
+  }
+  config.schema = configInput.schema;
+  debug("[config.schema]: %o", config.schema);
+}
+function defineMigrationsConfig(config, configInput) {
+  if (!configInput.migrations) {
+    return;
+  }
+  config.migrations = configInput.migrations;
+  debug("[config.migrations]: %o", config.migrations);
+}
+function defineTypedSqlConfig(config, configInput) {
+  if (!configInput.typedSql) {
+    return;
+  }
+  config.typedSql = configInput.typedSql;
+  debug("[config.typedSql]: %o", config.typedSql);
+}
+function defineViewsConfig(config, configInput) {
+  if (!configInput.views) {
+    return;
+  }
+  config.views = configInput.views;
+  debug("[config.views]: %o", config.views);
+}
+function defineTablesConfig(config, configInput) {
+  if (!configInput.tables) {
+    return;
+  }
+  config.tables = configInput.tables;
+  debug("[config.tables]: %o", config.tables);
+}
+function defineEnumsConfig(config, configInput) {
+  if (!configInput.enums) {
+    return;
+  }
+  config.enums = configInput.enums;
+  debug("[config.enums]: %o", config.enums);
+}
+function defineDatasource(config, configInput) {
+  const { datasource } = configInput;
+  Object.assign(config, { datasource });
+  debug("[config.datasource]: %o", datasource);
+}
+function defineExtensionsConfig(config, configInput) {
+  if (!configInput["extensions"]) {
+    return;
+  }
+  config["extensions"] = configInput["extensions"];
+  debug("[config.extensions]: %o", config["extensions"]);
+}
+
+// src/PrismaConfig.ts
+var debug2 = Debug("prisma:config:PrismaConfig");
+var DatasourceShape = import_effect2.Schema.Struct({
+  url: import_effect2.Schema.optional(import_effect2.Schema.String),
+  shadowDatabaseUrl: import_effect2.Schema.optional(import_effect2.Schema.String)
+});
+var ExperimentalConfigShape = import_effect2.Schema.Struct({
+  externalTables: import_effect2.Schema.optional(import_effect2.Schema.Boolean),
+  extensions: import_effect2.Schema.optional(import_effect2.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)
+});
+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)))
+});
+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)))
+});
+if (false) {
+  __testEnumsConfigShapeValueA;
+  __testEnumsConfigShapeValueB;
+}
+var ViewsConfigShape = import_effect2.Schema.Struct({
+  path: import_effect2.Schema.optional(import_effect2.Schema.String)
+});
+if (false) {
+  __testViewsConfigShapeValueA;
+  __testViewsConfigShapeValueB;
+}
+var TypedSqlConfigShape = import_effect2.Schema.Struct({
+  path: import_effect2.Schema.optional(import_effect2.Schema.String)
+});
+if (false) {
+  __testTypedSqlConfigShapeValueA;
+  __testTypedSqlConfigShapeValueB;
+}
+if (false) {
+  __testPrismaConfig;
+  __testPrismaConfigInternal;
+}
+var PrismaConfigShape = import_effect2.Schema.Struct({
+  experimental: import_effect2.Schema.optional(ExperimentalConfigShape),
+  datasource: import_effect2.Schema.optional(DatasourceShape),
+  schema: import_effect2.Schema.optional(import_effect2.Schema.String),
+  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)
+});
+if (false) {
+  __testPrismaConfigValueA;
+  __testPrismaConfigValueB;
+}
+function validateExperimentalFeatures2(config) {
+  const experimental = config.experimental || {};
+  if (config.tables?.external && !experimental.externalTables) {
+    return import_effect2.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(
+      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(
+      new Error(
+        "The `migrations.initShadowDb` configuration requires `experimental.externalTables` to be set to `true`."
+      )
+    );
+  }
+  if (config["extensions"] && !experimental.extensions) {
+    return import_effect2.Either.left(
+      new Error("The `extensions` configuration requires `experimental.extensions` to be set to `true`.")
+    );
+  }
+  return import_effect2.Either.right(config);
+}
+function parsePrismaConfigShape(input) {
+  return (0, import_Function.pipe)(
+    import_effect2.Schema.decodeUnknownEither(PrismaConfigShape, {})(input, {
+      onExcessProperty: "error"
+    }),
+    import_effect2.Either.flatMap(validateExperimentalFeatures2)
+  );
+}
+var PRISMA_CONFIG_INTERNAL_BRAND = Symbol.for("PrismaConfigInternal");
+var PrismaConfigInternalShape = import_effect2.Schema.Struct({
+  ...PrismaConfigShape.fields,
+  loadedFromFile: import_effect2.Schema.NullOr(import_effect2.Schema.String)
+});
+function brandPrismaConfigInternal(config) {
+  Object.defineProperty(config, "__brand", {
+    value: PRISMA_CONFIG_INTERNAL_BRAND,
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+  return config;
+}
+function parsePrismaConfigInternalShape(input) {
+  debug2("Parsing PrismaConfigInternal: %o", input);
+  if (typeof input === "object" && input !== null && input["__brand"] === PRISMA_CONFIG_INTERNAL_BRAND) {
+    debug2("Short-circuit: input is already a PrismaConfigInternal object");
+    return import_effect2.Either.right(input);
+  }
+  return (0, import_Function.pipe)(
+    import_effect2.Schema.decodeUnknownEither(PrismaConfigInternalShape, {})(input, {
+      onExcessProperty: "error"
+    }),
+    // Brand the output type to make `PrismaConfigInternal` opaque, without exposing the `Effect/Brand` type
+    // to the public API.
+    // This is done to work around the following issues:
+    // - 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)
+  );
+}
+function makePrismaConfigInternal(makeArgs) {
+  return (0, import_Function.pipe)(PrismaConfigInternalShape.make(makeArgs), brandPrismaConfigInternal);
+}
+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) => {
+      debug2("Parsed `PrismaConfig` shape: %o", config);
+      return defineConfig(config);
+    }),
+    // Otherwise, try to parse it as a `PrismaConfigInternal` shape.
+    import_effect2.Either.orElse(() => parsePrismaConfigInternalShape(defaultExport))
+  );
+  if (import_effect2.Either.isLeft(parseResultEither)) {
+    throw parseResultEither.left;
+  }
+  return parseResultEither.right;
+}
+
+// src/defaultTestConfig.ts
+function defaultTestConfig() {
+  return makePrismaConfigInternal({
+    loadedFromFile: null
+  });
+}
+
+// src/env.ts
+var PrismaConfigEnvError = class extends Error {
+  constructor(name) {
+    super(`Cannot resolve environment variable: ${name}.`);
+    this.name = "PrismaConfigEnvError";
+  }
+};
+function env(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new PrismaConfigEnvError(name);
+  }
+  return value;
+}
+
+// src/loadConfigFromFile.ts
+var import_node_path = __toESM(require("node:path"));
+var import_node_process = __toESM(require("node:process"));
+var debug3 = 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`;
+  const diagnostics = [];
+  try {
+    const { configModule, resolvedPath, error } = await loadConfigTsOrJs(configRoot, configFile);
+    if (error) {
+      return {
+        resolvedPath,
+        error,
+        diagnostics
+      };
+    }
+    debug3(`Config file loaded in %s`, getTime());
+    if (resolvedPath === null) {
+      debug3(`No config file found in the current working directory %s`, configRoot);
+      return { resolvedPath: null, config: defaultConfig(), diagnostics };
+    }
+    let parsedConfig;
+    try {
+      parsedConfig = parseDefaultExport(configModule);
+    } catch (e) {
+      const error2 = e;
+      return {
+        resolvedPath,
+        error: {
+          _tag: "ConfigFileSyntaxError",
+          error: error2
+        },
+        diagnostics
+      };
+    }
+    diagnostics.push({
+      _tag: "log",
+      value: ({ log, dim: dim2 }) => () => log(dim2(`Loaded Prisma config from ${import_node_path.default.relative(configRoot, resolvedPath)}.
+`))
+    });
+    const prismaConfig = transformPathsInConfigToAbsolute(parsedConfig, resolvedPath);
+    return {
+      config: {
+        ...prismaConfig,
+        loadedFromFile: resolvedPath
+      },
+      resolvedPath,
+      diagnostics
+    };
+  } catch (e) {
+    const error = e;
+    return {
+      resolvedPath: configRoot,
+      error: {
+        _tag: "UnknownError",
+        error
+      },
+      diagnostics
+    };
+  }
+}
+async function loadConfigTsOrJs(configRoot, configFile) {
+  const { loadConfig: loadConfigWithC12 } = await import("c12");
+  const { deepmerge } = await import("deepmerge-ts");
+  try {
+    const {
+      config,
+      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 resolvedPath = _resolvedPath ? import_node_path.default.normalize(_resolvedPath) : void 0;
+    const doesConfigFileExist = resolvedPath !== void 0 && meta !== void 0;
+    if (configFile && !doesConfigFileExist) {
+      debug3(`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: config,
+          resolvedPath,
+          error: {
+            _tag: "ConfigLoadError",
+            error: new Error(`Unsupported Prisma config file extension: ${extension}`)
+          }
+        };
+      }
+    }
+    return {
+      configModule: config,
+      resolvedPath: doesConfigFileExist ? resolvedPath : null,
+      error: null
+    };
+  } catch (e) {
+    const error = e;
+    debug3("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}` : "");
+    debug3("faulty config file: %s", filenameWithExtension);
+    return {
+      error: {
+        _tag: "ConfigLoadError",
+        error
+      },
+      resolvedPath: filenameWithExtension
+    };
+  }
+}
+function transformPathsInConfigToAbsolute(prismaConfig, resolvedPath) {
+  function resolvePath(value) {
+    if (!value) {
+      return void 0;
+    }
+    return import_node_path.default.resolve(import_node_path.default.dirname(resolvedPath), value);
+  }
+  return {
+    ...prismaConfig,
+    schema: resolvePath(prismaConfig.schema),
+    migrations: {
+      ...prismaConfig.migrations,
+      path: resolvePath(prismaConfig.migrations?.path)
+    },
+    typedSql: {
+      ...prismaConfig.typedSql,
+      path: resolvePath(prismaConfig.typedSql?.path)
+    },
+    views: {
+      ...prismaConfig.views,
+      path: resolvePath(prismaConfig.views?.path)
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PrismaConfigEnvError,
+  defaultTestConfig,
+  defineConfig,
+  env,
+  loadConfigFromFile
+});

_node_modules/@prisma/config/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@prisma/config",
+  "version": "7.4.0",
+  "description": "Internal package used to define and read Prisma configuration files",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma.git",
+    "directory": "packages/config"
+  },
+  "license": "Apache-2.0",
+  "author": "Alberto Schiabel <schiabel@prisma.io>",
+  "dependencies": {
+    "c12": "3.1.0",
+    "deepmerge-ts": "7.1.5",
+    "effect": "3.18.4",
+    "empathic": "2.0.0"
+  },
+  "devDependencies": {
+    "dotenv": "17.2.3",
+    "vitest": "3.2.4",
+    "@prisma/debug": "7.4.0",
+    "@prisma/get-platform": "7.4.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "dev": "DEV=true tsx helpers/build.ts",
+    "build": "tsx helpers/build.ts",
+    "test": "vitest run"
+  }
+}