@catladder/pipeline 0.0.0-node16-ddfae617 → 0.0.0-perf-cli-reduce-bundle-size-with-tsconfig-optimization-3556aaa4

package/dist/context/createAllComponentsContext.js

@@ -0,0 +1,159 @@
+"use strict";
+
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      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;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAllComponentsContext = void 0;
+var configruedEnvs_1 = require("../config/configruedEnvs");
+var createComponentContext_1 = require("./createComponentContext");
+var createAllComponentsContext = function (_a) {
+  return __awaiter(void 0, [_a], void 0, function (_b) {
+    var config = _b.config,
+      trigger = _b.trigger,
+      pipelineType = _b.pipelineType;
+    return __generator(this, function (_c) {
+      switch (_c.label) {
+        case 0:
+          return [4 /*yield*/, Promise.all(Object.keys(config.components).flatMap(function (componentName) {
+            var envs = (0, configruedEnvs_1.getAllEnvsByTrigger)(config, componentName, trigger);
+            return envs.map(function (env) {
+              return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                  switch (_a.label) {
+                    case 0:
+                      return [4 /*yield*/, (0, createComponentContext_1.createComponentContext)({
+                        config: config,
+                        componentName: componentName,
+                        env: env,
+                        trigger: trigger,
+                        pipelineType: pipelineType
+                      })];
+                    case 1:
+                      return [2 /*return*/, _a.sent()];
+                  }
+                });
+              });
+            });
+          }))];
+        case 1:
+          return [2 /*return*/, _c.sent()];
+      }
+    });
+  });
+};
+exports.createAllComponentsContext = createAllComponentsContext;

package/dist/context/createComponentContext.d.ts

@@ -0,0 +1,11 @@
+import type { PipelineType } from "../types";
+import type { Config, PipelineTrigger } from "../types/config";
+import type { ComponentContext } from "../types/context";
+export type CreateComponentContextContext = {
+  config: Config;
+  componentName: string;
+  env: string;
+  pipelineType?: PipelineType;
+  trigger?: PipelineTrigger;
+};
+export declare const createComponentContext: (ctx: CreateComponentContextContext) => Promise<ComponentContext>;

package/dist/context/createComponentContext.js

