@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.
- package/dist/bin.js +13 -14
- package/dist/{chunk-XVL5RF2T.js → chunk-75AMGQ4R.js} +8 -8
- package/dist/{chunk-ZLGLVUFD.js → chunk-E2XKFV2C.js} +8 -8
- package/dist/{chunk-LLGEQ76N.js → chunk-O6RO4YUZ.js} +8 -8
- package/dist/{chunk-IR435FI6.js → chunk-R537DG5M.js} +779 -93
- package/dist/{chunk-WIZM7TFT.js → chunk-YKUZUAXA.js} +443 -55
- package/dist/{chunk-4DKBB75A.js → chunk-YX22UVGD.js} +6 -92
- package/dist/commands/DbSeed.js +4 -5
- package/dist/commands/MigrateDev.js +4 -5
- package/dist/commands/MigrateDiff.js +3 -4
- package/dist/commands/MigrateReset.js +4 -5
- package/dist/index.js +13 -14
- package/dist/internals/src/utils/isCurrentBinInstalledGlobally.d.ts +1 -1
- package/dist/utils/seed.js +6 -7
- package/package.json +5 -6
- package/dist/chunk-EFPE3Q7J.js +0 -424
- package/dist/internals/src/get-generators/generatorResolvers/prisma-client-js/check-dependencies/checkYarnVersion.d.ts +0 -9
@@ -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
|
30
|
-
__export(
|
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(
|
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 =
|
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: "
|
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:
|
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
|
-
|
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();
|