@catladder/cli 0.0.0-refactor-needs-aae6e67d → 0.0.0-refactor-gitlab-jobs-9e285eaf

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