@@ -0,0 +1,256 @@
+"use strict";
+
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      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;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createComponentContext = void 0;
+var lodash_1 = require("lodash");
+var build_1 = require("../build");
+var deploy_1 = require("../deploy");
+var packageManager_1 = require("../pipeline/packageManager");
+var utils_1 = require("../utils");
+var getEnvironment_1 = require("./getEnvironment");
+var getEnvironmentContext_1 = require("./getEnvironmentContext");
+var createComponentContext = function (ctx) {
+  return __awaiter(void 0, void 0, void 0, function () {
+    var packageManagerInfo, envContext, componentConfigWithoutDefaults, resolvedBuildType, defaults, componentConfig, environment, deploy, build, customJobs, dir, getComponentDirs, _getBuildContext, buildContext, context, resolvedCustomJobs;
+    var _a;
+    return __generator(this, function (_b) {
+      switch (_b.label) {
+        case 0:
+          if (!/^[a-z0-9-]+$/.test(ctx.componentName)) {
+            throw new Error("componentName may only contain lower case letters, numbers and -");
+          }
+          return [4 /*yield*/, (0, packageManager_1.getPackageManagerInfoForComponent)(ctx.config, ctx.componentName)];
+        case 1:
+          packageManagerInfo = _b.sent();
+          envContext = (0, getEnvironmentContext_1.getEnvironmentContext)(ctx);
+          componentConfigWithoutDefaults = envContext.envConfigRaw;
+          resolvedBuildType = (0, build_1.isStandaloneBuildConfig)(componentConfigWithoutDefaults.build) ? componentConfigWithoutDefaults.build.type : (_a = ctx.config.builds) === null || _a === void 0 ? void 0 : _a[componentConfigWithoutDefaults.build.from].type;
+          if (!resolvedBuildType) {
+            throw new Error("build type not found, is the build config correct?");
+          }
+          defaults = componentConfigWithoutDefaults.deploy ? {
+            build: build_1.BUILD_TYPES[resolvedBuildType].defaults(envContext),
+            deploy: deploy_1.DEPLOY_TYPES[componentConfigWithoutDefaults.deploy.type].defaults(envContext)
+          } : {
+            build: build_1.BUILD_TYPES[resolvedBuildType].defaults(envContext),
+            deploy: {}
+          };
+          componentConfig = (0, utils_1.mergeWithMergingArrays)(defaults, componentConfigWithoutDefaults);
+          return [4 /*yield*/, (0, getEnvironment_1.getEnvironment)(ctx)];
+        case 2:
+          environment = _b.sent();
+          deploy = componentConfig.deploy, build = componentConfig.build, customJobs = componentConfig.customJobs, dir = componentConfig.dir;
+          getComponentDirs = function (mode) {
+            var _a;
+            return __spreadArray([dir], __read(mode === "all" ? (_a = packageManagerInfo.currentWorkspaceDependencies) !== null && _a !== void 0 ? _a : [] : []), false);
+          };
+          _getBuildContext = function () {
+            var _a;
+            if ((0, build_1.isStandaloneBuildConfig)(build)) {
+              return {
+                dir: dir,
+                getComponentDirs: getComponentDirs,
+                config: build,
+                buildType: build.type,
+                type: "standalone"
+              };
+            }
+            // must be shared build
+            var referencedBuild = (_a = ctx.config.builds) === null || _a === void 0 ? void 0 : _a[build.from];
+            if (!referencedBuild) {
+              throw new Error("build.from not found in config");
+            }
+            return {
+              dir: dir,
+              getComponentDirs: getComponentDirs,
+              config: build,
+              workspaceBuildConfig: referencedBuild,
+              workspaceName: build.from,
+              buildType: referencedBuild.type,
+              type: "fromWorkspace"
+            };
+          };
+          buildContext = _getBuildContext();
+          context = {
+            type: "component",
+            name: ctx.componentName,
+            componentName: ctx.componentName,
+            env: ctx.env,
+            fullConfig: ctx.config,
+            componentConfig: componentConfig,
+            build: buildContext,
+            deploy: deploy ? {
+              config: deploy
+            } : null,
+            environment: environment,
+            packageManagerInfo: packageManagerInfo,
+            pipelineType: ctx.pipelineType,
+            trigger: ctx.trigger
+          };
+          resolvedCustomJobs = (0, lodash_1.isFunction)(customJobs) ? customJobs(context) : customJobs;
+          return [2 /*return*/, __assign(__assign({}, context), {
+            customJobs: resolvedCustomJobs
+          })];
+      }
+    });
+  });
+};
+exports.createComponentContext = createComponentContext;

package/dist/context/createWorkspaceContext.d.ts

@@ -0,0 +1,16 @@
+import { type Config, type PipelineTrigger, type PipelineType, type WorkspaceContext } from "..";
+export declare function createWorkspaceContext({
+  env,
+  components,
+  workspaceName,
+  config,
+  pipelineType,
+  trigger
+}: {
+  env: string;
+  components: WorkspaceContext["components"];
+  workspaceName: string;
+  config: Config;
+  pipelineType: PipelineType;
+  trigger: PipelineTrigger;
+}): Promise<WorkspaceContext>;

package/dist/context/createWorkspaceContext.js

