@prisma/migrate 6.6.0-dev.1 → 6.6.0-dev.100

package/dist/chunk-IK3BVD3Y.js

@@ -0,0 +1,233 @@
+"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_IK3BVD3Y_exports = {};
+__export(chunk_IK3BVD3Y_exports, {
+  SchemaEngineWasm: () => SchemaEngineWasm
+});
+module.exports = __toCommonJS(chunk_IK3BVD3Y_exports);
+var import_chunk_OEWQACEH = require("./chunk-OEWQACEH.js");
+var import_chunk_SKRR5WT4 = require("./chunk-SKRR5WT4.js");
+var import_debug = __toESM(require("@prisma/debug"));
+var import_internals = require("@prisma/internals");
+var SchemaEngineWasm = class _SchemaEngineWasm {
+  engine;
+  // TODO: forward initial schema to the Wasm engine
+  schemaContext;
+  // TODO: forward enabled preview features to the Wasm engine
+  enabledPreviewFeatures;
+  // `isRunning` is set to true when the engine is initialized, and set to false when the engine is stopped
+  isRunning = false;
+  constructor({ debug = false, enabledPreviewFeatures, schemaContext, engine }) {
+    this.schemaContext = schemaContext;
+    this.enabledPreviewFeatures = enabledPreviewFeatures;
+    if (debug) {
+      import_debug.default.enable("SchemaEngine*");
+    }
+    this.engine = engine;
+  }
+  static async setup({ adapter, ...rest }) {
+    const engine = await import_internals.wasmSchemaEngineLoader.loadSchemaEngine(adapter);
+    return new _SchemaEngineWasm({ ...rest, engine });
+  }
+  runCommand(command, input) {
+    this.isRunning = true;
+    try {
+      return this.engine[command](input);
+    } catch (error) {
+      const e = error;
+      console.error("[schema-engine] error on command %s:\n%s", command, e);
+      if ((0, import_internals.isWasmPanic)(e)) {
+        const { message, stack } = (0, import_internals.getWasmError)(e);
+        throw new import_internals.RustPanic(serializePanic(message), stack, command, import_internals.ErrorArea.LIFT_CLI);
+      }
+      throw e;
+    }
+  }
+  /**
+   * Apply the migrations from the migrations directory to the database.
+   * This is the command behind prisma migrate deploy.
+   */
+  applyMigrations(input) {
+    return this.runCommand("applyMigrations", input);
+  }
+  /**
+   * Create the next migration in the migrations history.
+   * If draft is false and there are no unexecutable steps, it will also apply the newly created migration.
+   * Note: This will use the shadow database on the connectors where we need one.
+   */
+  createMigration(input) {
+    return this.runCommand("createMigration", input);
+  }
+  /**
+   * Execute a database script directly on the specified live database.
+   * Note that this may not be defined on all connectors.
+   */
+  async dbExecute(input) {
+    await this.runCommand("dbExecute", input);
+    return null;
+  }
+  /**
+   * Make the Schema engine panic. Only useful to test client error handling.
+   */
+  async debugPanic() {
+    this.runCommand("debugPanic", void 0);
+    return Promise.resolve(null);
+  }
+  /**
+   * The method called at the beginning of migrate dev to decide the course of action,
+   * based on the current state of the workspace.
+   * It acts as a wrapper around diagnoseMigrationHistory.
+   * Its role is to interpret the diagnostic output,
+   * and translate it to a concrete action to be performed by the CLI.
+   */
+  devDiagnostic(input) {
+    return this.runCommand("devDiagnostic", input);
+  }
+  /**
+   * Read the contents of the migrations directory and the migrations table, and returns their relative statuses.
+   * At this stage, the Schema engine only reads,
+   * it does not write to the database nor the migrations directory, nor does it use a shadow database.
+   */
+  diagnoseMigrationHistory(input) {
+    return this.runCommand("diagnoseMigrationHistory", input);
+  }
+  /**
+   * Make sure the Schema engine can connect to the database from the Prisma schema.
+   */
+  async ensureConnectionValidity(input) {
+    await this.runCommand("ensureConnectionValidity", input);
+  }
+  /**
+   * Development command for migrations.
+   * Evaluate the data loss induced by the next migration the engine would generate on the main database.
+   */
+  evaluateDataLoss(input) {
+    return this.runCommand("evaluateDataLoss", input);
+  }
+  /**
+   * Get the database version for error reporting.
+   * If no argument is given, the version of the database associated to the Prisma schema provided
+   * in the constructor will be returned.
+   */
+  getDatabaseVersion(input) {
+    return this.runCommand("version", input);
+  }
+  /**
+   * Given a Prisma schema, introspect the database definitions and update the schema with the results.
+   * `compositeTypeDepth` is optional, and only required for MongoDB.
+   */
+  async introspect({
+    schema,
+    force = false,
+    baseDirectoryPath,
+    viewsDirectoryPath,
+    compositeTypeDepth = -1,
+    namespaces
+  }) {
+    const introspectResult = await this.runCommand("introspect", {
+      schema,
+      force,
+      compositeTypeDepth,
+      namespaces: namespaces ?? null,
+      baseDirectoryPath
+    });
+    const { views } = introspectResult;
+    if (views) {
+      await (0, import_chunk_OEWQACEH.handleViewsIO)({ views, viewsDirectoryPath });
+    }
+    return introspectResult;
+  }
+  /**
+   * Compares two databases schemas from two arbitrary sources,
+   * and display the difference as either a human-readable summary,
+   * or an executable script that can be passed to dbExecute.
+   * Connection to a shadow database is only necessary when either the from or the to params is a migrations directory.
+   * Diffs have a direction. Which source is from and which is to matters.
+   * The resulting diff should be thought of as a migration from the schema in `args.from` to the schema in `args.to`.
+   * By default, we output a human-readable diff. If you want an executable script, pass the "script": true param.
+   */
+  async migrateDiff(input) {
+    const { stdout, ...rest } = await this.runCommand("diff", input);
+    if (stdout) {
+      process.stdout.write(stdout + "\n");
+    }
+    return rest;
+  }
+  /**
+   * Mark a migration as applied in the migrations table.
+   * There are two possible outcomes:
+   * - The migration is already in the table, but in a failed state. In this case, we will mark it as rolled back, then create a new entry.
+   * - The migration is not in the table. We will create a new entry in the migrations table. The started_at and finished_at will be the same.
+   * If it is already applied, we return a user-facing error.
+   */
+  async markMigrationApplied(input) {
+    await this.runCommand("markMigrationApplied", input);
+  }
+  /**
+   * Mark an existing failed migration as rolled back in the migrations table. It will still be there, but ignored for all purposes except as audit trail.
+   */
+  async markMigrationRolledBack(input) {
+    await this.runCommand("markMigrationRolledBack", input);
+  }
+  /**
+   * Try to make the database empty: no data and no schema.
+   * On most connectors, this is implemented by dropping and recreating the database.
+   * If that fails (most likely because of insufficient permissions),
+   * the engine attempts a “best effort reset” by inspecting the contents of the database and dropping them individually.
+   * Drop and recreate the database. The migrations will not be applied, as it would overlap with applyMigrations.
+   */
+  async reset() {
+    await this.runCommand("reset", void 0);
+  }
+  /**
+   * The command behind db push.
+   */
+  schemaPush(input) {
+    return this.runCommand("schemaPush", input);
+  }
+  /**
+   * SQL introspection that powers TypedSQL feature
+   * @param args
+   * @returns
+   */
+  introspectSql(input) {
+    return this.runCommand("introspectSql", input);
+  }
+  /**
+   * Stop the engine.
+   */
+  stop() {
+    this.isRunning = false;
+    this.engine.free();
+  }
+};
+function serializePanic(log) {
+  return `${(0, import_chunk_SKRR5WT4.red)((0, import_chunk_SKRR5WT4.bold)("Error in Schema engine.\nReason: "))}${log}
+`;
+}

