@catladder/cli 0.0.0-main-c5822809 → 0.0.0-main-d184a023

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.
@@ -40112,7 +40112,7 @@ exports.readConfigSync = readConfigSync;
40112
40112
 
40113
40113
  exports.__esModule = true;
40114
40114
  exports.DOCKER_REGISTRY = exports.PIPELINE_IMAGE_TAG = void 0;
40115
- exports.PIPELINE_IMAGE_TAG = "main-c5822809" || 0;
40115
+ exports.PIPELINE_IMAGE_TAG = "main-d184a023" || 0;
40116
40116
  exports.DOCKER_REGISTRY = "git.panter.ch:5001/catladder/catladder" || 0;
40117
40117
 
40118
40118
  /***/ }),
@@ -43011,22 +43011,183 @@ exports.getBaseCommitInfo = getBaseCommitInfo;
43011
43011
 
43012
43012
  /***/ }),
43013
43013
 
43014
- /***/ 8974:
43014
+ /***/ 7052:
43015
43015
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
43016
43016
 
43017
43017
  "use strict";
43018
43018
 
43019
43019
 
43020
- var __assign = this && this.__assign || function () {
43021
- __assign = Object.assign || function (t) {
43022
- for (var s, i = 1, n = arguments.length; i < n; i++) {
43023
- s = arguments[i];
43024
- for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
43020
+ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
43021
+ function adopt(value) {
43022
+ return value instanceof P ? value : new P(function (resolve) {
43023
+ resolve(value);
43024
+ });
43025
+ }
43026
+ return new (P || (P = Promise))(function (resolve, reject) {
43027
+ function fulfilled(value) {
43028
+ try {
43029
+ step(generator.next(value));
43030
+ } catch (e) {
43031
+ reject(e);
43032
+ }
43025
43033
  }
43026
- return t;
43027
- };
43028
- return __assign.apply(this, arguments);
43034
+ function rejected(value) {
43035
+ try {
43036
+ step(generator["throw"](value));
43037
+ } catch (e) {
43038
+ reject(e);
43039
+ }
43040
+ }
43041
+ function step(result) {
43042
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
43043
+ }
43044
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
43045
+ });
43029
43046
  };
43047
+ var __generator = this && this.__generator || function (thisArg, body) {
43048
+ var _ = {
43049
+ label: 0,
43050
+ sent: function () {
43051
+ if (t[0] & 1) throw t[1];
43052
+ return t[1];
43053
+ },
43054
+ trys: [],
43055
+ ops: []
43056
+ },
43057
+ f,
43058
+ y,
43059
+ t,
43060
+ g;
43061
+ return g = {
43062
+ next: verb(0),
43063
+ "throw": verb(1),
43064
+ "return": verb(2)
43065
+ }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
43066
+ return this;
43067
+ }), g;
43068
+ function verb(n) {
43069
+ return function (v) {
43070
+ return step([n, v]);
43071
+ };
43072
+ }
43073
+ function step(op) {
43074
+ if (f) throw new TypeError("Generator is already executing.");
43075
+ while (_) try {
43076
+ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
43077
+ if (y = 0, t) op = [op[0] & 2, t.value];
43078
+ switch (op[0]) {
43079
+ case 0:
43080
+ case 1:
43081
+ t = op;
43082
+ break;
43083
+ case 4:
43084
+ _.label++;
43085
+ return {
43086
+ value: op[1],
43087
+ done: false
43088
+ };
43089
+ case 5:
43090
+ _.label++;
43091
+ y = op[1];
43092
+ op = [0];
43093
+ continue;
43094
+ case 7:
43095
+ op = _.ops.pop();
43096
+ _.trys.pop();
43097
+ continue;
43098
+ default:
43099
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
43100
+ _ = 0;
43101
+ continue;
43102
+ }
43103
+ if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
43104
+ _.label = op[1];
43105
+ break;
43106
+ }
43107
+ if (op[0] === 6 && _.label < t[1]) {
43108
+ _.label = t[1];
43109
+ t = op;
43110
+ break;
43111
+ }
43112
+ if (t && _.label < t[2]) {
43113
+ _.label = t[2];
43114
+ _.ops.push(op);
43115
+ break;
43116
+ }
43117
+ if (t[2]) _.ops.pop();
43118
+ _.trys.pop();
43119
+ continue;
43120
+ }
43121
+ op = body.call(thisArg, _);
43122
+ } catch (e) {
43123
+ op = [6, e];
43124
+ y = 0;
43125
+ } finally {
43126
+ f = t = 0;
43127
+ }
43128
+ if (op[0] & 5) throw op[1];
43129
+ return {
43130
+ value: op[0] ? op[1] : void 0,
43131
+ done: true
43132
+ };
43133
+ }
43134
+ };
43135
+ exports.__esModule = true;
43136
+ exports.createAllJobs = void 0;
43137
+ var config_1 = __nccwpck_require__(3138);
43138
+ var createJobsForComponent_1 = __nccwpck_require__(962);
43139
+ var createAllJobs = function (config, trigger) {
43140
+ return __awaiter(void 0, void 0, void 0, function () {
43141
+ var _a, _b;
43142
+ return __generator(this, function (_c) {
43143
+ switch (_c.label) {
43144
+ case 0:
43145
+ _b = (_a = Object).fromEntries;
43146
+ return [4 /*yield*/, Promise.all(Object.keys(config.components).map(function (componentName) {
43147
+ return __awaiter(void 0, void 0, void 0, function () {
43148
+ var envs, _a, _b, _c;
43149
+ return __generator(this, function (_d) {
43150
+ switch (_d.label) {
43151
+ case 0:
43152
+ envs = (0, config_1.getAllEnvsByTrigger)(config, componentName, trigger);
43153
+ _a = [componentName];
43154
+ _c = (_b = Object).fromEntries;
43155
+ return [4 /*yield*/, Promise.all(envs.map(function (env) {
43156
+ return __awaiter(void 0, void 0, void 0, function () {
43157
+ var _a;
43158
+ return __generator(this, function (_b) {
43159
+ switch (_b.label) {
43160
+ case 0:
43161
+ _a = [env];
43162
+ return [4 /*yield*/, (0, createJobsForComponent_1.createJobsForComponent)(config, componentName, env, trigger)];
43163
+ case 1:
43164
+ return [2 /*return*/, _a.concat([_b.sent()])];
43165
+ }
43166
+ });
43167
+ });
43168
+ }))];
43169
+ case 1:
43170
+ return [2 /*return*/, _a.concat([_c.apply(_b, [_d.sent()])])];
43171
+ }
43172
+ });
43173
+ });
43174
+ }))];
43175
+ case 1:
43176
+ return [2 /*return*/, _b.apply(_a, [_c.sent()])];
43177
+ }
43178
+ });
43179
+ });
43180
+ };
43181
+ exports.createAllJobs = createAllJobs;
43182
+
43183
+ /***/ }),
43184
+
43185
+ /***/ 8974:
43186
+ /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
43187
+
43188
+ "use strict";
43189
+
43190
+
43030
43191
  var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