@@ -0,0 +1,173 @@
+"use strict";
+
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+var __generator = this && this.__generator || function (thisArg, body) {
+  var _ = {
+      label: 0,
+      sent: function () {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      },
+      trys: [],
+      ops: []
+    },
+    f,
+    y,
+    t,
+    g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+      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;
+      if (y = 0, t) op = [op[0] & 2, t.value];
+      switch (op[0]) {
+        case 0:
+        case 1:
+          t = op;
+          break;
+        case 4:
+          _.label++;
+          return {
+            value: op[1],
+            done: false
+          };
+        case 5:
+          _.label++;
+          y = op[1];
+          op = [0];
+          continue;
+        case 7:
+          op = _.ops.pop();
+          _.trys.pop();
+          continue;
+        default:
+          if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+            _ = 0;
+            continue;
+          }
+          if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+            _.label = op[1];
+            break;
+          }
+          if (op[0] === 6 && _.label < t[1]) {
+            _.label = t[1];
+            t = op;
+            break;
+          }
+          if (t && _.label < t[2]) {
+            _.label = t[2];
+            _.ops.push(op);
+            break;
+          }
+          if (t[2]) _.ops.pop();
+          _.trys.pop();
+          continue;
+      }
+      op = body.call(thisArg, _);
+    } catch (e) {
+      op = [6, e];
+      y = 0;
+    } finally {
+      f = t = 0;
+    }
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createWorkspaceContext = void 0;
+var __1 = require("..");
+var packageManager_1 = require("../pipeline/packageManager");
+var utils_1 = require("../utils");
+var lodash_1 = require("lodash");
+function createWorkspaceContext(_a) {
+  return __awaiter(this, arguments, void 0, function (_b) {
+    var workspaceConfigRaw, defaults, workspaceConfig;
+    var _c;
+    var _d, _e;
+    var env = _b.env,
+      components = _b.components,
+      workspaceName = _b.workspaceName,
+      config = _b.config,
+      pipelineType = _b.pipelineType,
+      trigger = _b.trigger;
+    return __generator(this, function (_f) {
+      switch (_f.label) {
+        case 0:
+          workspaceConfigRaw = (_d = config.builds) === null || _d === void 0 ? void 0 : _d[workspaceName];
+          if (!workspaceConfigRaw) {
+            throw new Error("Workspace ".concat(workspaceName, " not found in config"));
+          }
+          defaults = __1.WORKSPACE_BUILD_TYPES[workspaceConfigRaw.type].defaults();
+          workspaceConfig = (0, utils_1.mergeWithMergingArrays)(defaults, workspaceConfigRaw);
+          _c = {
+            name: workspaceName,
+            pipelineType: pipelineType,
+            trigger: trigger,
+            type: "workspace",
+            workspaceConfig: workspaceConfig,
+            env: env,
+            components: components,
+            fullConfig: config
+          };
+          return [4 /*yield*/, (0, packageManager_1.getPackageManagerInfoBase)()];
+        case 1:
+          return [2 /*return*/, (_c.packageManagerInfo = _f.sent(), _c.build = {
+            type: "workspace",
+            dir: (_e = workspaceConfig.dir) !== null && _e !== void 0 ? _e : ".",
+            getComponentDirs: function (mode) {
+              return (0, lodash_1.uniq)(components.flatMap(function (c) {
+                return c.build.getComponentDirs(mode);
+              }));
+            },
+            buildType: workspaceConfig.type,
+            config: workspaceConfig
+          }, _c)];
+      }
+    });
+  });
+}
+exports.createWorkspaceContext = createWorkspaceContext;

package/dist/context/getBuildInfoVariables.d.ts

@@ -0,0 +1,6 @@
+import { BashExpression } from "../bash/BashExpression";
+import type { EnvironmentContext } from "../types/environmentContext";
+export declare const ALL_BUILD_VARIABLES: string[];
+export declare const getBuildInfoVariables: (ctx: EnvironmentContext) => {
+  [k: string]: string | BashExpression;
+};

package/dist/context/getBuildInfoVariables.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBuildInfoVariables = exports.ALL_BUILD_VARIABLES = void 0;
+var BashExpression_1 = require("../bash/BashExpression");
+var bashExpressionPerPipelineType_1 = require("../bash/bashExpressionPerPipelineType");
+var BUILD_VARIABLES = {
+  BUILD_INFO_BUILD_ID: {
+    default: new BashExpression_1.BashExpression("$(git describe --tags 2>/dev/null || git rev-parse HEAD)")
+  },
+  BUILD_INFO_BUILD_TIME: {
+    default: "unknown-build-time",
+    gitlab: new BashExpression_1.BashExpression("$CI_JOB_STARTED_AT")
+  },
+  BUILD_INFO_CURRENT_VERSION: {
+    default: new BashExpression_1.BashExpression(
+    // because we do shallow fetch, we need to ask the origin
+    "$(tag=$(git ls-remote origin \"refs/tags/v*[0-9]\" 2>/dev/null | cut -f 2- | sort -V | tail -1 | sed 's/refs\\/tags\\/v//'); [ -z \"$tag\" ] && echo \"0.0.0\" || echo \"$tag\")")
+  }
+};
+exports.ALL_BUILD_VARIABLES = Object.keys(BUILD_VARIABLES);
+var getBuildInfoVariables = function (ctx) {
+  var pipelineType = ctx.pipelineType;
+  return Object.fromEntries(Object.entries(BUILD_VARIABLES).map(function (_a) {
+    var _b = __read(_a, 2),
+      key = _b[0],
+      value = _b[1];
+    return [key, (0, bashExpressionPerPipelineType_1.getBashExpressionPerPipelineType)(value, pipelineType)];
+  }));
+};
+exports.getBuildInfoVariables = getBuildInfoVariables;

package/dist/context/getEnvConfig.d.ts

@@ -0,0 +1,2 @@
+import type { Config, EnvConfigWithComponent } from "../types/config";
+export declare const getEnvConfig: (config: Config, componentName: string, env: string) => EnvConfigWithComponent;