@prisma/migrate 5.23.0-dev.11 → 5.23.0-dev.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -26,16 +26,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
26
26
  mod
27
27
  ));
28
28
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
29
- var chunk_IR435FI6_exports = {};
30
- __export(chunk_IR435FI6_exports, {
29
+ var chunk_R537DG5M_exports = {};
30
+ __export(chunk_R537DG5M_exports, {
31
31
  MigrateDiff: () => MigrateDiff,
32
32
  init_MigrateDiff: () => init_MigrateDiff
33
33
  });
34
- module.exports = __toCommonJS(chunk_IR435FI6_exports);
34
+ module.exports = __toCommonJS(chunk_R537DG5M_exports);
35
35
  var import_chunk_VWV2NY26 = require("./chunk-VWV2NY26.js");
36
36
  var import_chunk_XRTNIFND = require("./chunk-XRTNIFND.js");
37
37
  var import_chunk_TKAGMA5K = require("./chunk-TKAGMA5K.js");
38
- var import_chunk_WIZM7TFT = require("./chunk-WIZM7TFT.js");
39
38
  var import_chunk_MWEO3VUS = require("./chunk-MWEO3VUS.js");
40
39
  var import_chunk_LVFPGUOH = require("./chunk-LVFPGUOH.js");
41
40
  var import_chunk_6TE2RIPN = require("./chunk-6TE2RIPN.js");
@@ -5028,6 +5027,778 @@ var require_ensure = (0, import_chunk_WWAWV7DQ.__commonJS)({
5028
5027
  };
5029
5028
  }
5030
5029
  });