package/dist/{chunk-255BRND3.js → chunk-KRQEFTDT.js}

@@ -16,16 +16,16 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_255BRND3_exports = {};
-__export(chunk_255BRND3_exports, {
+var chunk_KRQEFTDT_exports = {};
+__export(chunk_KRQEFTDT_exports, {
   printFiles: () => printFiles,
   printFilesFromMigrationIds: () => printFilesFromMigrationIds
 });
-module.exports = __toCommonJS(chunk_255BRND3_exports);
+module.exports = __toCommonJS(chunk_KRQEFTDT_exports);
 var import_chunk_UP6FVCDK = require("./chunk-UP6FVCDK.js");
-var import_chunk_LKTTJWFT = require("./chunk-LKTTJWFT.js");
-var import_chunk_WWAWV7DQ = require("./chunk-WWAWV7DQ.js");
-var import_indent_string = (0, import_chunk_WWAWV7DQ.__toESM)((0, import_chunk_LKTTJWFT.require_indent_string)());
+var import_chunk_2R6DII47 = require("./chunk-2R6DII47.js");
+var import_chunk_2ESYSVXG = require("./chunk-2ESYSVXG.js");
+var import_indent_string = (0, import_chunk_2ESYSVXG.__toESM)((0, import_chunk_2R6DII47.require_indent_string)());
 function printFiles(printPath, files) {
   const fileNames = Object.keys(files);
   const folders = printPath.split("/");

package/dist/{chunk-EX2UWGES.js → chunk-KW633S3Y.js}

@@ -16,22 +16,53 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_EX2UWGES_exports = {};
-__export(chunk_EX2UWGES_exports, {
+var chunk_KW633S3Y_exports = {};
+__export(chunk_KW633S3Y_exports, {
   MigrateResolve: () => MigrateResolve
 });
-module.exports = __toCommonJS(chunk_EX2UWGES_exports);
-var import_chunk_KXMACMQC = require("./chunk-KXMACMQC.js");
-var import_chunk_GKDFIHM2 = require("./chunk-GKDFIHM2.js");
+module.exports = __toCommonJS(chunk_KW633S3Y_exports);
 var import_chunk_QOPTDDIH = require("./chunk-QOPTDDIH.js");
-var import_chunk_DJMFXNR4 = require("./chunk-DJMFXNR4.js");
+var import_chunk_74LUB4XX = require("./chunk-74LUB4XX.js");
+var import_chunk_YSWLN2IJ = require("./chunk-YSWLN2IJ.js");
 var import_chunk_SKRR5WT4 = require("./chunk-SKRR5WT4.js");
-var import_chunk_WWAWV7DQ = require("./chunk-WWAWV7DQ.js");
 var import_internals = require("@prisma/internals");
-var _MigrateResolve = class _MigrateResolve2 {
+var MigrateResolve = class _MigrateResolve {
   static new() {
-    return new _MigrateResolve2();
+    return new _MigrateResolve();
   }
+  static help = (0, import_internals.format)(`
+Resolve issues with database migrations in deployment databases: 
+- recover from failed migrations
+- baseline databases when starting to use Prisma Migrate on existing databases
+- reconcile hotfixes done manually on databases with your migration history
+
+Run "prisma migrate status" to identify if you need to use resolve.
+
+Read more about resolving migration history issues: ${(0, import_internals.link)("https://pris.ly/d/migrate-resolve")}
+ 
+${(0, import_chunk_SKRR5WT4.bold)("Usage")}
+
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate resolve [options]
+  
+${(0, import_chunk_SKRR5WT4.bold)("Options")}
+
+    -h, --help   Display this help message
+      --config   Custom path to your Prisma config file
+      --schema   Custom path to your Prisma schema
+     --applied   Record a specific migration as applied
+ --rolled-back   Record a specific migration as rolled back
+
+${(0, import_chunk_SKRR5WT4.bold)("Examples")}
+
+  Update migrations table, recording a specific migration as applied 
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate resolve --applied 20201231000000_add_users_table
+
+  Update migrations table, recording a specific migration as rolled back
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate resolve --rolled-back 20201231000000_add_users_table
+
+  Specify a schema
+  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate resolve --rolled-back 20201231000000_add_users_table --schema=./schema.prisma
+`);
   async parse(argv, config) {
     const args = (0, import_internals.arg)(
       argv,
@@ -49,13 +80,17 @@ var _MigrateResolve = class _MigrateResolve2 {
     if ((0, import_internals.isError)(args)) {
       return this.help(args.message);
     }
-    await (0, import_internals.checkUnsupportedDataProxy)("migrate resolve", args, config.schema, true);
     if (args["--help"]) {
       return this.help();
     }
     await (0, import_internals.loadEnvFile)({ schemaPath: args["--schema"], printMessage: true, config });
-    const { schemaPath } = await (0, import_chunk_GKDFIHM2.getSchemaPathAndPrint)(args["--schema"], config.schema);
-    (0, import_chunk_QOPTDDIH.printDatasource)({ datasourceInfo: await (0, import_chunk_DJMFXNR4.getDatasourceInfo)({ schemaPath }) });
+    const schemaContext = await (0, import_internals.loadSchemaContext)({
+      schemaPathFromArg: args["--schema"],
+      schemaPathFromConfig: config.schema
+    });
+    const { migrationsDirPath } = (0, import_internals.inferDirectoryConfig)(schemaContext);
+    (0, import_internals.checkUnsupportedDataProxy)({ cmd: "migrate resolve", schemaContext });
+    (0, import_chunk_QOPTDDIH.printDatasource)({ datasourceInfo: (0, import_chunk_74LUB4XX.parseDatasourceInfo)(schemaContext.primaryDatasource) });
     if (!args["--applied"] && !args["--rolled-back"]) {
       throw new Error(
         `--applied or --rolled-back must be part of the command like:
@@ -73,8 +108,11 @@ ${(0, import_chunk_SKRR5WT4.bold)((0, import_chunk_SKRR5WT4.green)((0, import_in
           )}`
         );
       }
-      await (0, import_chunk_DJMFXNR4.ensureCanConnectToDatabase)(schemaPath);
-      const migrate = new import_chunk_KXMACMQC.Migrate(schemaPath);
+      const adapter = await config.migrate?.adapter(process.env);
+      if (!adapter) {
+        await (0, import_chunk_74LUB4XX.ensureCanConnectToDatabase)(schemaContext.primaryDatasource);
+      }
+      const migrate = await import_chunk_YSWLN2IJ.Migrate.setup({ adapter, migrationsDirPath, schemaContext });
       try {
         await migrate.markMigrationApplied({
           migrationId: args["--applied"]
@@ -94,8 +132,8 @@ Migration ${args["--applied"]} marked as applied.
           )}`
         );
       }
-      await (0, import_chunk_DJMFXNR4.ensureCanConnectToDatabase)(schemaPath);
-      const migrate = new import_chunk_KXMACMQC.Migrate(schemaPath);
+      await (0, import_chunk_74LUB4XX.ensureCanConnectToDatabase)(schemaContext.primaryDatasource);
+      const migrate = await import_chunk_YSWLN2IJ.Migrate.setup({ adapter: void 0, migrationsDirPath, schemaContext });
       try {
         await migrate.markMigrationRolledBack({
           migrationId: args["--rolled-back"]
@@ -113,42 +151,8 @@ Migration ${args["--rolled-back"]} marked as rolled back.
     if (error) {
       return new import_internals.HelpError(`
 ${(0, import_chunk_SKRR5WT4.bold)((0, import_chunk_SKRR5WT4.red)(`!`))} ${error}
-${_MigrateResolve2.help}`);
+${_MigrateResolve.help}`);
     }
-    return _MigrateResolve2.help;
+    return _MigrateResolve.help;
   }
 };
-(0, import_chunk_WWAWV7DQ.__publicField)(_MigrateResolve, "help", (0, import_internals.format)(`
-Resolve issues with database migrations in deployment databases: 
-- recover from failed migrations
-- baseline databases when starting to use Prisma Migrate on existing databases
-- reconcile hotfixes done manually on databases with your migration history
-
-Run "prisma migrate status" to identify if you need to use resolve.
-
-Read more about resolving migration history issues: ${(0, import_internals.link)("https://pris.ly/d/migrate-resolve")}
- 
-${(0, import_chunk_SKRR5WT4.bold)("Usage")}
-
-  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate resolve [options]
-  
-${(0, import_chunk_SKRR5WT4.bold)("Options")}
-
-    -h, --help   Display this help message
-      --config   Custom path to your Prisma config file
-      --schema   Custom path to your Prisma schema
-     --applied   Record a specific migration as applied
- --rolled-back   Record a specific migration as rolled back
-
-${(0, import_chunk_SKRR5WT4.bold)("Examples")}
-
-  Update migrations table, recording a specific migration as applied 
-  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate resolve --applied 20201231000000_add_users_table
-
-  Update migrations table, recording a specific migration as rolled back
-  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate resolve --rolled-back 20201231000000_add_users_table
-
-  Specify a schema
-  ${(0, import_chunk_SKRR5WT4.dim)("$")} prisma migrate resolve --rolled-back 20201231000000_add_users_table --schema=./schema.prisma
-`));
-var MigrateResolve = _MigrateResolve;

package/dist/{chunk-VVKOFN3Y.js → chunk-LLO7YF56.js}

@@ -16,59 +16,21 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_VVKOFN3Y_exports = {};
-__export(chunk_VVKOFN3Y_exports, {
+var chunk_LLO7YF56_exports = {};
+__export(chunk_LLO7YF56_exports, {
   MigrateCommand: () => MigrateCommand
 });
-module.exports = __toCommonJS(chunk_VVKOFN3Y_exports);
+module.exports = __toCommonJS(chunk_LLO7YF56_exports);
 var import_chunk_SKRR5WT4 = require("./chunk-SKRR5WT4.js");
-var import_chunk_WWAWV7DQ = require("./chunk-WWAWV7DQ.js");
 var import_internals = require("@prisma/internals");
-var _MigrateCommand = class _MigrateCommand2 {
+var MigrateCommand = class _MigrateCommand {
   constructor(cmds) {
     this.cmds = cmds;
   }
   static new(cmds) {
-    return new _MigrateCommand2(cmds);
+    return new _MigrateCommand(cmds);
   }
-  async parse(argv, config) {
-    const args = (0, import_internals.arg)(argv, {
-      "--help": Boolean,
-      "-h": "--help",
-      "--config": String,
-      "--preview-feature": Boolean,
-      "--telemetry-information": String
-    });
-    if ((0, import_internals.isError)(args)) {
-      return this.help(args.message);
-    }
-    if (args._.length === 0 || args["--help"]) {
-      return this.help();
-    }
-    const commandName = args._[0];
-    const cmd = this.cmds[commandName];
-    if (cmd) {
-      let argsForCmd;
-      if (commandName === "diff") {
-        argsForCmd = args["--preview-feature"] ? [...args._.slice(1), `--preview-feature`] : args._.slice(1);
-      } else {
-        const filteredArgs = args._.filter((item) => item !== "--preview-feature");
-        argsForCmd = filteredArgs.slice(1);
-      }
-      return cmd.parse(argsForCmd, config);
-    }
-    return (0, import_internals.unknownCommand)(_MigrateCommand2.help, commandName);
-  }
-  help(error) {
-    if (error) {
-      return new import_internals.HelpError(`
-${(0, import_chunk_SKRR5WT4.bold)((0, import_chunk_SKRR5WT4.red)(`!`))} ${error}
-${_MigrateCommand2.help}`);
-    }
-    return _MigrateCommand2.help;
-  }
-};
-(0, import_chunk_WWAWV7DQ.__publicField)(_MigrateCommand, "help", (0, import_internals.format)(`
+  static help = (0, import_internals.format)(`
 Update the database schema with migrations
   
 ${(0, import_chunk_SKRR5WT4.bold)("Usage")}
@@ -119,5 +81,41 @@ ${(0, import_chunk_SKRR5WT4.bold)("Examples")}
     --from-url "$DATABASE_URL" \\
     --to-url "postgresql://login:password@localhost:5432/db" \\
     --script
-`));
-var MigrateCommand = _MigrateCommand;
+`);
+  async parse(argv, config) {
+    const args = (0, import_internals.arg)(argv, {
+      "--help": Boolean,
+      "-h": "--help",
+      "--config": String,
+      "--preview-feature": Boolean,
+      "--telemetry-information": String
+    });
+    if ((0, import_internals.isError)(args)) {
+      return this.help(args.message);
+    }
+    if (args._.length === 0 || args["--help"]) {
+      return this.help();
+    }
+    const commandName = args._[0];
+    const cmd = this.cmds[commandName];
+    if (cmd) {
+      let argsForCmd;
+      if (commandName === "diff") {
+        argsForCmd = args["--preview-feature"] ? [...args._.slice(1), `--preview-feature`] : args._.slice(1);
+      } else {
+        const filteredArgs = args._.filter((item) => item !== "--preview-feature");
+        argsForCmd = filteredArgs.slice(1);
+      }
+      return cmd.parse(argsForCmd, config);
+    }
+    return (0, import_internals.unknownCommand)(_MigrateCommand.help, commandName);
+  }
+  help(error) {
+    if (error) {
+      return new import_internals.HelpError(`
+${(0, import_chunk_SKRR5WT4.bold)((0, import_chunk_SKRR5WT4.red)(`!`))} ${error}
+${_MigrateCommand.help}`);
+    }
+    return _MigrateCommand.help;
+  }
+};

package/dist/{chunk-VZ23KD5C.js → chunk-NGQA5JTN.js}

@@ -16,20 +16,19 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_VZ23KD5C_exports = {};
-__export(chunk_VZ23KD5C_exports, {
+var chunk_NGQA5JTN_exports = {};
+__export(chunk_NGQA5JTN_exports, {
   CLI: () => CLI
 });
-module.exports = __toCommonJS(chunk_VZ23KD5C_exports);
+module.exports = __toCommonJS(chunk_NGQA5JTN_exports);
 var import_chunk_SKRR5WT4 = require("./chunk-SKRR5WT4.js");
-var import_chunk_WWAWV7DQ = require("./chunk-WWAWV7DQ.js");
 var import_internals = require("@prisma/internals");
-var _CLI = class _CLI2 {
+var CLI = class _CLI {
   constructor(cmds) {
     this.cmds = cmds;
   }
   static new(cmds) {
-    return new _CLI2(cmds);
+    return new _CLI(cmds);
   }
   async parse(argv, config) {
     const args = (0, import_internals.arg)(argv, {
@@ -70,10 +69,9 @@ var _CLI = class _CLI2 {
     if (error) {
       return new import_internals.HelpError(`
 ${(0, import_chunk_SKRR5WT4.bold)((0, import_chunk_SKRR5WT4.red)(`!`))} ${error}
-${_CLI2.help}`);
+${_CLI.help}`);
     }
-    return _CLI2.help;
+    return _CLI.help;
   }
+  static help = (0, import_internals.format)(`This is the internal CLI for @prisma/migrate`);
 };
-(0, import_chunk_WWAWV7DQ.__publicField)(_CLI, "help", (0, import_internals.format)(`This is the internal CLI for @prisma/migrate`));
-var CLI = _CLI;