@catladder/pipeline 4.6.4 → 4.7.1

package/dist/types/config.d.ts

@@ -7,6 +7,7 @@ import type { PipelineType, WorkspaceBuildConfig } from "..";
 import type { AgentConfig } from "./agent";
 import type { Hooks } from "./hooks";
 import type { ReleaseConfig } from "./release";
+import type { VerifyConfig } from "../verify/types";
 export declare const ALL_PIPELINE_TRIGGERS: readonly ["mainBranch", "mr", "taggedRelease"];
 export type PipelineTrigger = (typeof ALL_PIPELINE_TRIGGERS)[number];
 /**
@@ -71,6 +72,13 @@ export type DefaultEnvConfig = {
    * environment variables
    */
   vars?: EnvVars;
+  /**
+   * post-deploy verification: runs a job in the `verify` stage after the deploy,
+   * e.g. an e2e test suite against the freshly deployed environment.
+   *
+   * Runs in all deployed envs by default, disable per env with `verify: false`
+   */
+  verify?: VerifyConfig | false;
 };
 export type DevLocalEnvConfig = {
   vars?: EnvVars;

package/dist/variables/VariableValueContainingReferences.d.ts

@@ -16,6 +16,12 @@ type MaybeArray<T> = T | T[];
 export declare class VariableValueContainingReferences {
   parts: VariableValuePart[];
   constructor(parts: MaybeArray<VariableValuePart | VariableValueContainingReferences>);
+  /**
+   * concats values to this one and returns a new VariableValueContainingReferences.
+   * mirrors String.prototype.concat / BashExpression.concat so a VariableValue
+   * can be extended regardless of its concrete type
+   */
+  concat(...values: Array<VariableValuePart | VariableValueContainingReferences>): VariableValueContainingReferences;
   toString(options?: EscapeOptions): string;
 }
 export declare const createVariableValueContainingReferencesFromString: (value: string, options: {

package/dist/variables/VariableValueContainingReferences.js

@@ -22,6 +22,15 @@ var __read = this && this.__read || function (o, n) {
   }
   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
 });
@@ -55,6 +64,18 @@ var VariableValueContainingReferences = /** @class */function () {
       return part instanceof VariableValueContainingReferences ? part.parts : part === "" ? [] : [part];
     });
   }