43031
43192
  function adopt(value) {
43032
43193
  return value instanceof P ? value : new P(function (resolve) {
@@ -43179,54 +43340,40 @@ var config_1 = __nccwpck_require__(3138);
43179
43340
  var rules_1 = __nccwpck_require__(2020);
43180
43341
  var runner_1 = __nccwpck_require__(5071);
43181
43342
  var jobs_1 = __nccwpck_require__(2339);
43182
- var createJobs_1 = __nccwpck_require__(7726);
43343
+ var createAllJobs_1 = __nccwpck_require__(7052);
43344
+ var createGitlabJobs_1 = __nccwpck_require__(3920);
43183
43345
  var createChildPipeline = function (type, trigger, config) {
43184
43346
  return __awaiter(void 0, void 0, void 0, function () {
43185
- var components, jobs, allEnvs, stages, pipeline;
43186
- return __generator(this, function (_a) {
43187
- switch (_a.label) {
43347
+ var jobs, allEnvs, stages, pipeline;
43348
+ var _a;
43349
+ return __generator(this, function (_b) {
43350
+ switch (_b.label) {
43188
43351
  case 0:
43189
- components = Object.keys(config.components);
43190
- return [4 /*yield*/, components.reduce(function (acc, componentName) {
43191
- return __awaiter(void 0, void 0, void 0, function () {
43192
- var envs, _a, _b;
43193
- return __generator(this, function (_c) {
43194
- switch (_c.label) {
43195
- case 0:
43196
- envs = (0, config_1.getAllEnvsByTrigger)(config, componentName, trigger);
43197
- _a = [{}];
43198
- return [4 /*yield*/, acc];
43199
- case 1:
43200
- _b = [__assign.apply(void 0, _a.concat([_c.sent()]))];
43201
- return [4 /*yield*/, (0, createJobs_1.createJobs)(type, envs, config, componentName, trigger)];
43202
- case 2:
43203
- return [2 /*return*/, __assign.apply(void 0, _b.concat([_c.sent()]))];
43204
- }
43205
- });
43206
- });
43207
- }, Promise.resolve({}))];
43352
+ return [4 /*yield*/, (0, createAllJobs_1.createAllJobs)(config, trigger)];
43208
43353
  case 1:
43209
- jobs = _a.sent();
43354
+ jobs = _b.sent();
43210
43355
  allEnvs = (0, config_1.getAllEnvsInAllComponents)(config);
43211
43356
  stages = jobs_1.BASE_STAGES.reduce(function (acc, baseStage) {
43212
43357
  return __spreadArray(__spreadArray(__spreadArray([], __read(acc), false), [baseStage], false), __read(allEnvs.map(function (e) {
43213
43358
  return "".concat(baseStage, " ").concat(e);
43214
43359
  })), false);
43215
43360
  }, []);
43216
- if (type === "gitlab") {
43217
- pipeline = {
43218
- image: (0, runner_1.getRunnerImage)("jobs-default"),
43219
- variables: {
43220
- FF_USE_FASTZIP: "true"
43221
- },
43222
- workflow: {
43223
- rules: rules_1.RULES_ALWAYS
43224
- },
43225
- stages: stages,
43226
- jobs: jobs
43227
- };
43228
- return [2 /*return*/, pipeline];
43229
- }
43361
+ if (!(type === "gitlab")) return [3 /*break*/, 3];
43362
+ _a = {
43363
+ image: (0, runner_1.getRunnerImage)("jobs-default"),
43364
+ variables: {
43365
+ FF_USE_FASTZIP: "true"
43366
+ },
43367
+ workflow: {
43368
+ rules: rules_1.RULES_ALWAYS
43369
+ },
43370
+ stages: stages
43371
+ };
43372
+ return [4 /*yield*/, (0, createGitlabJobs_1.createGitlabJobs)(jobs)];
43373
+ case 2:
43374
+ pipeline = (_a.jobs = _b.sent(), _a);
43375
+ return [2 /*return*/, pipeline];
43376
+ case 3:
43230
43377
  throw new Error("".concat(type, " is not supported"));
43231
43378
  }
43232
43379
  });
@@ -43236,7 +43383,7 @@ exports.createChildPipeline = createChildPipeline;
43236
43383
 
43237
43384
  /***/ }),
43238
43385
 
43239
- /***/ 7726:
43386
+ /***/ 962:
43240
43387
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
43241
43388
 
43242
43389
  "use strict";
@@ -43407,14 +43554,12 @@ var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
43407
43554
  return to.concat(ar || Array.prototype.slice.call(from));
43408
43555
  };
43409
43556
  exports.__esModule = true;
43410
- exports.createJobs = void 0;
43557
+ exports.createJobsForComponent = void 0;
43411
43558
  var lodash_1 = __nccwpck_require__(3255);
43412
43559
  var build_1 = __nccwpck_require__(3760);
43413
43560
  var context_1 = __nccwpck_require__(2041);
43414
43561
  var deploy_1 = __nccwpck_require__(223);
43415
- var utils_1 = __nccwpck_require__(7461);
43416
43562
  var getCommitInfo_1 = __nccwpck_require__(5923);
43417
- var makeGitlabJob_1 = __nccwpck_require__(5715);
43418
43563
  var packageManager_1 = __nccwpck_require__(9168);
43419
43564
  var injectDefaultVarsInCustomJobs = function (context, jobs) {
43420
43565
  return jobs.map(function (_a) {
@@ -43442,71 +43587,9 @@ var createRawJobs = function (context) {
43442
43587
  var customJobs = getCustomJobs(context);
43443
43588
  return __spreadArray(__spreadArray(__spreadArray([], __read(buildJobs), false), __read(deployJobs), false), __read(customJobs), false);
43444
43589
  };
43445
- var getFullJobName = function (name, componentName, env) {
43446
- if (env) {
43447
- return "".concat(componentName, " ").concat(name, " | ").concat(env, " ");
43448
- }
43449
- return "".concat(componentName, " ").concat(name);
43450
- };
43451
- var getFullReferencedJobName = function (referencedJobName, componentName, env, allRawJobs) {
43452
- var referencedJob = allRawJobs.find(function (j) {
43453
- return j.name === referencedJobName;
43454
- });
43455
- if (!referencedJob) {
43456
- throw new Error("unknown job referenced: " + referencedJobName);
43457
- }
43458
- var envToSet = referencedJob.envMode !== "none" ? env : null;
43459
- return getFullJobName(referencedJobName, componentName, envToSet);
43460
- };
43461
- // replaces references to other jobs with the full name
43462
- // the full name contains the componentname and the env name (if any)
43463
- var replaceReferences = function (job, componentName, env, allRawJobs) {
43464
- var _a, _b, _c;
43465
- var stage = job.envMode === "stagePerEnv" ? "".concat(job.stage, " ").concat(env) : job.stage;
43466
- var cleanedNeeds = __spreadArray(__spreadArray([], __read((_a = job.needs) !== null && _a !== void 0 ? _a : []), false), __read((_b = job.needsOtherComponent) !== null && _b !== void 0 ? _b : []), false);
43467
- var needs = cleanedNeeds === null || cleanedNeeds === void 0 ? void 0 : cleanedNeeds.map(function (n) {
43468
- var _a;
43469
- return (0, lodash_1.isObject)(n) ? {
43470
- job: getFullReferencedJobName(n.job, (_a = n.componentName) !== null && _a !== void 0 ? _a : componentName, env, allRawJobs),
43471
- artifacts: n.artifacts
43472
- } : getFullReferencedJobName(n, componentName, env, allRawJobs);
43473
- });
43474
- return __assign(__assign({}, job), {
43475
- stage: stage,
43476
- needs: needs,
43477
- environment: ((_c = job.environment) === null || _c === void 0 ? void 0 : _c.on_stop) ? __assign(__assign({}, job.environment), {
43478
- on_stop: getFullReferencedJobName(job.environment.on_stop, componentName, env, allRawJobs)
43479
- }) : job.environment
43480
- });
43481
- };
43482
- // this can be removed once https://gitlab.com/gitlab-org/gitlab/-/issues/220758 is resolved
43483
- var addStageNeeds = function (jobs) {
43484
- // when a job defines needsStages, we add these as needs
43485
- return jobs.map(function (job) {
43486
- var _a;
43487
- if (!job.needsStages || job.needsStages.length === 0) {
43488
- return job;
43489
- }
43490
- var neededJobs = jobs.map(function (j) {
43491
- var _a, _b;
43492
- var neededStage = (_a = job.needsStages) === null || _a === void 0 ? void 0 : _a.find(function (s) {
43493
- return j.stage === s.stage;
43494
- });
43495
- if (neededStage) {
43496
- return {
43497
- job: j.name,
43498
- artifacts: (_b = neededStage.artifacts) !== null && _b !== void 0 ? _b : false
43499
- };
43500
- }
43501
- }).filter(utils_1.notNil);
43502
- return __assign(__assign({}, job), {
43503
- needs: __spreadArray(__spreadArray([], __read((_a = job.needs) !== null && _a !== void 0 ? _a : []), false), __read(neededJobs), false)
43504
- });
43505
- });
43506
- };
43507
- var createJobs = function (type, envs, config, componentName, trigger) {
43590
+ var createJobsForComponent = function (config, componentName, env, trigger) {
43508
43591
  return __awaiter(void 0, void 0, void 0, function () {
43509
- var commitInfo, _a, packageManagerInfo;
43592
+ var commitInfo, _a, packageManagerInfo, context;
43510
43593
  return __generator(this, function (_b) {
43511
43594
  switch (_b.label) {
43512
43595
  case 0:
@@ -43519,47 +43602,19 @@ var createJobs = function (type, envs, config, componentName, trigger) {
43519
43602
  return [4 /*yield*/, (0, packageManager_1.getPackageManagerInfo)(config, componentName)];
43520
43603
  case 2:
43521
43604
  packageManagerInfo = _b.sent();
43522
- return [2 /*return*/, envs.reduce(function (acc, env) {
43523
- return __awaiter(void 0, void 0, void 0, function () {
43524
- var context, jobs, result, _a, _b, _c, _d, _e;
43525
- return __generator(this, function (_f) {
43526
- switch (_f.label) {
43527
- case 0:
43528
- return [4 /*yield*/, (0, context_1.createContext)(config, componentName, env, commitInfo, packageManagerInfo)];
43529
- case 1:
43530
- context = _f.sent();
43531
- jobs = addStageNeeds(createRawJobs(context));
43532
- _a = [{}];
43533
- return [4 /*yield*/, acc];
43534
- case 2:
43535
- _b = [__assign.apply(void 0, _a.concat([_f.sent()]))];
43536
- _d = (_c = jobs).reduce;
43537
- _e = [function (acc, job) {
43538
- var _a;
43539
- var jobWithResolvedReferences = replaceReferences(job, componentName, env, jobs);
43540
- var jobName = getFullJobName(job.name, componentName, job.envMode !== "none" ? env : undefined);
43541
- if (type === "gitlab") {
43542
- return __assign(__assign({}, acc), (_a = {}, _a[jobName] = (0, makeGitlabJob_1.makeGitlabJob)(jobWithResolvedReferences), _a));
43543
- }
43544
- throw new Error("not supported");
43545
- }];
43546
- return [4 /*yield*/, Promise.resolve({})];
43547
- case 3:
43548
- result = __assign.apply(void 0, _b.concat([_d.apply(_c, _e.concat([_f.sent()]))]));
43549
- return [2 /*return*/, result];
43550
- }
43551
- });
43552
- });
43553
- }, {})];
43605
+ return [4 /*yield*/, (0, context_1.createContext)(config, componentName, env, commitInfo, packageManagerInfo)];
43606
+ case 3:
43607
+ context = _b.sent();
43608
+ return [2 /*return*/, createRawJobs(context)];
43554
43609
  }
43555
43610
  });
43556
43611
  });
43557
43612
  };
43558
- exports.createJobs = createJobs;
43613
+ exports.createJobsForComponent = createJobsForComponent;
43559
43614
 
43560
43615
  /***/ }),
43561
43616
 
43562
- /***/ 5715:
43617
+ /***/ 3920:
43563
43618
  /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
43564
43619
 
43565
43620
  "use strict";
@@ -43575,6 +43630,121 @@ var __assign = this && this.__assign || function () {
43575
43630
  };
43576
43631
  return __assign.apply(this, arguments);
43577
43632
  };
43633
+ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
43634
+ function adopt(value) {
43635
+ return value instanceof P ? value : new P(function (resolve) {
43636
+ resolve(value);
43637
+ });
43638
+ }
43639
+ return new (P || (P = Promise))(function (resolve, reject) {
43640
+ function fulfilled(value) {
43641
+ try {
43642
+ step(generator.next(value));
43643
+ } catch (e) {
43644
+ reject(e);
43645
+ }
43646
+ }
43647
+ function rejected(value) {
43648
+ try {
43649
+ step(generator["throw"](value));
43650
+ } catch (e) {
43651
+ reject(e);
43652
+ }
43653
+ }
43654
+ function step(result) {
43655
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
43656
+ }
43657
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
43658
+ });
43659
+ };
43660
+ var __generator = this && this.__generator || function (thisArg, body) {
43661
+ var _ = {
43662
+ label: 0,
43663
+ sent: function () {
43664
+ if (t[0] & 1) throw t[1];
43665
+ return t[1];
43666
+ },
43667
+ trys: [],
43668
+ ops: []
43669
+ },
43670
+ f,
43671
+ y,
43672
+ t,
43673
+ g;
43674
+ return g = {
43675
+ next: verb(0),
43676
+ "throw": verb(1),
43677
+ "return": verb(2)
43678
+ }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
43679
+ return this;
43680
+ }), g;
43681
+ function verb(n) {
43682
+ return function (v) {
43683
+ return step([n, v]);
43684
+ };
43685
+ }
43686
+ function step(op) {
43687
+ if (f) throw new TypeError("Generator is already executing.");
43688
+ while (_) try {
43689
+ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
43690
+ if (y = 0, t) op = [op[0] & 2, t.value];
43691
+ switch (op[0]) {
43692
+ case 0:
43693
+ case 1:
43694
+ t = op;
43695
+ break;
43696
+ case 4:
43697
+ _.label++;
43698
+ return {
43699
+ value: op[1],
43700
+ done: false
43701
+ };
43702
+ case 5:
43703
+ _.label++;
43704
+ y = op[1];
43705
+ op = [0];
43706
+ continue;
43707
+ case 7:
43708
+ op = _.ops.pop();
43709
+ _.trys.pop();
43710
+ continue;
43711
+ default:
43712
+ if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
43713
+ _ = 0;
43714
+ continue;
43715
+ }
43716
+ if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
43717
+ _.label = op[1];
43718
+ break;
43719
+ }
43720
+ if (op[0] === 6 && _.label < t[1]) {
43721
+ _.label = t[1];
43722
+ t = op;
43723
+ break;
43724
+ }
43725
+ if (t && _.label < t[2]) {
43726
+ _.label = t[2];
43727
+ _.ops.push(op);
43728
+ break;
43729
+ }
43730
+ if (t[2]) _.ops.pop();
43731
+ _.trys.pop();
43732
+ continue;
43733
+ }
43734
+ op = body.call(thisArg, _);
43735
+ } catch (e) {
43736
+ op = [6, e];
43737
+ y = 0;
43738
+ } finally {
43739
+ f = t = 0;
43740
+ }
43741
+ if (op[0] & 5) throw op[1];
43742
+ return {
43743
+ value: op[0] ? op[1] : void 0,
43744
+ done: true
43745
+ };
43746
+ }
43747
+ };
43578
43748
  var __rest = this && this.__rest || function (s, e) {
43579
43749
  var t = {};
43580
43750
  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
@@ -43615,29 +43785,99 @@ var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
43615
43785
  return to.concat(ar || Array.prototype.slice.call(from));
43616
43786
  };
43617
43787
  exports.__esModule = true;
43618
- exports.makeGitlabJob = void 0;
43788
+ exports.createGitlabJobs = exports.makeGitlabJob = void 0;
43619
43789
  var lodash_1 = __nccwpck_require__(3255);
43620
43790
  var defaults_1 = __nccwpck_require__(7383);
43791
+ var getFullJobName = function (name, componentName, env) {
43792
+ if (env) {
43793
+ return "".concat(componentName, " ").concat(name, " | ").concat(env, " ");
43794
+ }
43795
+ return "".concat(componentName, " ").concat(name);
43796
+ };
43797
+ var getFullReferencedJobName = function (referencedJobName, componentName, env, allJobs) {
43798
+ var _a, _b;
43799
+ var referencedJob = (_b = (_a = allJobs[componentName]) === null || _a === void 0 ? void 0 : _a[env]) === null || _b === void 0 ? void 0 : _b.find(function (j) {
43800
+ return j.name === referencedJobName;
43801
+ });
43802
+ if (!referencedJob) {
43803
+ throw new Error("unknown job referenced: '".concat(referencedJobName, "' from '").concat(env, ":").concat(componentName, "'"));
43804
+ }
43805
+ var envToSet = referencedJob.envMode !== "none" ? env : null;
43806
+ return getFullJobName(referencedJobName, componentName, envToSet);
43807
+ };
43621
43808
  var getJobName = function (need) {
43622
43809
  return (0, lodash_1.isObject)(need) ? need.job : need;
43623
43810
  };
43624
- var makeGitlabJob = function (_a) {
43811
+ var makeGitlabJob = function (componentName, env, _a, allJobs) {
43812
+ var _b;
43625
43813
  var envMode = _a.envMode,
43626
43814
  needsStages = _a.needsStages,
43627
43815
  needsOtherComponent = _a.needsOtherComponent,
43628
43816
  name = _a.name,
43629
43817
  needs = _a.needs,
43630
- rest = __rest(_a, ["envMode", "needsStages", "needsOtherComponent", "name", "needs"]);
43631
- return __assign(__assign({}, rest), {
43818
+ job = __rest(_a, ["envMode", "needsStages", "needsOtherComponent", "name", "needs"]);
43819
+ var stage = envMode === "stagePerEnv" ? "".concat(job.stage, " ").concat(env) : job.stage;
43820
+ var needsFromStages = needsStages === null || needsStages === void 0 ? void 0 : needsStages.flatMap(function (n) {
43821
+ var _a, _b, _c, _d;
43822
+ var referencedComponentName = componentName;
43823
+ var allJobNamesFromThatStage = (_d = (_c = (_b = (_a = allJobs[referencedComponentName]) === null || _a === void 0 ? void 0 : _a[env]) === null || _b === void 0 ? void 0 : _b.filter(function (j) {
43824
+ return j.stage === n.stage;
43825
+ })) === null || _c === void 0 ? void 0 : _c.map(function (j) {
43826
+ return j.name;
43827
+ })) !== null && _d !== void 0 ? _d : [];
43828
+ return allJobNamesFromThatStage.map(function (job) {
43829
+ var _a;
43830
+ return {
43831
+ job: job,
43832
+ artifacts: (_a = n.artifacts) !== null && _a !== void 0 ? _a : false,
43833
+ componentName: referencedComponentName
43834
+ };
43835
+ });
43836
+ });
43837
+ var cleanedNeeds = __spreadArray(__spreadArray(__spreadArray([], __read(needs !== null && needs !== void 0 ? needs : []), false), __read(needsOtherComponent !== null && needsOtherComponent !== void 0 ? needsOtherComponent : []), false), __read(needsFromStages !== null && needsFromStages !== void 0 ? needsFromStages : []), false);
43838
+ var gitlabNeeds = cleanedNeeds === null || cleanedNeeds === void 0 ? void 0 : cleanedNeeds.map(function (n) {
43839
+ var _a;
43840
+ return (0, lodash_1.isObject)(n) ? {
43841
+ job: getFullReferencedJobName(n.job, (_a = n.componentName) !== null && _a !== void 0 ? _a : componentName, env, allJobs),
43842
+ artifacts: n.artifacts
43843
+ } : getFullReferencedJobName(n, componentName, env, allJobs);
43844
+ }).sort(function (a, b) {
43845
+ return getJobName(a).localeCompare(getJobName(b));
43846
+ });
43847
+ var fullJobName = getFullJobName(name, componentName, envMode !== "none" ? env : undefined);
43848
+ var gitlabJob = __assign(__assign({}, job), {
43849
+ stage: stage,
43850
+ environment: ((_b = job.environment) === null || _b === void 0 ? void 0 : _b.on_stop) ? __assign(__assign({}, job.environment), {
43851
+ on_stop: getFullReferencedJobName(job.environment.on_stop, componentName, env, allJobs)
43852
+ }) : job.environment,
43632
43853
  // sort in a predictable manner for snapshot tests
43633
- needs: needs ? __spreadArray([], __read(needs), false).sort(function (a, b) {
43634
- return getJobName(a).localeCompare(getJobName(b));
43635
- }) : undefined,
43854
+ needs: gitlabNeeds,
43636
43855
  retry: defaults_1.BASE_RETRY,
43637
43856
  interruptible: true
43638
43857
  });
43858
+ return [fullJobName, gitlabJob];
43639
43859
  };
43640
43860
  exports.makeGitlabJob = makeGitlabJob;
43861
+ var createGitlabJobs = function (allJobs) {
43862
+ return __awaiter(void 0, void 0, void 0, function () {
43863
+ return __generator(this, function (_a) {
43864
+ return [2 /*return*/, Object.keys(allJobs).reduce(function (accForComponents, componentName) {
43865
+ var componentJobs = allJobs[componentName];
43866
+ return __assign(__assign({}, accForComponents), Object.keys(componentJobs).reduce(function (accForEnvs, env) {
43867
+ var jobs = componentJobs[env];
43868
+ return __assign(__assign({}, accForEnvs), jobs.reduce(function (accForJobs, job) {
43869
+ var _a;
43870
+ var _b = __read((0, exports.makeGitlabJob)(componentName, env, job, allJobs), 2),
43871
+ fullJobName = _b[0],
43872
+ gitlabJob = _b[1];
43873
+ return __assign(__assign({}, accForJobs), (_a = {}, _a[fullJobName] = gitlabJob, _a));
43874
+ }, {}));
43875
+ }, {}));
43876
+ }, {})];
43877
+ });
43878
+ });
43879
+ };
43880
+ exports.createGitlabJobs = createGitlabJobs;
43641
43881
 
43642
43882
  /***/ }),
43643
43883
 
@@ -43664,7 +43904,7 @@ var __exportStar = this && this.__exportStar || function (m, exports) {
43664
43904
  };
43665
43905
  exports.__esModule = true;
43666
43906
  __exportStar(__nccwpck_require__(8974), exports);
43667
- __exportStar(__nccwpck_require__(7726), exports);
43907
+ __exportStar(__nccwpck_require__(962), exports);
43668
43908
 
43669
43909
  /***/ }),
43670
43910