5030
+ var require_polyfills2 = (0, import_chunk_WWAWV7DQ.__commonJS)({
5031
+ "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module2) {
5032
+ "use strict";
5033
+ var constants = (0, import_chunk_WWAWV7DQ.__require)("constants");
5034
+ var origCwd = process.cwd;
5035
+ var cwd = null;
5036
+ var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
5037
+ process.cwd = function() {
5038
+ if (!cwd)
5039
+ cwd = origCwd.call(process);
5040
+ return cwd;
5041
+ };
5042
+ try {
5043
+ process.cwd();
5044
+ } catch (er) {
5045
+ }
5046
+ if (typeof process.chdir === "function") {
5047
+ chdir = process.chdir;
5048
+ process.chdir = function(d) {
5049
+ cwd = null;
5050
+ chdir.call(process, d);
5051
+ };
5052
+ if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
5053
+ }
5054
+ var chdir;
5055
+ module2.exports = patch;
5056
+ function patch(fs3) {
5057
+ if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
5058
+ patchLchmod(fs3);
5059
+ }
5060
+ if (!fs3.lutimes) {
5061
+ patchLutimes(fs3);
5062
+ }
5063
+ fs3.chown = chownFix(fs3.chown);
5064
+ fs3.fchown = chownFix(fs3.fchown);
5065
+ fs3.lchown = chownFix(fs3.lchown);
5066
+ fs3.chmod = chmodFix(fs3.chmod);
5067
+ fs3.fchmod = chmodFix(fs3.fchmod);
5068
+ fs3.lchmod = chmodFix(fs3.lchmod);
5069
+ fs3.chownSync = chownFixSync(fs3.chownSync);
5070
+ fs3.fchownSync = chownFixSync(fs3.fchownSync);
5071
+ fs3.lchownSync = chownFixSync(fs3.lchownSync);
5072
+ fs3.chmodSync = chmodFixSync(fs3.chmodSync);
5073
+ fs3.fchmodSync = chmodFixSync(fs3.fchmodSync);
5074
+ fs3.lchmodSync = chmodFixSync(fs3.lchmodSync);
5075
+ fs3.stat = statFix(fs3.stat);
5076
+ fs3.fstat = statFix(fs3.fstat);
5077
+ fs3.lstat = statFix(fs3.lstat);
5078
+ fs3.statSync = statFixSync(fs3.statSync);
5079
+ fs3.fstatSync = statFixSync(fs3.fstatSync);
5080
+ fs3.lstatSync = statFixSync(fs3.lstatSync);
5081
+ if (fs3.chmod && !fs3.lchmod) {
5082
+ fs3.lchmod = function(path7, mode, cb) {
5083
+ if (cb) process.nextTick(cb);
5084
+ };
5085
+ fs3.lchmodSync = function() {
5086
+ };
5087
+ }
5088
+ if (fs3.chown && !fs3.lchown) {
5089
+ fs3.lchown = function(path7, uid, gid, cb) {
5090
+ if (cb) process.nextTick(cb);
5091
+ };
5092
+ fs3.lchownSync = function() {
5093
+ };
5094
+ }
5095
+ if (platform === "win32") {
5096
+ fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : function(fs$rename) {
5097
+ function rename(from, to, cb) {
5098
+ var start = Date.now();
5099
+ var backoff = 0;
5100
+ fs$rename(from, to, function CB(er) {
5101
+ if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
5102
+ setTimeout(function() {
5103
+ fs3.stat(to, function(stater, st) {
5104
+ if (stater && stater.code === "ENOENT")
5105
+ fs$rename(from, to, CB);
5106
+ else
5107
+ cb(er);
5108
+ });
5109
+ }, backoff);
5110
+ if (backoff < 100)
5111
+ backoff += 10;
5112
+ return;
5113
+ }
5114
+ if (cb) cb(er);
5115
+ });
5116
+ }
5117
+ if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
5118
+ return rename;
5119
+ }(fs3.rename);
5120
+ }
5121
+ fs3.read = typeof fs3.read !== "function" ? fs3.read : function(fs$read) {
5122
+ function read(fd, buffer, offset, length, position, callback_) {
5123
+ var callback;
5124
+ if (callback_ && typeof callback_ === "function") {
5125
+ var eagCounter = 0;
5126
+ callback = function(er, _, __) {
5127
+ if (er && er.code === "EAGAIN" && eagCounter < 10) {
5128
+ eagCounter++;
5129
+ return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
5130
+ }
5131
+ callback_.apply(this, arguments);
5132
+ };
5133
+ }
5134
+ return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
5135
+ }
5136
+ if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
5137
+ return read;
5138
+ }(fs3.read);
5139
+ fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : /* @__PURE__ */ function(fs$readSync) {
5140
+ return function(fd, buffer, offset, length, position) {
5141
+ var eagCounter = 0;
5142
+ while (true) {
5143
+ try {
5144
+ return fs$readSync.call(fs3, fd, buffer, offset, length, position);
5145
+ } catch (er) {
5146
+ if (er.code === "EAGAIN" && eagCounter < 10) {
5147
+ eagCounter++;
5148
+ continue;
5149
+ }
5150
+ throw er;
5151
+ }
5152
+ }
5153
+ };
5154
+ }(fs3.readSync);
5155
+ function patchLchmod(fs4) {
5156
+ fs4.lchmod = function(path7, mode, callback) {
5157
+ fs4.open(
5158
+ path7,
5159
+ constants.O_WRONLY | constants.O_SYMLINK,
5160
+ mode,
5161
+ function(err, fd) {
5162
+ if (err) {
5163
+ if (callback) callback(err);
5164
+ return;
5165
+ }
5166
+ fs4.fchmod(fd, mode, function(err2) {
5167
+ fs4.close(fd, function(err22) {
5168
+ if (callback) callback(err2 || err22);
5169
+ });
5170
+ });
5171
+ }
5172
+ );
5173
+ };
5174
+ fs4.lchmodSync = function(path7, mode) {
5175
+ var fd = fs4.openSync(path7, constants.O_WRONLY | constants.O_SYMLINK, mode);
5176
+ var threw = true;
5177
+ var ret;
5178
+ try {
5179
+ ret = fs4.fchmodSync(fd, mode);
5180
+ threw = false;
5181
+ } finally {
5182
+ if (threw) {
5183
+ try {
5184
+ fs4.closeSync(fd);
5185
+ } catch (er) {
5186
+ }
5187
+ } else {
5188
+ fs4.closeSync(fd);
5189
+ }
5190
+ }
5191
+ return ret;
5192
+ };
5193
+ }
5194
+ function patchLutimes(fs4) {
5195
+ if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
5196
+ fs4.lutimes = function(path7, at, mt, cb) {
5197
+ fs4.open(path7, constants.O_SYMLINK, function(er, fd) {
5198
+ if (er) {
5199
+ if (cb) cb(er);
5200
+ return;
5201
+ }
5202
+ fs4.futimes(fd, at, mt, function(er2) {
5203
+ fs4.close(fd, function(er22) {
5204
+ if (cb) cb(er2 || er22);
5205
+ });
5206
+ });
5207
+ });
5208
+ };
5209
+ fs4.lutimesSync = function(path7, at, mt) {
5210
+ var fd = fs4.openSync(path7, constants.O_SYMLINK);
5211
+ var ret;
5212
+ var threw = true;
5213
+ try {
5214
+ ret = fs4.futimesSync(fd, at, mt);
5215
+ threw = false;
5216
+ } finally {
5217
+ if (threw) {
5218
+ try {
5219
+ fs4.closeSync(fd);
5220
+ } catch (er) {
5221
+ }
5222
+ } else {
5223
+ fs4.closeSync(fd);
5224
+ }
5225
+ }
5226
+ return ret;
5227
+ };
5228
+ } else if (fs4.futimes) {
5229
+ fs4.lutimes = function(_a, _b, _c, cb) {
5230
+ if (cb) process.nextTick(cb);
5231
+ };
5232
+ fs4.lutimesSync = function() {
5233
+ };
5234
+ }
5235
+ }
5236
+ function chmodFix(orig) {
5237
+ if (!orig) return orig;
5238
+ return function(target, mode, cb) {
5239
+ return orig.call(fs3, target, mode, function(er) {
5240
+ if (chownErOk(er)) er = null;
5241
+ if (cb) cb.apply(this, arguments);
5242
+ });
5243
+ };
5244
+ }
5245
+ function chmodFixSync(orig) {
5246
+ if (!orig) return orig;
5247
+ return function(target, mode) {
5248
+ try {
5249
+ return orig.call(fs3, target, mode);
5250
+ } catch (er) {
5251
+ if (!chownErOk(er)) throw er;
5252
+ }
5253
+ };
5254
+ }
5255
+ function chownFix(orig) {
5256
+ if (!orig) return orig;
5257
+ return function(target, uid, gid, cb) {
5258
+ return orig.call(fs3, target, uid, gid, function(er) {
5259
+ if (chownErOk(er)) er = null;
5260
+ if (cb) cb.apply(this, arguments);
5261
+ });
5262
+ };
5263
+ }
5264
+ function chownFixSync(orig) {
5265
+ if (!orig) return orig;
5266
+ return function(target, uid, gid) {
5267
+ try {
5268
+ return orig.call(fs3, target, uid, gid);
5269
+ } catch (er) {
5270
+ if (!chownErOk(er)) throw er;
5271
+ }
5272
+ };
5273
+ }
5274
+ function statFix(orig) {
5275
+ if (!orig) return orig;
5276
+ return function(target, options, cb) {
5277
+ if (typeof options === "function") {
5278
+ cb = options;
5279
+ options = null;
5280
+ }
5281
+ function callback(er, stats) {
5282
+ if (stats) {
5283
+ if (stats.uid < 0) stats.uid += 4294967296;
5284
+ if (stats.gid < 0) stats.gid += 4294967296;
5285
+ }
5286
+ if (cb) cb.apply(this, arguments);
5287
+ }
5288
+ return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
5289
+ };
5290
+ }
5291
+ function statFixSync(orig) {
5292
+ if (!orig) return orig;
5293
+ return function(target, options) {
5294
+ var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
5295
+ if (stats) {
5296
+ if (stats.uid < 0) stats.uid += 4294967296;
5297
+ if (stats.gid < 0) stats.gid += 4294967296;
5298
+ }
5299
+ return stats;
5300
+ };
5301
+ }
5302
+ function chownErOk(er) {
5303
+ if (!er)
5304
+ return true;
5305
+ if (er.code === "ENOSYS")
5306
+ return true;
5307
+ var nonroot = !process.getuid || process.getuid() !== 0;
5308
+ if (nonroot) {
5309
+ if (er.code === "EINVAL" || er.code === "EPERM")
5310
+ return true;
5311
+ }
5312
+ return false;
5313
+ }
5314
+ }
5315
+ }
5316
+ });
5317
+ var require_legacy_streams2 = (0, import_chunk_WWAWV7DQ.__commonJS)({
5318
+ "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
5319
+ "use strict";
5320
+ var Stream = (0, import_chunk_WWAWV7DQ.__require)("stream").Stream;
5321
+ module2.exports = legacy;
5322
+ function legacy(fs3) {
5323
+ return {
5324
+ ReadStream,
5325
+ WriteStream
5326
+ };
5327
+ function ReadStream(path7, options) {
5328
+ if (!(this instanceof ReadStream)) return new ReadStream(path7, options);
5329
+ Stream.call(this);
5330
+ var self = this;
5331
+ this.path = path7;
5332
+ this.fd = null;
5333
+ this.readable = true;
5334
+ this.paused = false;
5335
+ this.flags = "r";
5336
+ this.mode = 438;
5337
+ this.bufferSize = 64 * 1024;
5338
+ options = options || {};
5339
+ var keys = Object.keys(options);
5340
+ for (var index = 0, length = keys.length; index < length; index++) {
5341
+ var key = keys[index];
5342
+ this[key] = options[key];
5343
+ }
5344
+ if (this.encoding) this.setEncoding(this.encoding);
5345
+ if (this.start !== void 0) {
5346
+ if ("number" !== typeof this.start) {
5347
+ throw TypeError("start must be a Number");
5348
+ }
5349
+ if (this.end === void 0) {
5350
+ this.end = Infinity;
5351
+ } else if ("number" !== typeof this.end) {
5352
+ throw TypeError("end must be a Number");
5353
+ }
5354
+ if (this.start > this.end) {
5355
+ throw new Error("start must be <= end");
5356
+ }
5357
+ this.pos = this.start;
5358
+ }
5359
+ if (this.fd !== null) {
5360
+ process.nextTick(function() {
5361
+ self._read();
5362
+ });
5363
+ return;
5364
+ }
5365
+ fs3.open(this.path, this.flags, this.mode, function(err, fd) {
5366
+ if (err) {
5367
+ self.emit("error", err);
5368
+ self.readable = false;
5369
+ return;
5370
+ }
5371
+ self.fd = fd;
5372
+ self.emit("open", fd);
5373
+ self._read();
5374
+ });
5375
+ }
5376
+ function WriteStream(path7, options) {
5377
+ if (!(this instanceof WriteStream)) return new WriteStream(path7, options);
5378
+ Stream.call(this);
5379
+ this.path = path7;
5380
+ this.fd = null;
5381
+ this.writable = true;
5382
+ this.flags = "w";
5383
+ this.encoding = "binary";
5384
+ this.mode = 438;
5385
+ this.bytesWritten = 0;
5386
+ options = options || {};
5387
+ var keys = Object.keys(options);
5388
+ for (var index = 0, length = keys.length; index < length; index++) {
5389
+ var key = keys[index];
5390
+ this[key] = options[key];
5391
+ }
5392
+ if (this.start !== void 0) {
5393
+ if ("number" !== typeof this.start) {
5394
+ throw TypeError("start must be a Number");
5395
+ }
5396
+ if (this.start < 0) {
5397
+ throw new Error("start must be >= zero");
5398
+ }
5399
+ this.pos = this.start;
5400
+ }
5401
+ this.busy = false;
5402
+ this._queue = [];
5403
+ if (this.fd === null) {
5404
+ this._open = fs3.open;
5405
+ this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
5406
+ this.flush();
5407
+ }
5408
+ }
5409
+ }
5410
+ }
5411
+ });
5412
+ var require_clone2 = (0, import_chunk_WWAWV7DQ.__commonJS)({
5413
+ "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports, module2) {
5414
+ "use strict";
5415
+ module2.exports = clone;
5416
+ var getPrototypeOf = Object.getPrototypeOf || function(obj) {
5417
+ return obj.__proto__;
5418
+ };
5419
+ function clone(obj) {
5420
+ if (obj === null || typeof obj !== "object")
5421
+ return obj;
5422
+ if (obj instanceof Object)
5423
+ var copy = { __proto__: getPrototypeOf(obj) };
5424
+ else
5425
+ var copy = /* @__PURE__ */ Object.create(null);
5426
+ Object.getOwnPropertyNames(obj).forEach(function(key) {
5427
+ Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
5428
+ });
5429
+ return copy;
5430
+ }
5431
+ }
5432
+ });
5433
+ var require_graceful_fs2 = (0, import_chunk_WWAWV7DQ.__commonJS)({
5434
+ "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
5435
+ "use strict";
5436
+ var fs3 = (0, import_chunk_WWAWV7DQ.__require)("fs");
5437
+ var polyfills = require_polyfills2();
5438
+ var legacy = require_legacy_streams2();
5439
+ var clone = require_clone2();
5440
+ var util = (0, import_chunk_WWAWV7DQ.__require)("util");
5441
+ var gracefulQueue;
5442
+ var previousSymbol;
5443
+ if (typeof Symbol === "function" && typeof Symbol.for === "function") {
5444
+ gracefulQueue = Symbol.for("graceful-fs.queue");
5445
+ previousSymbol = Symbol.for("graceful-fs.previous");
5446
+ } else {
5447
+ gracefulQueue = "___graceful-fs.queue";
5448
+ previousSymbol = "___graceful-fs.previous";
5449
+ }
5450
+ function noop() {
5451
+ }
5452
+ function publishQueue(context, queue2) {
5453
+ Object.defineProperty(context, gracefulQueue, {
5454
+ get: function() {
5455
+ return queue2;
5456
+ }
5457
+ });
5458
+ }
5459
+ var debug4 = noop;
5460
+ if (util.debuglog)
5461
+ debug4 = util.debuglog("gfs4");
5462
+ else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
5463
+ debug4 = function() {
5464
+ var m = util.format.apply(util, arguments);
5465
+ m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
5466
+ console.error(m);
5467
+ };
5468
+ if (!fs3[gracefulQueue]) {
5469
+ queue = global[gracefulQueue] || [];
5470
+ publishQueue(fs3, queue);
5471
+ fs3.close = function(fs$close) {
5472
+ function close(fd, cb) {
5473
+ return fs$close.call(fs3, fd, function(err) {
5474
+ if (!err) {
5475
+ resetQueue();
5476
+ }
5477
+ if (typeof cb === "function")
5478
+ cb.apply(this, arguments);
5479
+ });
5480
+ }
5481
+ Object.defineProperty(close, previousSymbol, {
5482
+ value: fs$close
5483
+ });
5484
+ return close;
5485
+ }(fs3.close);
5486
+ fs3.closeSync = function(fs$closeSync) {
5487
+ function closeSync(fd) {
5488
+ fs$closeSync.apply(fs3, arguments);
5489
+ resetQueue();
5490
+ }
5491
+ Object.defineProperty(closeSync, previousSymbol, {
5492
+ value: fs$closeSync
5493
+ });
5494
+ return closeSync;
5495
+ }(fs3.closeSync);
5496
+ if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
5497
+ process.on("exit", function() {
5498
+ debug4(fs3[gracefulQueue]);
5499
+ (0, import_chunk_WWAWV7DQ.__require)("assert").equal(fs3[gracefulQueue].length, 0);
5500
+ });
5501
+ }
5502
+ }
5503
+ var queue;
5504
+ if (!global[gracefulQueue]) {
5505
+ publishQueue(global, fs3[gracefulQueue]);
5506
+ }
5507
+ module2.exports = patch(clone(fs3));
5508
+ if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
5509
+ module2.exports = patch(fs3);
5510
+ fs3.__patched = true;
5511
+ }
5512
+ function patch(fs4) {
5513
+ polyfills(fs4);
5514
+ fs4.gracefulify = patch;
5515
+ fs4.createReadStream = createReadStream;
5516
+ fs4.createWriteStream = createWriteStream;
5517
+ var fs$readFile = fs4.readFile;
5518
+ fs4.readFile = readFile2;
5519
+ function readFile2(path7, options, cb) {
5520
+ if (typeof options === "function")
5521
+ cb = options, options = null;
5522
+ return go$readFile(path7, options, cb);
5523
+ function go$readFile(path8, options2, cb2, startTime) {
5524
+ return fs$readFile(path8, options2, function(err) {
5525
+ if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
5526
+ enqueue([go$readFile, [path8, options2, cb2], err, startTime || Date.now(), Date.now()]);
5527
+ else {
5528
+ if (typeof cb2 === "function")
5529
+ cb2.apply(this, arguments);
5530
+ }
5531
+ });
5532
+ }
5533
+ }
5534
+ var fs$writeFile = fs4.writeFile;
5535
+ fs4.writeFile = writeFile;
5536
+ function writeFile(path7, data, options, cb) {
5537
+ if (typeof options === "function")
5538
+ cb = options, options = null;
5539
+ return go$writeFile(path7, data, options, cb);
5540
+ function go$writeFile(path8, data2, options2, cb2, startTime) {
5541
+ return fs$writeFile(path8, data2, options2, function(err) {
5542
+ if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
5543
+ enqueue([go$writeFile, [path8, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
5544
+ else {
5545
+ if (typeof cb2 === "function")
5546
+ cb2.apply(this, arguments);
5547
+ }
5548
+ });
5549
+ }
5550
+ }
5551
+ var fs$appendFile = fs4.appendFile;
5552
+ if (fs$appendFile)
5553
+ fs4.appendFile = appendFile;
5554
+ function appendFile(path7, data, options, cb) {
5555
+ if (typeof options === "function")
5556
+ cb = options, options = null;
5557
+ return go$appendFile(path7, data, options, cb);
5558
+ function go$appendFile(path8, data2, options2, cb2, startTime) {
5559
+ return fs$appendFile(path8, data2, options2, function(err) {
5560
+ if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
5561
+ enqueue([go$appendFile, [path8, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
5562
+ else {
5563
+ if (typeof cb2 === "function")
5564
+ cb2.apply(this, arguments);
5565
+ }
5566
+ });
5567
+ }
5568
+ }
5569
+ var fs$copyFile = fs4.copyFile;
5570
+ if (fs$copyFile)
5571
+ fs4.copyFile = copyFile;
5572
+ function copyFile(src, dest, flags, cb) {
5573
+ if (typeof flags === "function") {
5574
+ cb = flags;
5575
+ flags = 0;
5576
+ }
5577
+ return go$copyFile(src, dest, flags, cb);
5578
+ function go$copyFile(src2, dest2, flags2, cb2, startTime) {
5579
+ return fs$copyFile(src2, dest2, flags2, function(err) {
5580
+ if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
5581
+ enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
5582
+ else {
5583
+ if (typeof cb2 === "function")
5584
+ cb2.apply(this, arguments);
5585
+ }
5586
+ });
5587
+ }
5588
+ }
5589
+ var fs$readdir = fs4.readdir;
5590
+ fs4.readdir = readdir;
5591
+ var noReaddirOptionVersions = /^v[0-5]\./;
5592
+ function readdir(path7, options, cb) {
5593
+ if (typeof options === "function")
5594
+ cb = options, options = null;
5595
+ var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path8, options2, cb2, startTime) {
5596
+ return fs$readdir(path8, fs$readdirCallback(
5597
+ path8,
5598
+ options2,
5599
+ cb2,
5600
+ startTime
5601
+ ));
5602
+ } : function go$readdir2(path8, options2, cb2, startTime) {
5603
+ return fs$readdir(path8, options2, fs$readdirCallback(
5604
+ path8,
5605
+ options2,
5606
+ cb2,
5607
+ startTime
5608
+ ));
5609
+ };
5610
+ return go$readdir(path7, options, cb);
5611
+ function fs$readdirCallback(path8, options2, cb2, startTime) {
5612
+ return function(err, files) {
5613
+ if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
5614
+ enqueue([
5615
+ go$readdir,
5616
+ [path8, options2, cb2],
5617
+ err,
5618
+ startTime || Date.now(),
5619
+ Date.now()
5620
+ ]);
5621
+ else {
5622
+ if (files && files.sort)
5623
+ files.sort();
5624
+ if (typeof cb2 === "function")
5625
+ cb2.call(this, err, files);
5626
+ }
5627
+ };
5628
+ }
5629
+ }
5630
+ if (process.version.substr(0, 4) === "v0.8") {
5631
+ var legStreams = legacy(fs4);
5632
+ ReadStream = legStreams.ReadStream;
5633
+ WriteStream = legStreams.WriteStream;
5634
+ }
5635
+ var fs$ReadStream = fs4.ReadStream;
5636
+ if (fs$ReadStream) {
5637
+ ReadStream.prototype = Object.create(fs$ReadStream.prototype);
5638
+ ReadStream.prototype.open = ReadStream$open;
5639
+ }
5640
+ var fs$WriteStream = fs4.WriteStream;
5641
+ if (fs$WriteStream) {
5642
+ WriteStream.prototype = Object.create(fs$WriteStream.prototype);
5643
+ WriteStream.prototype.open = WriteStream$open;
5644
+ }
5645
+ Object.defineProperty(fs4, "ReadStream", {
5646
+ get: function() {
5647
+ return ReadStream;
5648
+ },
5649
+ set: function(val) {
5650
+ ReadStream = val;
5651
+ },
5652
+ enumerable: true,
5653
+ configurable: true
5654
+ });
5655
+ Object.defineProperty(fs4, "WriteStream", {
5656
+ get: function() {
5657
+ return WriteStream;
5658
+ },
5659
+ set: function(val) {
5660
+ WriteStream = val;
5661
+ },
5662
+ enumerable: true,
5663
+ configurable: true
5664
+ });
5665
+ var FileReadStream = ReadStream;
5666
+ Object.defineProperty(fs4, "FileReadStream", {
5667
+ get: function() {
5668
+ return FileReadStream;
5669
+ },
5670
+ set: function(val) {
5671
+ FileReadStream = val;
5672
+ },
5673
+ enumerable: true,
5674
+ configurable: true
5675
+ });
5676
+ var FileWriteStream = WriteStream;
5677
+ Object.defineProperty(fs4, "FileWriteStream", {
5678
+ get: function() {
5679
+ return FileWriteStream;
5680
+ },
5681
+ set: function(val) {
5682
+ FileWriteStream = val;
5683
+ },
5684
+ enumerable: true,
5685
+ configurable: true
5686
+ });
5687
+ function ReadStream(path7, options) {
5688
+ if (this instanceof ReadStream)
5689
+ return fs$ReadStream.apply(this, arguments), this;
5690
+ else
5691
+ return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
5692
+ }
5693
+ function ReadStream$open() {
5694
+ var that = this;
5695
+ open(that.path, that.flags, that.mode, function(err, fd) {
5696
+ if (err) {
5697
+ if (that.autoClose)
5698
+ that.destroy();
5699
+ that.emit("error", err);
5700
+ } else {
5701
+ that.fd = fd;
5702
+ that.emit("open", fd);
5703
+ that.read();
5704
+ }
5705
+ });
5706
+ }
5707
+ function WriteStream(path7, options) {
5708
+ if (this instanceof WriteStream)
5709
+ return fs$WriteStream.apply(this, arguments), this;
5710
+ else
5711
+ return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
5712
+ }
5713
+ function WriteStream$open() {
5714
+ var that = this;
5715
+ open(that.path, that.flags, that.mode, function(err, fd) {
5716
+ if (err) {
5717
+ that.destroy();
5718
+ that.emit("error", err);
5719
+ } else {
5720
+ that.fd = fd;
5721
+ that.emit("open", fd);
5722
+ }
5723
+ });
5724
+ }
5725
+ function createReadStream(path7, options) {
5726
+ return new fs4.ReadStream(path7, options);
5727
+ }
5728
+ function createWriteStream(path7, options) {
5729
+ return new fs4.WriteStream(path7, options);
5730
+ }
5731
+ var fs$open = fs4.open;
5732
+ fs4.open = open;
5733
+ function open(path7, flags, mode, cb) {
5734
+ if (typeof mode === "function")
5735
+ cb = mode, mode = null;
5736
+ return go$open(path7, flags, mode, cb);
5737
+ function go$open(path8, flags2, mode2, cb2, startTime) {
5738
+ return fs$open(path8, flags2, mode2, function(err, fd) {
5739
+ if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
5740
+ enqueue([go$open, [path8, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
5741
+ else {
5742
+ if (typeof cb2 === "function")
5743
+ cb2.apply(this, arguments);
5744
+ }
5745
+ });
5746
+ }
5747
+ }
5748
+ return fs4;
5749
+ }
5750
+ function enqueue(elem) {
5751
+ debug4("ENQUEUE", elem[0].name, elem[1]);
5752
+ fs3[gracefulQueue].push(elem);
5753
+ retry();
5754
+ }
5755
+ var retryTimer;
5756
+ function resetQueue() {
5757
+ var now = Date.now();
5758
+ for (var i = 0; i < fs3[gracefulQueue].length; ++i) {
5759
+ if (fs3[gracefulQueue][i].length > 2) {
5760
+ fs3[gracefulQueue][i][3] = now;
5761
+ fs3[gracefulQueue][i][4] = now;
5762
+ }
5763
+ }
5764
+ retry();
5765
+ }
5766
+ function retry() {
5767
+ clearTimeout(retryTimer);
5768
+ retryTimer = void 0;
5769
+ if (fs3[gracefulQueue].length === 0)
5770
+ return;
5771
+ var elem = fs3[gracefulQueue].shift();
5772
+ var fn = elem[0];
5773
+ var args = elem[1];
5774
+ var err = elem[2];
5775
+ var startTime = elem[3];
5776
+ var lastTime = elem[4];
5777
+ if (startTime === void 0) {
5778
+ debug4("RETRY", fn.name, args);
5779
+ fn.apply(null, args);
5780
+ } else if (Date.now() - startTime >= 6e4) {
5781
+ debug4("TIMEOUT", fn.name, args);
5782
+ var cb = args.pop();
5783
+ if (typeof cb === "function")
5784
+ cb.call(null, err);
5785
+ } else {
5786
+ var sinceAttempt = Date.now() - lastTime;
5787
+ var sinceStart = Math.max(lastTime - startTime, 1);
5788
+ var desiredDelay = Math.min(sinceStart * 1.2, 100);
5789
+ if (sinceAttempt >= desiredDelay) {
5790
+ debug4("RETRY", fn.name, args);
5791
+ fn.apply(null, args.concat([startTime]));
5792
+ } else {
5793
+ fs3[gracefulQueue].push(elem);
5794
+ }
5795
+ }
5796
+ if (retryTimer === void 0) {
5797
+ retryTimer = setTimeout(retry, 0);
5798
+ }
5799
+ }
5800
+ }
5801
+ });
5031
5802
  var require_utils2 = (0, import_chunk_WWAWV7DQ.__commonJS)({
5032
5803
  "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js"(exports, module2) {
5033
5804
  "use strict";
@@ -5048,7 +5819,7 @@ var require_jsonfile = (0, import_chunk_WWAWV7DQ.__commonJS)({
5048
5819
  "use strict";
5049
5820
  var _fs;
5050
5821
  try {
5051
- _fs = require_graceful_fs();
5822
+ _fs = require_graceful_fs2();
5052
5823
  } catch (_) {
5053
5824
  _fs = (0, import_chunk_WWAWV7DQ.__require)("fs");
5054
5825
  }
@@ -10754,7 +11525,7 @@ var require_package = (0, import_chunk_WWAWV7DQ.__commonJS)({
10754
11525
  "../internals/package.json"(exports, module2) {
10755
11526
  module2.exports = {
10756
11527
  name: "@prisma/internals",
10757
- version: "5.23.0-dev.11",
11528
+ version: "0.0.0",
10758
11529
  description: "This package is intended for Prisma's internal use",
10759
11530
  main: "dist/index.js",
10760
11531
  types: "dist/index.d.ts",
@@ -11208,14 +11979,9 @@ async function getSchemaWithPathInternal(schemaPathFromArgs, { cwd, argumentName
11208
11979
  if (defaultResult.ok) {
11209
11980
  return defaultResult;
11210
11981
  }
11211
- const yarnResult = await getSchemaFromYarn1Workspace(cwd, defaultResult.error.failures);
11212
- if (yarnResult.ok) {
11213
- return yarnResult;
11214
- }
11215
- const finalError = yarnResult.error.kind === "Yarn1WorkspaceSchemaNotFound" ? defaultResult.error : yarnResult.error;
11216
11982
  return {
11217
11983
  ok: false,
11218
- error: finalError
11984
+ error: defaultResult.error
11219
11985
  };
11220
11986
  }
11221
11987
  function renderLookupError(error) {
@@ -11290,47 +12056,6 @@ async function getSchemaFromPackageJson(cwd) {
11290
12056
  }
11291
12057
  return lookupResult;
11292
12058
  }
11293
- async function getSchemaFromYarn1Workspace(cwd, pastFailures) {
11294
- if (!process.env.npm_config_user_agent?.includes("yarn")) {
11295
- return { ok: false, error: { kind: "Yarn1WorkspaceSchemaNotFound" } };
11296
- }
11297
- let workspaces;
11298
- try {
11299
- const { stdout: version2 } = await import_execa.default.command("yarn --version", {
11300
- cwd
11301
- });
11302
- if (version2.startsWith("2")) {
11303
- return { ok: false, error: { kind: "Yarn1WorkspaceSchemaNotFound" } };
11304
- }
11305
- const { stdout } = await import_execa.default.command("yarn workspaces info --json", {
11306
- cwd
11307
- });
11308
- const json = getJson(stdout);
11309
- workspaces = Object.values(json);
11310
- } catch {
11311
- return { ok: false, error: { kind: "Yarn1WorkspaceSchemaNotFound" } };
11312
- }
11313
- const workspaceRootDir = await findWorkspaceRoot(cwd);
11314
- if (!workspaceRootDir) {
11315
- return { ok: false, error: { kind: "Yarn1WorkspaceSchemaNotFound" } };
11316
- }
11317
- for (const workspace of workspaces) {
11318
- const workspacePath = import_path5.default.join(workspaceRootDir, workspace.location);
11319
- const workspaceSchema = await tryWorkspacePath(workspacePath, pastFailures);
11320
- if (workspaceSchema.ok) {
11321
- return workspaceSchema;
11322
- }
11323
- }
11324
- const rootPathSchema = await tryWorkspacePath(workspaceRootDir, pastFailures);
11325
- return rootPathSchema;
11326
- }
11327
- async function tryWorkspacePath(cwd, pastFailures) {
11328
- const pkgJson = await getSchemaFromPackageJson(cwd);
11329
- if (pkgJson.ok) {
11330
- return pkgJson;
11331
- }
11332
- return getDefaultSchema(cwd, pastFailures);
11333
- }
11334
12059
  async function getDefaultSchema(cwd, failures = []) {
11335
12060
  const schemaPrisma = {
11336
12061
  schemaPath: {
@@ -11395,50 +12120,11 @@ async function loadSchemaFromDefaultLocation(lookupPath) {
11395
12120
  return readSchemaFromDirectory(lookupPath.path);
11396
12121
  }
11397
12122
  }
11398
- function getJson(stdout) {
11399
- const firstCurly = stdout.indexOf("{");
11400
- const lastCurly = stdout.lastIndexOf("}");
11401
- const sliced = stdout.slice(firstCurly, lastCurly + 1);
11402
- return JSON.parse(sliced);
11403
- }
11404
- function isPkgJsonWorkspaceRoot(pkgJson) {
11405
- const workspaces = pkgJson.workspaces;
11406
- if (!workspaces) {
11407
- return false;
11408
- }
11409
- return Array.isArray(workspaces) || workspaces.packages !== void 0;
11410
- }
11411
- async function isNearestPkgJsonWorkspaceRoot(cwd) {
11412
- const pkgJson = await readPackageUp({ cwd, normalize: false });
11413
- if (!pkgJson) {
11414
- return null;
11415
- }
11416
- return {
11417
- isRoot: isPkgJsonWorkspaceRoot(pkgJson.packageJson),
11418
- path: pkgJson.path
11419
- };
11420
- }
11421
- async function findWorkspaceRoot(cwd) {
11422
- let pkgJson = await isNearestPkgJsonWorkspaceRoot(cwd);
11423
- if (!pkgJson) {
11424
- return null;
11425
- }
11426
- if (pkgJson.isRoot === true) {
11427
- return import_path5.default.dirname(pkgJson.path);
11428
- }
11429
- const pkgJsonParentDir = import_path5.default.dirname(import_path5.default.dirname(pkgJson.path));
11430
- pkgJson = await isNearestPkgJsonWorkspaceRoot(pkgJsonParentDir);
11431
- if (!pkgJson || pkgJson.isRoot === false) {
11432
- return null;
11433
- }
11434
- return import_path5.default.dirname(pkgJson.path);
11435
- }
11436
- var import_schema_files_loader, import_execa, readFile, stat, debug2;
12123
+ var import_schema_files_loader, readFile, stat, debug2;
11437
12124
  var init_getSchema = (0, import_chunk_WWAWV7DQ.__esm)({
11438
12125
  "../internals/src/cli/getSchema.ts"() {
11439
12126
  "use strict";
11440
12127
  import_schema_files_loader = (0, import_chunk_WWAWV7DQ.__toESM)(require_dist());
11441
- import_execa = (0, import_chunk_WWAWV7DQ.__toESM)((0, import_chunk_WIZM7TFT.require_execa)());
11442
12128
  (0, import_chunk_6TE2RIPN.init_colors)();
11443
12129
  init_read_package_up();
11444
12130
  init_engine_commands();