@prisma/migrate 5.22.0-integration-remove-custom-yarn-logic.1 → 5.22.0-integration-engines-5-22-0-8-integration-itx-refactor-9bb49c906d23e0946061d551777bdac14ae4d17d.2

package/dist/bin.js

@@ -34,7 +34,7 @@ __export(bin_exports, {
 module.exports = __toCommonJS(bin_exports);
 var import_chunk_JZ6FKTWG = require("./chunk-JZ6FKTWG.js");
 var import_chunk_GJN3CSXW = require("./chunk-GJN3CSXW.js");
-var import_chunk_75AMGQ4R = require("./chunk-75AMGQ4R.js");
+var import_chunk_XVL5RF2T = require("./chunk-XVL5RF2T.js");
 var import_chunk_BAVMZZAR = require("./chunk-BAVMZZAR.js");
 var import_chunk_SV5GANSI = require("./chunk-SV5GANSI.js");
 var import_chunk_ZBOJAYON = require("./chunk-ZBOJAYON.js");
@@ -50,20 +50,21 @@ var import_chunk_QBK5XTJE = require("./chunk-QBK5XTJE.js");
 var import_chunk_INC2OACE = require("./chunk-INC2OACE.js");
 var import_chunk_GN5BY5N2 = require("./chunk-GN5BY5N2.js");
 var import_chunk_76XWADEV = require("./chunk-76XWADEV.js");
-var import_chunk_E2XKFV2C = require("./chunk-E2XKFV2C.js");
+var import_chunk_ZLGLVUFD = require("./chunk-ZLGLVUFD.js");
 var import_chunk_CK5VLKFM = require("./chunk-CK5VLKFM.js");
 var import_chunk_UJWMQPUH = require("./chunk-UJWMQPUH.js");
-var import_chunk_O6RO4YUZ = require("./chunk-O6RO4YUZ.js");
+var import_chunk_LLGEQ76N = require("./chunk-LLGEQ76N.js");
 var import_chunk_IFCV5MY4 = require("./chunk-IFCV5MY4.js");
 var import_chunk_SGCF5OHF = require("./chunk-SGCF5OHF.js");
-var import_chunk_YKUZUAXA = require("./chunk-YKUZUAXA.js");
+var import_chunk_EFPE3Q7J = require("./chunk-EFPE3Q7J.js");
 var import_chunk_WOOPRG54 = require("./chunk-WOOPRG54.js");
 var import_chunk_6QFE3AWR = require("./chunk-6QFE3AWR.js");
 var import_chunk_LKTTJWFT = require("./chunk-LKTTJWFT.js");
-var import_chunk_4D5LNZLQ = require("./chunk-4D5LNZLQ.js");
+var import_chunk_YA2IHLWJ = require("./chunk-YA2IHLWJ.js");
 var import_chunk_VWV2NY26 = require("./chunk-VWV2NY26.js");
 var import_chunk_XRTNIFND = require("./chunk-XRTNIFND.js");
 var import_chunk_TKAGMA5K = require("./chunk-TKAGMA5K.js");
+var import_chunk_WIZM7TFT = require("./chunk-WIZM7TFT.js");
 var import_chunk_MWEO3VUS = require("./chunk-MWEO3VUS.js");
 var import_chunk_6C7ESGWY = require("./chunk-6C7ESGWY.js");
 var import_chunk_J46BJQHT = require("./chunk-J46BJQHT.js");
@@ -89,12 +90,12 @@ var require_bin = (0, import_chunk_WWAWV7DQ.__commonJS)({
     (0, import_chunk_ZBOJAYON.init_DbExecute)();
     (0, import_chunk_EXUBPCXZ.init_DbPull)();
     (0, import_chunk_76XWADEV.init_DbPush)();
-    (0, import_chunk_E2XKFV2C.init_DbSeed)();
+    (0, import_chunk_ZLGLVUFD.init_DbSeed)();
     (0, import_chunk_CK5VLKFM.init_MigrateCommand)();
     (0, import_chunk_UJWMQPUH.init_MigrateDeploy)();
-    (0, import_chunk_O6RO4YUZ.init_MigrateDev)();
-    (0, import_chunk_4D5LNZLQ.init_MigrateDiff)();
-    (0, import_chunk_75AMGQ4R.init_MigrateReset)();
+    (0, import_chunk_LLGEQ76N.init_MigrateDev)();
+    (0, import_chunk_YA2IHLWJ.init_MigrateDiff)();
+    (0, import_chunk_XVL5RF2T.init_MigrateReset)();
     (0, import_chunk_BAVMZZAR.init_MigrateResolve)();
     (0, import_chunk_SV5GANSI.init_MigrateStatus)();
     (0, import_chunk_GJN3CSXW.init_getDatabaseVersionSafe)();
@@ -112,19 +113,19 @@ var require_bin = (0, import_chunk_WWAWV7DQ.__commonJS)({
     async function main() {
       const cli = import_chunk_JZ6FKTWG.CLI.new({
         migrate: import_chunk_CK5VLKFM.MigrateCommand.new({
-          dev: import_chunk_O6RO4YUZ.MigrateDev.new(),
+          dev: import_chunk_LLGEQ76N.MigrateDev.new(),
           status: import_chunk_SV5GANSI.MigrateStatus.new(),
           resolve: import_chunk_BAVMZZAR.MigrateResolve.new(),
-          reset: import_chunk_75AMGQ4R.MigrateReset.new(),
+          reset: import_chunk_XVL5RF2T.MigrateReset.new(),
           deploy: import_chunk_UJWMQPUH.MigrateDeploy.new(),
-          diff: import_chunk_4D5LNZLQ.MigrateDiff.new()
+          diff: import_chunk_YA2IHLWJ.MigrateDiff.new()
         }),
         db: import_chunk_NJUAN6V2.DbCommand.new({
           execute: import_chunk_ZBOJAYON.DbExecute.new(),
           pull: import_chunk_EXUBPCXZ.DbPull.new(),
           push: import_chunk_76XWADEV.DbPush.new(),
           // drop: DbDrop.new(),
-          seed: import_chunk_E2XKFV2C.DbSeed.new()
+          seed: import_chunk_ZLGLVUFD.DbSeed.new()
         })
       });
       const result = await cli.parse(commandArray);

package/dist/{chunk-F5EZH7R5.js → chunk-DPSX7IAE.js}

@@ -26,15 +26,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_F5EZH7R5_exports = {};
-__export(chunk_F5EZH7R5_exports, {
+var chunk_DPSX7IAE_exports = {};
+__export(chunk_DPSX7IAE_exports, {
   MigrateDiff: () => MigrateDiff,
   init_MigrateDiff: () => init_MigrateDiff
 });
-module.exports = __toCommonJS(chunk_F5EZH7R5_exports);
+module.exports = __toCommonJS(chunk_DPSX7IAE_exports);
 var import_chunk_VWV2NY26 = require("./chunk-VWV2NY26.js");
 var import_chunk_XRTNIFND = require("./chunk-XRTNIFND.js");
 var import_chunk_TKAGMA5K = require("./chunk-TKAGMA5K.js");
+var import_chunk_WIZM7TFT = require("./chunk-WIZM7TFT.js");
 var import_chunk_MWEO3VUS = require("./chunk-MWEO3VUS.js");
 var import_chunk_LVFPGUOH = require("./chunk-LVFPGUOH.js");
 var import_chunk_6TE2RIPN = require("./chunk-6TE2RIPN.js");
@@ -10838,7 +10839,7 @@ var require_package = (0, import_chunk_WWAWV7DQ.__commonJS)({
         "@prisma/fetch-engine": "workspace:*",
         "@prisma/generator-helper": "workspace:*",
         "@prisma/get-platform": "workspace:*",
-        "@prisma/prisma-schema-wasm": "5.22.0-7.155af6224b4a7a7fe47f2ce6202a785fbc5e1750",
+        "@prisma/prisma-schema-wasm": "5.22.0-8.integration-itx-refactor-9bb49c906d23e0946061d551777bdac14ae4d17d",
         "@prisma/schema-files-loader": "workspace:*",
         arg: "5.0.2",
         prompts: "2.4.2"
@@ -11207,9 +11208,14 @@ async function getSchemaWithPathInternal(schemaPathFromArgs, { cwd, argumentName
   if (defaultResult.ok) {
     return defaultResult;
   }
+  const yarnResult = await getSchemaFromYarn1Workspace(cwd, defaultResult.error.failures);
+  if (yarnResult.ok) {
+    return yarnResult;
+  }
+  const finalError = yarnResult.error.kind === "Yarn1WorkspaceSchemaNotFound" ? defaultResult.error : yarnResult.error;
   return {
     ok: false,
-    error: defaultResult.error
+    error: finalError
   };
 }
 function renderLookupError(error) {
@@ -11284,6 +11290,47 @@ async function getSchemaFromPackageJson(cwd) {
   }
   return lookupResult;
 }
+async function getSchemaFromYarn1Workspace(cwd, pastFailures) {
+  if (!process.env.npm_config_user_agent?.includes("yarn")) {
+    return { ok: false, error: { kind: "Yarn1WorkspaceSchemaNotFound" } };
+  }
+  let workspaces;
+  try {
+    const { stdout: version2 } = await import_execa.default.command("yarn --version", {
+      cwd
+    });
+    if (version2.startsWith("2")) {
+      return { ok: false, error: { kind: "Yarn1WorkspaceSchemaNotFound" } };
+    }
+    const { stdout } = await import_execa.default.command("yarn workspaces info --json", {
+      cwd
+    });
+    const json = getJson(stdout);
+    workspaces = Object.values(json);
+  } catch {
+    return { ok: false, error: { kind: "Yarn1WorkspaceSchemaNotFound" } };
+  }
+  const workspaceRootDir = await findWorkspaceRoot(cwd);
+  if (!workspaceRootDir) {
+    return { ok: false, error: { kind: "Yarn1WorkspaceSchemaNotFound" } };
+  }
+  for (const workspace of workspaces) {
+    const workspacePath = import_path5.default.join(workspaceRootDir, workspace.location);
+    const workspaceSchema = await tryWorkspacePath(workspacePath, pastFailures);
+    if (workspaceSchema.ok) {
+      return workspaceSchema;
+    }
+  }
+  const rootPathSchema = await tryWorkspacePath(workspaceRootDir, pastFailures);
+  return rootPathSchema;
+}
+async function tryWorkspacePath(cwd, pastFailures) {
+  const pkgJson = await getSchemaFromPackageJson(cwd);
+  if (pkgJson.ok) {
+    return pkgJson;
+  }
+  return getDefaultSchema(cwd, pastFailures);
+}
 async function getDefaultSchema(cwd, failures = []) {
   const schemaPrisma = {
     schemaPath: {
@@ -11348,11 +11395,50 @@ async function loadSchemaFromDefaultLocation(lookupPath) {
       return readSchemaFromDirectory(lookupPath.path);
   }
 }
-var import_schema_files_loader, readFile, stat, debug2;
+function getJson(stdout) {
+  const firstCurly = stdout.indexOf("{");
+  const lastCurly = stdout.lastIndexOf("}");
+  const sliced = stdout.slice(firstCurly, lastCurly + 1);
+  return JSON.parse(sliced);
+}
+function isPkgJsonWorkspaceRoot(pkgJson) {
+  const workspaces = pkgJson.workspaces;
+  if (!workspaces) {
+    return false;
+  }
+  return Array.isArray(workspaces) || workspaces.packages !== void 0;
+}
+async function isNearestPkgJsonWorkspaceRoot(cwd) {
+  const pkgJson = await readPackageUp({ cwd, normalize: false });
+  if (!pkgJson) {
+    return null;
+  }
+  return {
+    isRoot: isPkgJsonWorkspaceRoot(pkgJson.packageJson),
+    path: pkgJson.path
+  };
+}
+async function findWorkspaceRoot(cwd) {
+  let pkgJson = await isNearestPkgJsonWorkspaceRoot(cwd);
+  if (!pkgJson) {
+    return null;
+  }
+  if (pkgJson.isRoot === true) {
+    return import_path5.default.dirname(pkgJson.path);
+  }
+  const pkgJsonParentDir = import_path5.default.dirname(import_path5.default.dirname(pkgJson.path));
+  pkgJson = await isNearestPkgJsonWorkspaceRoot(pkgJsonParentDir);
+  if (!pkgJson || pkgJson.isRoot === false) {
+    return null;
+  }
+  return import_path5.default.dirname(pkgJson.path);
+}
+var import_schema_files_loader, import_execa, readFile, stat, debug2;
 var init_getSchema = (0, import_chunk_WWAWV7DQ.__esm)({
   "../internals/src/cli/getSchema.ts"() {
     "use strict";
     import_schema_files_loader = (0, import_chunk_WWAWV7DQ.__toESM)(require_dist());
+    import_execa = (0, import_chunk_WWAWV7DQ.__toESM)((0, import_chunk_WIZM7TFT.require_execa)());
     (0, import_chunk_6TE2RIPN.init_colors)();
     init_read_package_up();
     init_engine_commands();

package/dist/chunk-EFPE3Q7J.js

@@ -0,0 +1,424 @@
+"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);
+var chunk_EFPE3Q7J_exports = {};
+__export(chunk_EFPE3Q7J_exports, {
+  executeSeedCommand: () => executeSeedCommand,
+  getSeedCommandFromPackageJson: () => getSeedCommandFromPackageJson,
+  init_seed: () => init_seed,
+  legacyTsNodeScriptWarning: () => legacyTsNodeScriptWarning,
+  verifySeedConfigAndReturnMessage: () => verifySeedConfigAndReturnMessage
+});
+module.exports = __toCommonJS(chunk_EFPE3Q7J_exports);
+var import_chunk_WIZM7TFT = require("./chunk-WIZM7TFT.js");
+var import_chunk_6TE2RIPN = require("./chunk-6TE2RIPN.js");
+var import_chunk_WWAWV7DQ = require("./chunk-WWAWV7DQ.js");
+var import_debug = __toESM(require("@prisma/debug"));
+var import_internals = require("@prisma/internals");
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var require_has_yarn = (0, import_chunk_WWAWV7DQ.__commonJS)({
+  "../../node_modules/.pnpm/has-yarn@2.1.0/node_modules/has-yarn/index.js"(exports, module2) {
+    "use strict";
+    var path2 = (0, import_chunk_WWAWV7DQ.__require)("path");
+    var fs2 = (0, import_chunk_WWAWV7DQ.__require)("fs");
+    var hasYarn2 = (cwd = process.cwd()) => fs2.existsSync(path2.resolve(cwd, "yarn.lock"));
+    module2.exports = hasYarn2;
+    module2.exports.default = hasYarn2;
+  }
+});
+var require_path_exists = (0, import_chunk_WWAWV7DQ.__commonJS)({
+  "../../node_modules/.pnpm/path-exists@3.0.0/node_modules/path-exists/index.js"(exports, module2) {
+    "use strict";
+    var fs2 = (0, import_chunk_WWAWV7DQ.__require)("fs");
+    module2.exports = (fp) => new Promise((resolve) => {
+      fs2.access(fp, (err) => {
+        resolve(!err);
+      });
+    });
+    module2.exports.sync = (fp) => {
+      try {
+        fs2.accessSync(fp);
+        return true;
+      } catch (err) {
+        return false;
+      }
+    };
+  }
+});
+var require_p_try = (0, import_chunk_WWAWV7DQ.__commonJS)({
+  "../../node_modules/.pnpm/p-try@2.2.0/node_modules/p-try/index.js"(exports, module2) {
+    "use strict";
+    var pTry = (fn, ...arguments_) => new Promise((resolve) => {
+      resolve(fn(...arguments_));
+    });
+    module2.exports = pTry;
+    module2.exports.default = pTry;
+  }
+});
+var require_p_limit = (0, import_chunk_WWAWV7DQ.__commonJS)({
+  "../../node_modules/.pnpm/p-limit@2.3.0/node_modules/p-limit/index.js"(exports, module2) {
+    "use strict";
+    var pTry = require_p_try();
+    var pLimit = (concurrency) => {
+      if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+        return Promise.reject(new TypeError("Expected `concurrency` to be a number from 1 and up"));
+      }
+      const queue = [];
+      let activeCount = 0;
+      const next = () => {
+        activeCount--;
+        if (queue.length > 0) {
+          queue.shift()();
+        }
+      };
+      const run = (fn, resolve, ...args) => {
+        activeCount++;
+        const result = pTry(fn, ...args);
+        resolve(result);
+        result.then(next, next);
+      };
+      const enqueue = (fn, resolve, ...args) => {
+        if (activeCount < concurrency) {
+          run(fn, resolve, ...args);
+        } else {
+          queue.push(run.bind(null, fn, resolve, ...args));
+        }
+      };
+      const generator = (fn, ...args) => new Promise((resolve) => enqueue(fn, resolve, ...args));
+      Object.defineProperties(generator, {
+        activeCount: {
+          get: () => activeCount
+        },
+        pendingCount: {
+          get: () => queue.length
+        },
+        clearQueue: {
+          value: () => {
+            queue.length = 0;
+          }
+        }
+      });
+      return generator;
+    };
+    module2.exports = pLimit;
+    module2.exports.default = pLimit;
+  }
+});
+var require_p_locate = (0, import_chunk_WWAWV7DQ.__commonJS)({
+  "../../node_modules/.pnpm/p-locate@3.0.0/node_modules/p-locate/index.js"(exports, module2) {
+    "use strict";
+    var pLimit = require_p_limit();
+    var EndError = class extends Error {
+      constructor(value) {
+        super();
+        this.value = value;
+      }
+    };
+    var testElement = (el, tester) => Promise.resolve(el).then(tester);
+    var finder = (el) => Promise.all(el).then((val) => val[1] === true && Promise.reject(new EndError(val[0])));
+    module2.exports = (iterable, tester, opts) => {
+      opts = Object.assign({
+        concurrency: Infinity,
+        preserveOrder: true
+      }, opts);
+      const limit = pLimit(opts.concurrency);
+      const items = [...iterable].map((el) => [el, limit(testElement, el, tester)]);
+      const checkLimit = pLimit(opts.preserveOrder ? 1 : Infinity);
+      return Promise.all(items.map((el) => checkLimit(finder, el))).then(() => {
+      }).catch((err) => err instanceof EndError ? err.value : Promise.reject(err));
+    };
+  }
+});
+var require_locate_path = (0, import_chunk_WWAWV7DQ.__commonJS)({
+  "../../node_modules/.pnpm/locate-path@3.0.0/node_modules/locate-path/index.js"(exports, module2) {
+    "use strict";
+    var path2 = (0, import_chunk_WWAWV7DQ.__require)("path");
+    var pathExists = require_path_exists();
+    var pLocate = require_p_locate();
+    module2.exports = (iterable, options) => {
+      options = Object.assign({
+        cwd: process.cwd()
+      }, options);
+      return pLocate(iterable, (el) => pathExists(path2.resolve(options.cwd, el)), options);
+    };
+    module2.exports.sync = (iterable, options) => {
+      options = Object.assign({
+        cwd: process.cwd()
+      }, options);
+      for (const el of iterable) {
+        if (pathExists.sync(path2.resolve(options.cwd, el))) {
+          return el;
+        }
+      }
+    };
+  }
+});
+var require_find_up = (0, import_chunk_WWAWV7DQ.__commonJS)({
+  "../../node_modules/.pnpm/find-up@3.0.0/node_modules/find-up/index.js"(exports, module2) {
+    "use strict";
+    var path2 = (0, import_chunk_WWAWV7DQ.__require)("path");
+    var locatePath = require_locate_path();
+    module2.exports = (filename, opts = {}) => {
+      const startDir = path2.resolve(opts.cwd || "");
+      const { root } = path2.parse(startDir);
+      const filenames = [].concat(filename);
+      return new Promise((resolve) => {
+        (function find(dir) {
+          locatePath(filenames, { cwd: dir }).then((file) => {
+            if (file) {
+              resolve(path2.join(dir, file));
+            } else if (dir === root) {
+              resolve(null);
+            } else {
+              find(path2.dirname(dir));
+            }
+          });
+        })(startDir);
+      });
+    };
+    module2.exports.sync = (filename, opts = {}) => {
+      let dir = path2.resolve(opts.cwd || "");
+      const { root } = path2.parse(dir);
+      const filenames = [].concat(filename);
+      while (true) {
+        const file = locatePath.sync(filenames, { cwd: dir });
+        if (file) {
+          return path2.join(dir, file);
+        }
+        if (dir === root) {
+          return null;
+        }
+        dir = path2.dirname(dir);
+      }
+    };
+  }
+});
+var require_pkg_up = (0, import_chunk_WWAWV7DQ.__commonJS)({
+  "../../node_modules/.pnpm/pkg-up@3.1.0/node_modules/pkg-up/index.js"(exports, module2) {
+    "use strict";
+    var findUp = require_find_up();
+    module2.exports = async ({ cwd } = {}) => findUp("package.json", { cwd });
+    module2.exports.sync = ({ cwd } = {}) => findUp.sync("package.json", { cwd });
+  }
+});
+async function verifySeedConfigAndReturnMessage(schemaPath) {
+  const cwd = process.cwd();
+  const detected = detectSeedFiles(cwd, schemaPath);
+  const prismaConfig = await (0, import_internals.getPrismaConfigFromPackageJson)(cwd);
+  if (prismaConfig && prismaConfig.data?.seed) {
+    return void 0;
+  }
+  const packageManager = (0, import_has_yarn.default)() ? "yarn add -D" : "npm i -D";
+  let message = `${(0, import_chunk_6TE2RIPN.red)(
+    'To configure seeding in your project you need to add a "prisma.seed" property in your package.json with the command to execute it:'
+  )}
+
+1. Open the package.json of your project
+`;
+  if (detected.numberOfSeedFiles) {
+    await legacyTsNodeScriptWarning();
+    message += `2. Add the following example to it:`;
+    if (detected.js) {
+      message += `
+\`\`\`
+"prisma": {
+  "seed": "node ${detected.js}"
+}
+\`\`\`
+`;
+    } else if (detected.ts) {
+      message += `
+\`\`\`
+"prisma": {
+  "seed": "ts-node ${detected.ts}"
+}
+\`\`\`
+If you are using ESM (ECMAScript modules):
+\`\`\`
+"prisma": {
+  "seed": "node --loader ts-node/esm ${detected.ts}"
+}
+\`\`\`
+
+3. Install the required dependencies by running:
+${(0, import_chunk_6TE2RIPN.green)(`${packageManager} ts-node typescript @types/node`)}
+`;
+    } else if (detected.sh) {
+      message += `
+\`\`\`
+"prisma": {
+  "seed": "${detected.sh}"
+}
+\`\`\`
+And run \`chmod +x ${detected.sh}\` to make it executable.`;
+    }
+  } else {
+    message += `2. Add one of the following examples to your package.json:
+
+${(0, import_chunk_6TE2RIPN.bold)("TypeScript:")}
+\`\`\`
+"prisma": {
+  "seed": "ts-node ./prisma/seed.ts"
+}
+\`\`\`
+If you are using ESM (ECMAScript modules):
+\`\`\`
+"prisma": {
+  "seed": "node --loader ts-node/esm ./prisma/seed.ts"
+}
+\`\`\`
+
+And install the required dependencies by running:
+${packageManager} ts-node typescript @types/node
+
+${(0, import_chunk_6TE2RIPN.bold)("JavaScript:")}
+\`\`\`
+"prisma": {
+  "seed": "node ./prisma/seed.js"
+}
+\`\`\`
+
+${(0, import_chunk_6TE2RIPN.bold)("Bash:")}
+\`\`\`
+"prisma": {
+  "seed": "./prisma/seed.sh"
+}
+\`\`\`
+And run \`chmod +x prisma/seed.sh\` to make it executable.`;
+  }
+  message += `
+More information in our documentation:
+${(0, import_internals.link)("https://pris.ly/d/seeding")}`;
+  return message;
+}
+async function getSeedCommandFromPackageJson(cwd) {
+  const prismaConfig = await (0, import_internals.getPrismaConfigFromPackageJson)(cwd);
+  debug({ prismaConfig });
+  if (!prismaConfig || !prismaConfig.data?.seed) {
+    return null;
+  }
+  const seedCommandFromPkgJson = prismaConfig.data.seed;
+  if (typeof seedCommandFromPkgJson !== "string") {
+    throw new Error(
+      `Provided seed command \`${seedCommandFromPkgJson}\` from \`${import_path.default.relative(
+        cwd,
+        prismaConfig.packagePath
+      )}\` must be of type string`
+    );
+  }
+  if (!seedCommandFromPkgJson) {
+    throw new Error(
+      `Provided seed command \`${seedCommandFromPkgJson}\` from \`${import_path.default.relative(
+        cwd,
+        prismaConfig.packagePath
+      )}\` cannot be empty`
+    );
+  }
+  return seedCommandFromPkgJson;
+}
+async function executeSeedCommand({
+  commandFromConfig,
+  extraArgs
+}) {
+  const command = extraArgs ? `${commandFromConfig} ${extraArgs}` : commandFromConfig;
+  process.stdout.write(`Running seed command \`${(0, import_chunk_6TE2RIPN.italic)(command)}\` ...
+`);
+  try {
+    await import_execa.default.command(command, {
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+  } catch (_e) {
+    const e = _e;
+    debug({ e });
+    console.error((0, import_chunk_6TE2RIPN.bold)((0, import_chunk_6TE2RIPN.red)(`
+An error occurred while running the seed command:`)));
+    console.error((0, import_chunk_6TE2RIPN.red)(e.stderr || String(e)));
+    return false;
+  }
+  return true;
+}
+function detectSeedFiles(cwd, schemaPath) {
+  let parentDirectory = import_path.default.relative(cwd, import_path.default.join(cwd, "prisma"));
+  if (schemaPath) {
+    parentDirectory = import_path.default.relative(cwd, import_path.default.dirname(schemaPath));
+  }
+  const seedPath = import_path.default.join(parentDirectory, "seed.");
+  const detected = {
+    seedPath,
+    numberOfSeedFiles: 0,
+    js: "",
+    ts: "",
+    sh: ""
+  };
+  const extensions = ["js", "ts", "sh"];
+  for (const extension of extensions) {
+    const fullPath = seedPath + extension;
+    if (!import_fs.default.existsSync(fullPath)) {
+      continue;
+    }
+    detected[extension] = fullPath;
+    detected.numberOfSeedFiles++;
+  }
+  debug({ detected });
+  return detected;
+}
+async function legacyTsNodeScriptWarning() {
+  const scripts = await getScriptsFromPackageJson();
+  if (scripts?.["ts-node"]) {
+    import_internals.logger.warn(
+      (0, import_chunk_6TE2RIPN.yellow)(`The "ts-node" script in the package.json is not used anymore since version 3.0 and can now be removed.`)
+    );
+  }
+  return void 0;
+}
+async function getScriptsFromPackageJson(cwd = process.cwd()) {
+  try {
+    const pkgJsonPath = await (0, import_pkg_up.default)({ cwd });
+    if (!pkgJsonPath) {
+      return null;
+    }
+    const pkgJsonString = await import_fs.default.promises.readFile(pkgJsonPath, "utf-8");
+    const pkgJson = JSON.parse(pkgJsonString);
+    const { "ts-node": tsnode } = pkgJson.scripts;
+    return { "ts-node": tsnode };
+  } catch {
+    return null;
+  }
+}
+var import_execa, import_has_yarn, import_pkg_up, debug;
+var init_seed = (0, import_chunk_WWAWV7DQ.__esm)({
+  "src/utils/seed.ts"() {
+    import_execa = (0, import_chunk_WWAWV7DQ.__toESM)((0, import_chunk_WIZM7TFT.require_execa)());
+    import_has_yarn = (0, import_chunk_WWAWV7DQ.__toESM)(require_has_yarn());
+    (0, import_chunk_6TE2RIPN.init_colors)();
+    import_pkg_up = (0, import_chunk_WWAWV7DQ.__toESM)(require_pkg_up());
+    debug = (0, import_debug.default)("prisma:migrate:seed");
+  }
+});