@prisma/internals 6.6.0-dev.6 → 6.6.0-dev.60

package/dist/chunk-QXNNDOVP.js

@@ -0,0 +1,900 @@
+"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 __toESM2 = (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);
+var chunk_QXNNDOVP_exports = {};
+__export(chunk_QXNNDOVP_exports, {
+  checkUnsupportedDataProxy: () => checkUnsupportedDataProxy,
+  forbiddenCmdWithDataProxyFlagMessage: () => forbiddenCmdWithDataProxyFlagMessage,
+  formatSchema: () => formatSchema,
+  getBinaryTargetForCurrentPlatform: () => import_get_platform2.getBinaryTargetForCurrentPlatform,
+  getCLIPathHash: () => getCLIPathHash,
+  getEnvPaths: () => getEnvPaths,
+  getGenerator: () => getGenerator,
+  getGenerators: () => getGenerators,
+  getNodeAPIName: () => import_get_platform2.getNodeAPIName,
+  getPrismaConfigFromPackageJson: () => getPrismaConfigFromPackageJson,
+  getProjectHash: () => getProjectHash,
+  getSchemaFromPackageJson: () => getSchemaFromPackageJson,
+  getSchemaWithPath: () => getSchemaWithPath,
+  getSchemaWithPathOptional: () => getSchemaWithPathOptional,
+  knownBinaryTargets: () => knownBinaryTargets,
+  loadEnvFile: () => loadEnvFile,
+  loadSchemaContext: () => loadSchemaContext,
+  printSchemaLoadedMessage: () => printSchemaLoadedMessage,
+  processSchemaResult: () => processSchemaResult,
+  skipIndex: () => skipIndex
+});
+module.exports = __toCommonJS(chunk_QXNNDOVP_exports);
+var import_chunk_X77CS5RK = require("./chunk-X77CS5RK.js");
+var import_chunk_EPXBOIA5 = require("./chunk-EPXBOIA5.js");
+var import_chunk_RS2R7COT = require("./chunk-RS2R7COT.js");
+var import_chunk_X3P4J7WW = require("./chunk-X3P4J7WW.js");
+var import_chunk_LRU47BGE = require("./chunk-LRU47BGE.js");
+var import_chunk_5FJ3MENK = require("./chunk-5FJ3MENK.js");
+var import_chunk_UTJGRVMG = require("./chunk-UTJGRVMG.js");
+var import_chunk_XLTQGAI2 = require("./chunk-XLTQGAI2.js");
+var import_chunk_5V36RLCO = require("./chunk-5V36RLCO.js");
+var import_chunk_AZV6HVKA = require("./chunk-AZV6HVKA.js");
+var import_chunk_HAGJ64PM = require("./chunk-HAGJ64PM.js");
+var import_chunk_CRVLHWC5 = require("./chunk-CRVLHWC5.js");
+var import_chunk_QJ72IP2K = require("./chunk-QJ72IP2K.js");
+var import_chunk_GNKWZC7O = require("./chunk-GNKWZC7O.js");
+var import_chunk_TN4KCTWC = require("./chunk-TN4KCTWC.js");
+var import_chunk_CW6KQ3VH = require("./chunk-CW6KQ3VH.js");
+var import_chunk_T5MMBF2S = require("./chunk-T5MMBF2S.js");
+var import_chunk_2B26F5N3 = require("./chunk-2B26F5N3.js");
+var import_chunk_M3GBKLGE = require("./chunk-M3GBKLGE.js");
+var import_chunk_XKZ6CBLA = require("./chunk-XKZ6CBLA.js");
+var import_chunk_LMVSIVKQ = require("./chunk-LMVSIVKQ.js");
+var import_chunk_BPDMLM32 = require("./chunk-BPDMLM32.js");
+var import_chunk_IOIAK7V7 = require("./chunk-IOIAK7V7.js");
+var import_chunk_MJIP3FY5 = require("./chunk-MJIP3FY5.js");
+var import_chunk_ZJWZK45Z = require("./chunk-ZJWZK45Z.js");
+var import_chunk_PG5FDKSF = require("./chunk-PG5FDKSF.js");
+var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
+var import_debug = require("@prisma/debug");
+var import_schema_files_loader = require("@prisma/schema-files-loader");
+var import_fs = __toESM2(require("fs"));
+var import_path = __toESM2(require("path"));
+var import_util = require("util");
+var import_debug2 = __toESM2(require("@prisma/debug"));
+var import_crypto = __toESM2(require("crypto"));
+var import_path2 = __toESM2(require("path"));
+var import_debug3 = __toESM2(require("@prisma/debug"));
+var import_engines = require("@prisma/engines");
+var import_fetch_engine = require("@prisma/fetch-engine");
+var import_get_platform = require("@prisma/get-platform");
+var import_path3 = __toESM2(require("path"));
+var import_debug4 = __toESM2(require("@prisma/debug"));
+var import_node_path = __toESM2(require("node:path"));
+var import_node_process = __toESM2(require("node:process"));
+var import_node_path2 = __toESM2(require("node:path"));
+var import_node_fs = __toESM2(require("node:fs"));
+var import_node_url = require("node:url");
+var import_node_fs2 = __toESM2(require("node:fs"));
+var import_fs2 = __toESM2(require("fs"));
+var import_path4 = __toESM2(require("path"));
+var import_get_platform2 = require("@prisma/get-platform");
+var debug = (0, import_debug2.default)("prisma:format");
+async function formatSchema({ schemas }, inputFormattingOptions) {
+  if (process.env.FORCE_PANIC_PRISMA_SCHEMA) {
+    handleFormatPanic(() => {
+      import_chunk_T5MMBF2S.prismaSchemaWasm.debug_panic();
+    });
+  }
+  const defaultFormattingOptions = {
+    tabSize: 2,
+    insertSpaces: true
+  };
+  const documentFormattingParams = {
+    textDocument: { uri: "file:/dev/null" },
+    options: {
+      ...defaultFormattingOptions,
+      ...inputFormattingOptions
+    }
+  };
+  const { formattedMultipleSchemas, lintDiagnostics } = handleFormatPanic(() => {
+    const formattedMultipleSchemasRaw = formatWasm(JSON.stringify(schemas), documentFormattingParams);
+    const formattedMultipleSchemas2 = JSON.parse(formattedMultipleSchemasRaw);
+    const lintDiagnostics2 = (0, import_chunk_GNKWZC7O.lintSchema)({ schemas: formattedMultipleSchemas2 });
+    return { formattedMultipleSchemas: formattedMultipleSchemas2, lintDiagnostics: lintDiagnostics2 };
+  });
+  const lintWarnings = (0, import_chunk_GNKWZC7O.getLintWarningsAsText)(lintDiagnostics);
+  if (lintWarnings && import_chunk_ZJWZK45Z.logger_exports.should.warn()) {
+    console.warn(lintWarnings);
+  }
+  return Promise.resolve(formattedMultipleSchemas);
+}
+function handleFormatPanic(tryCb) {
+  try {
+    return tryCb();
+  } catch (e) {
+    const { message, stack } = (0, import_chunk_LMVSIVKQ.getWasmError)(e);
+    debug(`Error formatting schema: ${message}`);
+    debug(stack);
+    const panic = new import_chunk_LMVSIVKQ.RustPanic(
+      /* message */
+      message,
+      /* rustStack */
+      stack,
+      /* request */
+      "@prisma/prisma-schema-wasm format",
+      "FMT_CLI"
+      /* FMT_CLI */
+    );
+    throw panic;
+  }
+}
+function formatWasm(schema, documentFormattingParams) {
+  const formattedSchema = import_chunk_T5MMBF2S.prismaSchemaWasm.format(schema, JSON.stringify(documentFormattingParams));
+  return formattedSchema;
+}
+var readFile = (0, import_util.promisify)(import_fs.default.readFile);
+var stat = (0, import_util.promisify)(import_fs.default.stat);
+var debug2 = (0, import_debug.Debug)("prisma:getSchema");
+async function getSchemaWithPath(schemaPathFromArgs, schemaPathFromConfig, { cwd = process.cwd(), argumentName = "--schema" } = {}) {
+  const result = await getSchemaWithPathInternal(schemaPathFromArgs, schemaPathFromConfig, { cwd, argumentName });
+  if (result.ok) {
+    return result.schema;
+  }
+  throw new Error(renderDefaultLookupError(result.error, cwd));
+}
+async function getSchemaWithPathOptional(schemaPathFromArgs, schemaPathFromConfig, { cwd = process.cwd(), argumentName = "--schema" } = {}) {
+  const result = await getSchemaWithPathInternal(schemaPathFromArgs, schemaPathFromConfig, { cwd, argumentName });
+  if (result.ok) {
+    return result.schema;
+  }
+  return null;
+}
+function printSchemaLoadedMessage(schemaPath2) {
+  process.stdout.write((0, import_chunk_PG5FDKSF.dim)(`Prisma schema loaded from ${import_path.default.relative(process.cwd(), schemaPath2)}`) + "\n");
+}
+async function readSchemaFromSingleFile(schemaPath2) {
+  debug2("Reading schema from single file", schemaPath2);
+  const typeError = await (0, import_schema_files_loader.ensureType)(schemaPath2, "file");
+  if (typeError) {
+    return { ok: false, error: typeError };
+  }
+  const file = await readFile(schemaPath2, { encoding: "utf-8" });
+  const schemaTuple = [schemaPath2, file];
+  return {
+    ok: true,
+    schema: { schemaPath: schemaPath2, schemaRootDir: import_path.default.dirname(schemaPath2), schemas: [schemaTuple] }
+  };
+}
+async function readSchemaFromDirectory(schemaPath2) {
+  debug2("Reading schema from multiple files", schemaPath2);
+  const typeError = await (0, import_schema_files_loader.ensureType)(schemaPath2, "directory");
+  if (typeError) {
+    return { ok: false, error: typeError };
+  }
+  const files = await (0, import_schema_files_loader.loadSchemaFiles)(schemaPath2);
+  debug2("Loading config");
+  const config = await (0, import_chunk_CW6KQ3VH.getConfig)({
+    datamodel: files,
+    ignoreEnvVarErrors: true
+  });
+  debug2("Ok");
+  if (!(0, import_schema_files_loader.usesPrismaSchemaFolder)(config)) {
+    return { ok: false, error: { kind: "FolderPreviewNotEnabled", path: schemaPath2 } };
+  }
+  return { ok: true, schema: { schemaPath: schemaPath2, schemaRootDir: schemaPath2, schemas: files } };
+}
+async function readSchemaFromFileOrDirectory(schemaPath2) {
+  let stats;
+  try {
+    stats = await stat(schemaPath2);
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return { ok: false, error: { kind: "NotFound", path: schemaPath2 } };
+    }
+    throw e;
+  }
+  if (stats.isFile()) {
+    return readSchemaFromSingleFile(schemaPath2);
+  }
+  if (stats.isDirectory()) {
+    return readSchemaFromDirectory(schemaPath2);
+  }
+  return { ok: false, error: { kind: "WrongType", path: schemaPath2, expectedTypes: ["file", "directory"] } };
+}
+async function getSchemaWithPathInternal(schemaPathFromArgs, schemaPathFromConfig, { cwd, argumentName }) {
+  if (schemaPathFromArgs) {
+    const absPath = import_path.default.resolve(cwd, schemaPathFromArgs);
+    const customSchemaResult = await readSchemaFromFileOrDirectory(absPath);
+    if (!customSchemaResult.ok) {
+      const relPath = import_path.default.relative(cwd, absPath);
+      throw new Error(
+        `Could not load \`${argumentName}\` from provided path \`${relPath}\`: ${renderLookupError(
+          customSchemaResult.error
+        )}`
+      );
+    }
+    return customSchemaResult;
+  }
+  const prismaConfigResult = await readSchemaFromPrismaConfigBasedLocation(schemaPathFromConfig);
+  if (prismaConfigResult.ok) {
+    return prismaConfigResult;
+  }
+  const pkgJsonResult = await getSchemaFromPackageJson(cwd);
+  if (pkgJsonResult.ok) {
+    return pkgJsonResult;
+  }
+  const defaultResult = await getDefaultSchema(cwd);
+  if (defaultResult.ok) {
+    return defaultResult;
+  }
+  return {
+    ok: false,
+    error: defaultResult.error
+  };
+}
+function renderLookupError(error) {
+  switch (error.kind) {
+    case "NotFound": {
+      const expected = error.expectedType ?? "file or directory";
+      return `${expected} not found`;
+    }
+    case "FolderPreviewNotEnabled":
+      return `"prismaSchemaFolder" preview feature must be enabled`;
+    case "WrongType":
+      return `expected ${error.expectedTypes.join(" or ")}`;
+  }
+}
+function renderDefaultLookupError(error, cwd) {
+  const parts = [
+    `Could not find Prisma Schema that is required for this command.`,
+    `You can either provide it with ${(0, import_chunk_PG5FDKSF.green)("`--schema`")} argument,`,
+    `set it in your ${(0, import_chunk_PG5FDKSF.green)("`prisma.config.ts`")},`,
+    `set it as ${(0, import_chunk_PG5FDKSF.green)("`prisma.schema`")} in your ${(0, import_chunk_PG5FDKSF.green)("package.json")},`,
+    `or put it into the default location (${(0, import_chunk_PG5FDKSF.green)("`./prisma/schema.prisma`")}, or ${(0, import_chunk_PG5FDKSF.green)("`./schema.prisma`")}.`,
+    "Checked following paths:\n"
+  ];
+  const printedPaths = /* @__PURE__ */ new Set();
+  for (const failure of error.failures) {
+    const filePath = failure.path;
+    if (!printedPaths.has(failure.path)) {
+      parts.push(`${import_path.default.relative(cwd, filePath)}: ${renderLookupError(failure.error)}`);
+      printedPaths.add(filePath);
+    }
+  }
+  parts.push("\nSee also https://pris.ly/d/prisma-schema-location");
+  return parts.join("\n");
+}
+async function getPrismaConfigFromPackageJson(cwd) {
+  const pkgJson = await (0, import_chunk_MJIP3FY5.readPackageUp)({ cwd, normalize: false });
+  const prismaPropertyFromPkgJson = pkgJson?.packageJson?.prisma;
+  if (!pkgJson) {
+    return null;
+  }
+  return {
+    data: prismaPropertyFromPkgJson,
+    packagePath: pkgJson.path
+  };
+}
+async function readSchemaFromPrismaConfigBasedLocation(schemaPathFromConfig) {
+  if (!schemaPathFromConfig) {
+    return {
+      ok: false,
+      error: { kind: "PrismaConfigNotConfigured" }
+    };
+  }
+  const schemaResult = await readSchemaFromFileOrDirectory(schemaPathFromConfig);
+  if (!schemaResult.ok) {
+    throw new Error(
+      `Could not load schema from \`${schemaPathFromConfig}\` provided by "prisma.config.ts"\`: ${renderLookupError(
+        schemaResult.error
+      )}`
+    );
+  }
+  return schemaResult;
+}
+async function getSchemaFromPackageJson(cwd) {
+  const prismaConfig = await getPrismaConfigFromPackageJson(cwd);
+  debug2("prismaConfig", prismaConfig);
+  if (!prismaConfig || !prismaConfig.data?.schema) {
+    return { ok: false, error: { kind: "PackageJsonNotConfigured" } };
+  }
+  const schemaPathFromPkgJson = prismaConfig.data.schema;
+  if (typeof schemaPathFromPkgJson !== "string") {
+    throw new Error(
+      `Provided schema path \`${schemaPathFromPkgJson}\` from \`${import_path.default.relative(
+        cwd,
+        prismaConfig.packagePath
+      )}\` must be of type string`
+    );
+  }
+  const absoluteSchemaPath = import_path.default.isAbsolute(schemaPathFromPkgJson) ? schemaPathFromPkgJson : import_path.default.resolve(import_path.default.dirname(prismaConfig.packagePath), schemaPathFromPkgJson);
+  const lookupResult = await readSchemaFromFileOrDirectory(absoluteSchemaPath);
+  if (!lookupResult.ok) {
+    throw new Error(
+      `Could not load schema from \`${import_path.default.relative(
+        cwd,
+        absoluteSchemaPath
+      )}\` provided by "prisma.schema" config of \`${import_path.default.relative(
+        cwd,
+        prismaConfig.packagePath
+      )}\`: ${renderLookupError(lookupResult.error)}`
+    );
+  }
+  return lookupResult;
+}
+async function getDefaultSchema(cwd, failures = []) {
+  const lookupPaths = [import_path.default.join(cwd, "schema.prisma"), import_path.default.join(cwd, "prisma", "schema.prisma")];
+  for (const path7 of lookupPaths) {
+    debug2(`Checking existence of ${path7}`);
+    const schema = await readSchemaFromSingleFile(path7);
+    if (!schema.ok) {
+      failures.push({ path: path7, error: schema.error });
+      continue;
+    }
+    return schema;
+  }
+  return {
+    ok: false,
+    error: {
+      kind: "NotFoundMultipleLocations",
+      failures
+    }
+  };
+}
+async function getProjectHash(schemaPathFromArgs, schemaPathFromConfig) {
+  const projectPath = (await getSchemaWithPath(schemaPathFromArgs, schemaPathFromConfig))?.schemaPath ?? process.cwd();
+  return import_crypto.default.createHash("sha256").update(projectPath).digest("hex").substring(0, 8);
+}
+function getCLIPathHash() {
+  const cliPath = process.argv[1];
+  return import_crypto.default.createHash("sha256").update(cliPath).digest("hex").substring(0, 8);
+}
+async function loadSchemaContext({
+  schemaPathFromArg,
+  schemaPathFromConfig,
+  printLoadMessage = true,
+  ignoreEnvVarErrors = false,
+  allowNull = false,
+  schemaPathArgumentName = "--schema",
+  cwd = process.cwd()
+} = {}) {
+  let schemaResult = null;
+  if (allowNull) {
+    schemaResult = await getSchemaWithPathOptional(schemaPathFromArg, schemaPathFromConfig, {
+      argumentName: schemaPathArgumentName,
+      cwd
+    });
+    if (!schemaResult) return null;
+  } else {
+    schemaResult = await getSchemaWithPath(schemaPathFromArg, schemaPathFromConfig, {
+      argumentName: schemaPathArgumentName,
+      cwd
+    });
+  }
+  return processSchemaResult({ schemaResult, printLoadMessage, ignoreEnvVarErrors, cwd });
+}
+async function processSchemaResult({
+  schemaResult,
+  printLoadMessage = true,
+  ignoreEnvVarErrors = false,
+  cwd = process.cwd()
+}) {
+  const loadedFromPathForLogMessages = import_path2.default.relative(cwd, schemaResult.schemaPath);
+  if (printLoadMessage) {
+    printSchemaLoadedMessage(loadedFromPathForLogMessages);
+  }
+  const configFromPsl = await (0, import_chunk_CW6KQ3VH.getConfig)({ datamodel: schemaResult.schemas, ignoreEnvVarErrors });
+  const primaryDatasource = configFromPsl.datasources.at(0);
+  const schemaRootDir = schemaResult.schemaRootDir || cwd;
+  return {
+    schemaFiles: schemaResult.schemas,
+    schemaPath: schemaResult.schemaPath,
+    schemaRootDir,
+    datasources: configFromPsl.datasources,
+    generators: configFromPsl.generators,
+    primaryDatasource,
+    primaryDatasourceDirectory: primaryDatasourceDirectory(primaryDatasource) || schemaRootDir,
+    warnings: configFromPsl.warnings,
+    loadedFromPathForLogMessages
+  };
+}
+function primaryDatasourceDirectory(primaryDatasource) {
+  const datasourcePath = primaryDatasource?.sourceFilePath;
+  if (datasourcePath) {
+    return import_path2.default.dirname(datasourcePath);
+  }
+  return null;
+}
+var import_p_map = (0, import_chunk_4VNS5WPM.__toESM)((0, import_chunk_MJIP3FY5.require_p_map)());
+var debug3 = (0, import_debug3.default)("prisma:getGenerators");
+async function getGenerators(options) {
+  if (options.registry === void 0 && options.providerAliases !== void 0) {
+    options.registry = Object.fromEntries(
+      Object.entries(options.providerAliases).map(([name, definition]) => [
+        name,
+        {
+          type: "rpc",
+          generatorPath: definition.generatorPath,
+          isNode: definition.isNode
+        }
+      ])
+    );
+  }
+  const {
+    schemaPath,
+    registry,
+    version,
+    printDownloadProgress,
+    overrideGenerators,
+    skipDownload,
+    binaryPathsOverride,
+    generatorNames = [],
+    postinstall,
+    noEngine,
+    allowNoModels,
+    typedSql
+  } = options;
+  const schemaContext = !options.schemaContext && schemaPath ? await loadSchemaContext({ schemaPathFromArg: schemaPath, ignoreEnvVarErrors: true }) : options.schemaContext;
+  if (!schemaContext) {
+    throw new Error(`no schema provided for getGenerators`);
+  }
+  const binaryTarget = await (0, import_get_platform.getBinaryTargetForCurrentPlatform)();
+  const queryEngineBinaryType = (0, import_engines.getCliQueryEngineBinaryType)();
+  const queryEngineType = (0, import_chunk_RS2R7COT.binaryTypeToEngineType)(queryEngineBinaryType);
+  if (version && !binaryPathsOverride?.[queryEngineType]) {
+    const potentialPath = eval(`require('path').join(__dirname, '..')`);
+    if (!potentialPath.match(import_chunk_M3GBKLGE.vercelPkgPathRegex)) {
+      const downloadParams = {
+        binaries: {
+          [queryEngineBinaryType]: potentialPath
+        },
+        binaryTargets: [binaryTarget],
+        showProgress: false,
+        version,
+        skipDownload
+      };
+      await (0, import_fetch_engine.download)(downloadParams);
+    }
+  }
+  if (!schemaContext.primaryDatasource) {
+    throw new Error(import_chunk_AZV6HVKA.missingDatasource);
+  }
+  (0, import_chunk_5FJ3MENK.printConfigWarnings)(schemaContext.warnings);
+  const previewFeatures = (0, import_chunk_CRVLHWC5.extractPreviewFeatures)(schemaContext.generators);
+  const dmmf = await (0, import_chunk_QJ72IP2K.getDMMF)({
+    datamodel: schemaContext.schemaFiles,
+    previewFeatures
+  });
+  if (dmmf.datamodel.models.length === 0 && !allowNoModels) {
+    if (schemaContext.primaryDatasource.provider === "mongodb") {
+      throw new Error(import_chunk_XLTQGAI2.missingModelMessageMongoDB);
+    }
+    throw new Error(import_chunk_XLTQGAI2.missingModelMessage);
+  }
+  const generatorConfigs = filterGenerators(overrideGenerators || schemaContext.generators, generatorNames);
+  await validateGenerators(generatorConfigs);
+  const runningGenerators = [];
+  try {
+    const generators = await (0, import_p_map.default)(
+      generatorConfigs,
+      async (generatorConfig, index) => {
+        const baseDir = import_path3.default.dirname(generatorConfig.sourceFilePath ?? schemaContext.schemaRootDir);
+        const providerValue = (0, import_chunk_IOIAK7V7.parseEnvValue)(generatorConfig.provider);
+        const generatorDefinition = registry[providerValue] ?? {
+          type: "rpc",
+          generatorPath: providerValue
+        };
+        const generatorInstance = (0, import_chunk_XKZ6CBLA.z)(generatorDefinition).with({ type: "in-process" }, ({ generator }) => new import_chunk_BPDMLM32.InProcessGenerator(generatorConfig, generator)).with(
+          { type: "rpc" },
+          ({ generatorPath, isNode }) => new import_chunk_BPDMLM32.JsonRpcGenerator(generatorPath, generatorConfig, isNode)
+        ).exhaustive();
+        await generatorInstance.init();
+        if (generatorConfig.output) {
+          generatorConfig.output = {
+            value: import_path3.default.resolve(baseDir, (0, import_chunk_IOIAK7V7.parseEnvValue)(generatorConfig.output)),
+            fromEnvVar: null
+          };
+          generatorConfig.isCustomOutput = true;
+        } else {
+          if (!generatorInstance.manifest?.defaultOutput) {
+            throw new Error(
+              `Can't resolve output dir for generator ${(0, import_chunk_PG5FDKSF.bold)(generatorConfig.name)} with provider ${(0, import_chunk_PG5FDKSF.bold)(
+                generatorConfig.provider.value
+              )}.
+You need to define \`output\` in the generator block in the schema file.`
+            );
+          }
+          generatorConfig.output = {
+            value: await (0, import_chunk_2B26F5N3.resolveOutput)({
+              defaultOutput: generatorInstance.manifest.defaultOutput,
+              baseDir
+            }),
+            fromEnvVar: null
+          };
+        }
+        const datamodel = (0, import_chunk_TN4KCTWC.mergeSchemas)({ schemas: schemaContext.schemaFiles });
+        const envPaths = await getEnvPaths(schemaContext.schemaPath, { cwd: generatorConfig.output.value });
+        const options2 = {
+          datamodel,
+          datasources: schemaContext.datasources,
+          generator: generatorConfig,
+          dmmf,
+          otherGenerators: skipIndex(generatorConfigs, index),
+          schemaPath: schemaContext.schemaPath,
+          // TODO:(schemaPath) can we get rid of schema path passing here?
+          version: version || import_engines.enginesVersion,
+          // this version makes no sense anymore and should be ignored
+          postinstall,
+          noEngine,
+          allowNoModels,
+          envPaths,
+          typedSql
+        };
+        generatorInstance.setOptions(options2);
+        runningGenerators.push(generatorInstance);
+        return generatorInstance;
+      },
+      {
+        stopOnError: false
+        // needed so we can first make sure all generators are created properly, then cleaned up properly
+      }
+    );
+    const generatorProviders = generatorConfigs.map((g) => (0, import_chunk_IOIAK7V7.parseEnvValue)(g.provider));
+    for (const g of generators) {
+      if (g.manifest && g.manifest.requiresGenerators && g.manifest.requiresGenerators.length > 0) {
+        for (const neededGenerator of g.manifest.requiresGenerators) {
+          if (!generatorProviders.includes(neededGenerator)) {
+            throw new Error(
+              `Generator "${g.manifest.prettyName}" requires generator "${neededGenerator}", but it is missing in your schema.prisma.
+Please add it to your schema.prisma:
+
+generator gen {
+  provider = "${neededGenerator}"
+}
+`
+            );
+          }
+        }
+      }
+    }
+    const neededVersions = /* @__PURE__ */ Object.create(null);
+    for (const g of generators) {
+      if (g.manifest && g.manifest.requiresEngines && Array.isArray(g.manifest.requiresEngines) && g.manifest.requiresEngines.length > 0) {
+        const neededVersion = (0, import_chunk_X3P4J7WW.getEngineVersionForGenerator)(g.manifest, version);
+        if (!neededVersions[neededVersion]) {
+          neededVersions[neededVersion] = { engines: [], binaryTargets: [] };
+        }
+        for (const engine of g.manifest.requiresEngines) {
+          if (!neededVersions[neededVersion].engines.includes(engine)) {
+            neededVersions[neededVersion].engines.push(engine);
+          }
+        }
+        const generatorBinaryTargets = g.options?.generator?.binaryTargets;
+        if (generatorBinaryTargets && generatorBinaryTargets.length > 0) {
+          for (const binaryTarget2 of generatorBinaryTargets) {
+            if (!neededVersions[neededVersion].binaryTargets.find((object) => object.value === binaryTarget2.value)) {
+              neededVersions[neededVersion].binaryTargets.push(binaryTarget2);
+            }
+          }
+        }
+      }
+    }
+    debug3("neededVersions", JSON.stringify(neededVersions, null, 2));
+    const binaryPathsByVersion = await (0, import_chunk_EPXBOIA5.getBinaryPathsByVersion)({
+      neededVersions,
+      binaryTarget,
+      version,
+      printDownloadProgress,
+      skipDownload,
+      binaryPathsOverride
+    });
+    for (const generator of generators) {
+      if (generator.manifest && generator.manifest.requiresEngines) {
+        const engineVersion = (0, import_chunk_X3P4J7WW.getEngineVersionForGenerator)(generator.manifest, version);
+        const binaryPaths = binaryPathsByVersion[engineVersion];
+        const generatorBinaryPaths = (0, import_chunk_5V36RLCO.pick)(binaryPaths, generator.manifest.requiresEngines);
+        debug3({ generatorBinaryPaths });
+        generator.setBinaryPaths(generatorBinaryPaths);
+        if (engineVersion !== version && generator.options && generator.manifest.requiresEngines.includes(queryEngineType) && generatorBinaryPaths[queryEngineType] && generatorBinaryPaths[queryEngineType]?.[binaryTarget]) {
+          const customDmmf = await (0, import_chunk_QJ72IP2K.getDMMF)({
+            datamodel: schemaContext.schemaFiles,
+            previewFeatures
+          });
+          const options2 = { ...generator.options, dmmf: customDmmf };
+          debug3("generator.manifest.prettyName", generator.manifest.prettyName);
+          debug3("options", options2);
+          debug3("options.generator.binaryTargets", options2.generator.binaryTargets);
+          generator.setOptions(options2);
+        }
+      }
+    }
+    return generators;
+  } catch (e) {
+    runningGenerators.forEach((g) => g.stop());
+    throw e;
+  }
+}
+async function getGenerator(options2) {
+  const generators = await getGenerators(options2);
+  return generators[0];
+}
+function skipIndex(arr, index) {
+  return [...arr.slice(0, index), ...arr.slice(index + 1)];
+}
+var knownBinaryTargets = [...import_get_platform.binaryTargets, "native"];
+var oldToNewBinaryTargetsMapping = {
+  "linux-glibc-libssl1.0.1": "debian-openssl-1.0.x",
+  "linux-glibc-libssl1.0.2": "debian-openssl-1.0.x",
+  "linux-glibc-libssl1.1.0": "debian-openssl1.1.x"
+};
+async function validateGenerators(generators) {
+  const binaryTarget2 = await (0, import_get_platform.getBinaryTargetForCurrentPlatform)();
+  for (const generator of generators) {
+    if (generator.config.platforms) {
+      throw new Error(
+        `The \`platforms\` field on the generator definition is deprecated. Please rename it to \`binaryTargets\`.`
+      );
+    }
+    if (generator.config.pinnedBinaryTargets) {
+      throw new Error(
+        `The \`pinnedBinaryTargets\` field on the generator definition is deprecated.
+Please use the PRISMA_QUERY_ENGINE_BINARY env var instead to pin the binary target.`
+      );
+    }
+    if (generator.binaryTargets) {
+      const binaryTargets2 = generator.binaryTargets && generator.binaryTargets.length > 0 ? generator.binaryTargets : [{ fromEnvVar: null, value: "native" }];
+      const resolvedBinaryTargets = binaryTargets2.flatMap((object) => (0, import_chunk_IOIAK7V7.parseBinaryTargetsEnvValue)(object)).map((p) => p === "native" ? binaryTarget2 : p);
+      for (const resolvedBinaryTarget of resolvedBinaryTargets) {
+        if (oldToNewBinaryTargetsMapping[resolvedBinaryTarget]) {
+          throw new Error(
+            `Binary target ${(0, import_chunk_PG5FDKSF.red)((0, import_chunk_PG5FDKSF.bold)(resolvedBinaryTarget))} is deprecated. Please use ${(0, import_chunk_PG5FDKSF.green)(
+              (0, import_chunk_PG5FDKSF.bold)(oldToNewBinaryTargetsMapping[resolvedBinaryTarget])
+            )} instead.`
+          );
+        }
+        if (!knownBinaryTargets.includes(resolvedBinaryTarget)) {
+          throw new Error(
+            `Unknown binary target ${(0, import_chunk_PG5FDKSF.red)(resolvedBinaryTarget)} in generator ${(0, import_chunk_PG5FDKSF.bold)(generator.name)}.
+Possible binaryTargets: ${(0, import_chunk_PG5FDKSF.green)(knownBinaryTargets.join(", "))}`
+          );
+        }
+      }
+      if (!resolvedBinaryTargets.includes(binaryTarget2)) {
+        const originalBinaryTargetsConfig = (0, import_chunk_LRU47BGE.getOriginalBinaryTargetsValue)(generator.binaryTargets);
+        console.log(`${(0, import_chunk_PG5FDKSF.yellow)("Warning:")} Your current platform \`${(0, import_chunk_PG5FDKSF.bold)(
+          binaryTarget2
+        )}\` is not included in your generator's \`binaryTargets\` configuration ${JSON.stringify(
+          originalBinaryTargetsConfig
+        )}.
+To fix it, use this generator config in your ${(0, import_chunk_PG5FDKSF.bold)("schema.prisma")}:
+${(0, import_chunk_PG5FDKSF.green)(
+          (0, import_chunk_LRU47BGE.printGeneratorConfig)({
+            ...generator,
+            binaryTargets: (0, import_chunk_X77CS5RK.fixBinaryTargets)(generator.binaryTargets, binaryTarget2)
+          })
+        )}
+${(0, import_chunk_PG5FDKSF.gray)(
+          `Note, that by providing \`native\`, Prisma Client automatically resolves \`${binaryTarget2}\`.
+Read more about deploying Prisma Client: ${(0, import_chunk_PG5FDKSF.underline)(
+            "https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-schema/generators"
+          )}`
+        )}
+`);
+      }
+    }
+  }
+}
+function filterGenerators(generators, generatorNames2) {
+  if (generatorNames2.length < 1) {
+    return generators;
+  }
+  const filtered = generators.filter((generator) => generatorNames2.includes(generator.name));
+  if (filtered.length !== generatorNames2.length) {
+    const missings = generatorNames2.filter((name) => filtered.find((generator) => generator.name === name) == null);
+    const isSingular = missings.length <= 1;
+    throw new Error(
+      `The ${isSingular ? "generator" : "generators"} ${(0, import_chunk_PG5FDKSF.bold)(missings.join(", "))} specified via ${(0, import_chunk_PG5FDKSF.bold)(
+        "--generator"
+      )} ${isSingular ? "does" : "do"} not exist in your Prisma schema`
+    );
+  }
+  return filtered;
+}
+var typeMappings = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function checkType(type) {
+  if (Object.hasOwnProperty.call(typeMappings, type)) {
+    return;
+  }
+  throw new Error(`Invalid type specified: ${type}`);
+}
+var matchType = (type, stat2) => stat2[typeMappings[type]]();
+var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? (0, import_node_url.fileURLToPath)(urlOrPath) : urlOrPath;
+function locatePathSync(paths, {
+  cwd = import_node_process.default.cwd(),
+  type = "file",
+  allowSymlinks = true
+} = {}) {
+  checkType(type);
+  cwd = toPath2(cwd);
+  const statFunction = allowSymlinks ? import_node_fs.default.statSync : import_node_fs.default.lstatSync;
+  for (const path_ of paths) {
+    try {
+      const stat2 = statFunction(import_node_path2.default.resolve(cwd, path_), {
+        throwIfNoEntry: false
+      });
+      if (!stat2) {
+        continue;
+      }
+      if (matchType(type, stat2)) {
+        return path_;
+      }
+    } catch {
+    }
+  }
+}
+function pathExistsSync(path7) {
+  try {
+    import_node_fs2.default.accessSync(path7);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var findUpStop = Symbol("findUpStop");
+function findUpMultipleSync(name, options2 = {}) {
+  let directory = import_node_path.default.resolve((0, import_chunk_MJIP3FY5.toPath)(options2.cwd) ?? "");
+  const { root } = import_node_path.default.parse(directory);
+  const stopAt = import_node_path.default.resolve(directory, (0, import_chunk_MJIP3FY5.toPath)(options2.stopAt) ?? root);
+  const limit = options2.limit ?? Number.POSITIVE_INFINITY;
+  const paths = [name].flat();
+  const runMatcher = (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePathSync(paths, locateOptions);
+    }
+    const foundPath = name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePathSync([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = runMatcher({ ...options2, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(import_node_path.default.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = import_node_path.default.dirname(directory);
+  }
+  return matches;
+}
+function findUpSync(name, options2 = {}) {
+  const matches = findUpMultipleSync(name, { ...options2, limit: 1 });
+  return matches[0];
+}
+var debug4 = (0, import_debug4.default)("prisma:loadEnv");
+async function getEnvPaths(schemaPath2, opts = { cwd: process.cwd() }) {
+  const rootEnvPath = getProjectRootEnvPath({ cwd: opts.cwd }) ?? null;
+  const schemaEnvPathFromArgs = schemaPathToEnvPath(schemaPath2);
+  const schemaEnvPathFromPkgJson = schemaPathToEnvPath(await readSchemaPathFromPkgJson());
+  const schemaEnvPaths = [
+    schemaEnvPathFromArgs,
+    // 1 - Check --schema directory for .env
+    schemaEnvPathFromPkgJson,
+    // 2 - Check package.json schema directory for .env
+    "./prisma/.env",
+    // 3 - Check ./prisma directory for .env
+    "./.env"
+    // 4 - Check cwd for .env
+  ];
+  const schemaEnvPath = schemaEnvPaths.find(import_chunk_UTJGRVMG.exists);
+  return { rootEnvPath, schemaEnvPath };
+}
+async function readSchemaPathFromPkgJson() {
+  try {
+    const pkgJsonSchema = await getSchemaFromPackageJson(process.cwd());
+    if (pkgJsonSchema.ok) {
+      pkgJsonSchema.schema.schemaPath;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getProjectRootEnvPath(opts) {
+  const pkgJsonPath = findUpSync((dir) => {
+    const pkgPath = import_path4.default.join(dir, "package.json");
+    if (pathExistsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(import_fs2.default.readFileSync(pkgPath, "utf8"));
+        if (pkg["name"] !== ".prisma/client") {
+          debug4(`project root found at ${pkgPath}`);
+          return pkgPath;
+        }
+      } catch (e) {
+        debug4(`skipping package.json at ${pkgPath}`);
+      }
+    }
+    return void 0;
+  }, opts);
+  if (!pkgJsonPath) {
+    return null;
+  }
+  const candidate = import_path4.default.join(import_path4.default.dirname(pkgJsonPath), ".env");
+  if (!import_fs2.default.existsSync(candidate)) {
+    return null;
+  }
+  return candidate;
+}
+function schemaPathToEnvPath(schemaPath2) {
+  if (!schemaPath2) return null;
+  return import_path4.default.join(import_path4.default.dirname(schemaPath2), ".env");
+}
+async function loadEnvFile({
+  schemaPath: schemaPath2,
+  config,
+  printMessage = false
+}) {
+  if (config.loadedFromFile) {
+    process.stdout.write(`Prisma config detected, skipping environment variable loading.
+`);
+    return;
+  }
+  const envPaths = await getEnvPaths(schemaPath2);
+  const envData = (0, import_chunk_UTJGRVMG.tryLoadEnvs)(envPaths, { conflictCheck: "error" });
+  if (printMessage && envData && envData.message) {
+    process.stdout.write(envData.message + "\n");
+  }
+}
+var forbiddenCmdWithDataProxyFlagMessage = (command) => `
+Using an Accelerate URL is not supported for this CLI command ${(0, import_chunk_PG5FDKSF.green)(`prisma ${command}`)} yet.
+Please use a direct connection to your database via the datasource \`directUrl\` setting.
+
+More information about this limitation: ${(0, import_chunk_HAGJ64PM.link)("https://pris.ly/d/accelerate-limitations")}
+`;
+function checkUnsupportedDataProxy({
+  cmd,
+  schemaContext: schemaContext2 = void 0,
+  urls = []
+}) {
+  for (const url2 of urls) {
+    if (url2 && url2.includes("prisma://")) {
+      throw new Error(forbiddenCmdWithDataProxyFlagMessage(cmd));
+    }
+  }
+  if (!schemaContext2?.primaryDatasource) return;
+  const url = (0, import_chunk_CW6KQ3VH.resolveUrl)((0, import_chunk_CW6KQ3VH.getEffectiveUrl)(schemaContext2.primaryDatasource));
+  if (url?.startsWith("prisma://")) {
+    throw new Error(forbiddenCmdWithDataProxyFlagMessage(cmd));
+  }
+}