+  /**
+   * concats values to this one and returns a new VariableValueContainingReferences.
+   * mirrors String.prototype.concat / BashExpression.concat so a VariableValue
+   * can be extended regardless of its concrete type
+   */
+  VariableValueContainingReferences.prototype.concat = function () {
+    var values = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      values[_i] = arguments[_i];
+    }
+    return new VariableValueContainingReferences(__spreadArray(__spreadArray([], __read(this.parts), false), __read(values), false));
+  };
   VariableValueContainingReferences.prototype.toString = function (options) {
     if (options === void 0) {
       options = {

package/dist/variables/resolveAllReferences.d.ts

@@ -1,3 +1,2 @@
 import type { VariableValue } from "./VariableValue";
-import type { VariableValueContainingReferences } from "./VariableValueContainingReferences";
-export declare const resolveAllReferences: (values: Record<string, VariableValueContainingReferences>, getEnvVars: (componentName: string) => Promise<Record<string, VariableValue | null | undefined>>) => Promise<Record<string, VariableValueContainingReferences>>;
+export declare const resolveAllReferences: <T extends Record<string, VariableValue | null | undefined>>(values: T, getEnvVars: (componentName: string) => Promise<Record<string, VariableValue | null | undefined>>) => Promise<T>;

package/dist/variables/resolveAllReferences.js

@@ -143,6 +143,11 @@ Object.defineProperty(exports, "__esModule", {
 exports.resolveAllReferences = void 0;
 var VariableValueContainingReferences_1 = require("./VariableValueContainingReferences");
 var resolveAllReferencesOnce_1 = require("./resolveAllReferencesOnce");
+var hasUnresolvedReferences = function (value) {
+  return value instanceof VariableValueContainingReferences_1.VariableValueContainingReferences && value.parts.some(function (part) {
+    return part instanceof VariableValueContainingReferences_1.VariableReference;
+  });
+};
 var resolveAllReferences = function (values, getEnvVars) {
   return __awaiter(void 0, void 0, void 0, function () {
     var result, i, replaced, unresolved;
@@ -153,11 +158,7 @@ var resolveAllReferences = function (values, getEnvVars) {
           i = 0;
           _a.label = 1;
         case 1:
-          if (!Object.values(result).some(function (value) {
-            return value.parts.some(function (part) {
-              return part instanceof VariableValueContainingReferences_1.VariableReference;
-            });
-          })) return [3 /*break*/, 3];
+          if (!Object.values(result).some(hasUnresolvedReferences)) return [3 /*break*/, 3];
           return [4 /*yield*/, (0, resolveAllReferencesOnce_1.resolveAllReferencesOnce)(result, getEnvVars)];
         case 2:
           replaced = _a.sent();
@@ -168,9 +169,7 @@ var resolveAllReferences = function (values, getEnvVars) {
               var _b = __read(_a, 2),
                 key = _b[0],
                 value = _b[1];
-              return value.parts.some(function (part) {
-                return part instanceof VariableValueContainingReferences_1.VariableReference;
-              });
+              return hasUnresolvedReferences(value);
             });
             throw new Error("Infinite loop detected in these variables: " + unresolved.map(function (_a) {
               var _b = __read(_a, 2),

package/dist/variables/resolveAllReferencesOnce.d.ts

@@ -1,5 +1,2 @@
 import type { VariableValue } from "./VariableValue";
-import type { VariableValueContainingReferences } from "./VariableValueContainingReferences";
-export declare const resolveAllReferencesOnce: (values: Record<string, VariableValueContainingReferences>, getEnvVars: (componentName: string) => Promise<Record<string, VariableValue | undefined | null>>) => Promise<{
-  [k: string]: VariableValueContainingReferences;
-}>;
+export declare const resolveAllReferencesOnce: <T extends Record<string, VariableValue | null | undefined>>(values: T, getEnvVars: (componentName: string) => Promise<Record<string, VariableValue | undefined | null>>) => Promise<T>;

package/dist/variables/resolveAllReferencesOnce.js

@@ -150,9 +150,9 @@ var resolveAllReferencesOnce = function (values, getEnvVars) {
       switch (_c.label) {
         case 0:
           allReferences = Object.values(values).flatMap(function (value) {
-            return value === null || value === void 0 ? void 0 : value.parts.filter(function (part) {
+            return value instanceof VariableValueContainingReferences_1.VariableValueContainingReferences ? value.parts.filter(function (part) {
               return part instanceof VariableValueContainingReferences_1.VariableReference;
-            });
+            }) : [];
           });
           allComponentsUnique = Array.from(new Set(allReferences.map(function (reference) {
             return reference.componentName;
@@ -178,7 +178,7 @@ var resolveAllReferencesOnce = function (values, getEnvVars) {
             var _b = __read(_a, 2),
               key = _b[0],
               value = _b[1];
-            return [key, value !== null && value !== undefined ? (0, resolveReferencesOnce_1.resolveReferencesOnce)(value, function (_a) {
+            return [key, value instanceof VariableValueContainingReferences_1.VariableValueContainingReferences ? (0, resolveReferencesOnce_1.resolveReferencesOnce)(value, function (_a) {
               var componentName = _a.componentName,
                 variableName = _a.variableName;
               return allEnvVarsInComponents[componentName][variableName];

package/dist/verify/createVerifyJobs.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentContext } from "../types/context";
+import type { CatladderJob } from "../types/jobs";
+export declare const VERIFY_JOB_NAME = "\uD83D\uDD0D verify";
+export declare const createVerifyJobs: (context: ComponentContext) => Promise<CatladderJob[]>;

package/dist/verify/createVerifyJobs.js

@@ -0,0 +1,229 @@
+"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.createVerifyJobs = exports.VERIFY_JOB_NAME = void 0;
+var createArtifactsConfig_1 = require("../build/base/createArtifactsConfig");
+var createJobCache_1 = require("../build/cache/createJobCache");
+var cache_1 = require("../build/node/cache");
+var constants_1 = require("../build/node/constants");
+var yarn_1 = require("../build/node/yarn");
+var deploy_1 = require("../deploy");
+var deploy_2 = require("../deploy/base/deploy");
+var runner_1 = require("../runner");
+var utils_1 = require("../utils");
+exports.VERIFY_JOB_NAME = "🔍 verify";
+var createVerifyJobs = function (context) {
+  return __awaiter(void 0, void 0, void 0, function () {
+    var verifyConfig, deployConfig, isNodeBuild, _a, yarnInstall, nodeCache, _b, setupScript;
+    var _c, _d, _e, _f, _g, _h, _j;
+    return __generator(this, function (_k) {
+      switch (_k.label) {
+        case 0:
+          verifyConfig = context.componentConfig.verify;
+          if (!verifyConfig) {
+            return [2 /*return*/, []];
+          }
+          deployConfig = (_c = context.deploy) === null || _c === void 0 ? void 0 : _c.config;
+          if (!deployConfig) {
+            // nothing is deployed, so there is nothing to verify
+            return [2 /*return*/, []];
+          }
+          isNodeBuild = context.build.type !== "disabled" && context.build.buildType === "node";
+          if (!isNodeBuild) return [3 /*break*/, 2];
+          return [4 /*yield*/, Promise.all([(0, yarn_1.getYarnInstall)(context), (0, cache_1.getNodeCache)(context, "pull")])];
+        case 1:
+          _b = _k.sent();
+          return [3 /*break*/, 3];
+        case 2:
+          _b = [null, null];
+          _k.label = 3;
+        case 3:
+          _a = __read.apply(void 0, [_b, 2]), yarnInstall = _a[0], nodeCache = _a[1];
+          setupScript = (_f = (_e = (_d = deploy_1.DEPLOY_TYPES[deployConfig.type]).verifyJobSetupScript) === null || _e === void 0 ? void 0 : _e.call(_d, context)) !== null && _f !== void 0 ? _f : [];
+          return [2 /*return*/, [__assign({
+            name: exports.VERIFY_JOB_NAME,
+            stage: "verify",
+            envMode: "stagePerEnv",
+            // wait for this component's own deploy
+            needsStages: [{
+              stage: "deploy",
+              artifacts: false
+            }],
+            // ...and for the deploys of the components listed in waitFor
+            needs: ((_g = verifyConfig.waitFor) !== null && _g !== void 0 ? _g : []).map(function (componentName) {
+              return {
+                job: deploy_2.DEPLOY_JOB_NAME,
+                componentName: componentName,
+                artifacts: false
+              };
+            }),
+            image: (_h = verifyConfig.jobImage) !== null && _h !== void 0 ? _h : (0, runner_1.getRunnerImage)("jobs-testing-chrome"),
+            cache: nodeCache ? (0, createJobCache_1.createJobCacheFromCacheConfigs)(context, nodeCache) : undefined,
+            variables: __assign({}, context.environment.envVars),
+            runnerVariables: __assign(__assign({}, constants_1.NODE_RUNNER_BUILD_VARIABLES), (_j = verifyConfig.runnerVariables) !== null && _j !== void 0 ? _j : {}),
+            script: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(setupScript), false), __read(yarnInstall ? (0, yarn_1.ensureNodeVersion)(context) : []), false), ["cd ".concat(context.build.dir)], false), __read(yarnInstall !== null && yarnInstall !== void 0 ? yarnInstall : []), false), __read((0, utils_1.ensureArray)(verifyConfig.command)), false),
+            allow_failure: verifyConfig.allowFailure
+          }, (0, createArtifactsConfig_1.createArtifactsConfig)(context.build.dir, verifyConfig.artifactsReports, verifyConfig.artifacts))]];
+      }
+    });
+  });
+};
+exports.createVerifyJobs = createVerifyJobs;

package/dist/verify/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./createVerifyJobs";

package/dist/verify/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m, k);
+  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    desc = {
+      enumerable: true,
+      get: function () {
+        return m[k];
+      }
+    };
+  }
+  Object.defineProperty(o, k2, desc);
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+var __exportStar = this && this.__exportStar || function (m, exports) {
+  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+__exportStar(require("./types"), exports);
+__exportStar(require("./createVerifyJobs"), exports);

package/dist/verify/types.d.ts

@@ -0,0 +1,16 @@
+import type { TestJobCustom } from "../build/types";
+/**
+ * post-deploy verification job configuration
+ */
+export type VerifyConfig = TestJobCustom & {
+  /**
+   * command(s) to run against the deployed environment (e.g. `yarn e2e`).
+   * Runs in the component's directory.
+   */
+  command: string | string[];
+  /**
+   * names of other components whose deploy must finish before this verify job runs
+   * (in addition to this component's own deploy, which is always awaited)
+   */
+  waitFor?: string[];
+};

package/dist/verify/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});