@catladder/pipeline 0.0.0-more-collapse-deeb54d7 → 0.0.0-multiple-gitlab-includes-1a40efc0

package/dist/variables/__tests__/resolveAllReferences.test.js

@@ -0,0 +1,218 @@
+"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
+});
+var VariableValueContainingReferences_1 = require("../VariableValueContainingReferences");
+var resolveAllReferences_1 = require("../resolveAllReferences");
+describe("replaceAllReferences", function () {
+  it("should replace all references recursivly", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var values, getEnvVars, result;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            values = {
+              myVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the 2nd component has ${component2:variable1} and self reference ${variable2}", {
+                componentName: "component1"
+              }),
+              myOtherVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the third component has ${component3:variable1}, isn't that cool?", {
+                componentName: "component1"
+              }),
+              myThirdVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("value from component3: ${component3:variable3}", {
+                componentName: "component1"
+              })
+            };
+            getEnvVars = function (componentName) {
+              return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                  return [2 /*return*/, {
+                    variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am variable1 from ".concat(componentName), {
+                      componentName: componentName
+                    }),
+                    variable2: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("foo from ".concat(componentName), {
+                      componentName: componentName
+                    }),
+                    variable3: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component1:variable1}", {
+                      componentName: componentName
+                    })
+                  }];
+                });
+              });
+            };
+            return [4 /*yield*/, (0, resolveAllReferences_1.resolveAllReferences)(values, getEnvVars)];
+          case 1:
+            result = _a.sent();
+            expect(result).toEqual({
+              myVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["the 2nd component has ", "i am variable1 from component2", " and self reference ", "foo from component1"]),
+              myOtherVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["the third component has ", "i am variable1 from component3", ", isn't that cool?"]),
+              myThirdVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["value from component3: ", "i am referencing ", "i am variable1 from component1"])
+            });
+            return [2 /*return*/];
+        }
+      });
+    });
+  });
+  it("detects infinte loop", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var values, getEnvVars;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            values = {
+              myVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component2:variable1}", {
+                componentName: "component1"
+              })
+            };
+            getEnvVars = function (componentName) {
+              return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                  if (componentName === "component2") {
+                    return [2 /*return*/, {
+                      variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component3:variable1}", {
+                        componentName: componentName
+                      })
+                    }];
+                  } else if (componentName === "component3") {
+                    return [2 /*return*/, {
+                      variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component1:variable1}", {
+                        componentName: componentName
+                      })
+                    }];
+                  } else {
+                    return [2 /*return*/, {
+                      variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component2:variable1}", {
+                        componentName: componentName
+                      })
+                    }];
+                  }
+                  return [2 /*return*/];
+                });
+              });
+            };
+            // expect to throw an error
+            return [4 /*yield*/, expect((0, resolveAllReferences_1.resolveAllReferences)(values, getEnvVars)).rejects.toThrow("Infinite loop detected in these variables: myVar (last reference: ${component1:variable1})")];
+          case 1:
+            // expect to throw an error
+            _a.sent();
+            return [2 /*return*/];
+        }
+      });
+    });
+  });
+});

package/dist/variables/__tests__/resolveAllReferencesOnce.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/variables/__tests__/resolveAllReferencesOnce.test.js

@@ -0,0 +1,171 @@
+"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
+});
+var VariableValueContainingReferences_1 = require("../VariableValueContainingReferences");
+var resolveAllReferencesOnce_1 = require("../resolveAllReferencesOnce");
+describe("resolveAllReferencesOnce", function () {
+  it("should replace all references", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var values, getEnvVars, result;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            values = {
+              myVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the 2nd component has ${component2:variable1} and self reference ${variable2}", {
+                componentName: "component1"
+              }),
+              myOtherVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the third component has ${component3:variable1}, isn't that cool?", {
+                componentName: "component1"
+              }),
+              myThirdVar: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("value from component3: ${component3:variable3}", {
+                componentName: "component1"
+              })
+            };
+            getEnvVars = function (componentName) {
+              return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                  return [2 /*return*/, {
+                    variable1: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am variable1 from ".concat(componentName), {
+                      componentName: componentName
+                    }),
+                    variable2: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("foo from ".concat(componentName), {
+                      componentName: componentName
+                    }),
+                    variable3: (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("i am referencing ${component1:variable1}", {
+                      componentName: componentName
+                    })
+                  }];
+                });
+              });
+            };
+            return [4 /*yield*/, (0, resolveAllReferencesOnce_1.resolveAllReferencesOnce)(values, getEnvVars)];
+          case 1:
+            result = _a.sent();
+            expect(result).toEqual({
+              myVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["the 2nd component has ", "i am variable1 from component2", " and self reference ", "foo from component1"]),
+              myOtherVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["the third component has ", "i am variable1 from component3", ", isn't that cool?"]),
+              myThirdVar: new VariableValueContainingReferences_1.VariableValueContainingReferences(["value from component3: ", "i am referencing ", new VariableValueContainingReferences_1.VariableReference("component1", "variable1")])
+            });
+            return [2 /*return*/];
+        }
+      });
+    });
+  });
+});

package/dist/variables/__tests__/resolveReferencesOnce.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/variables/__tests__/resolveReferencesOnce.test.js

@@ -0,0 +1,199 @@
+"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
+});
+var VariableValueContainingReferences_1 = require("../VariableValueContainingReferences");
+var resolveReferencesOnce_1 = require("../resolveReferencesOnce");
+describe("resolveReferencesOnce", function () {
+  it("should replace a reference to another component", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var value, result;
+      return __generator(this, function (_a) {
+        value = (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the other component has ${otherComponent:variableName}, isn't that cool?", {
+          componentName: "myComponent"
+        });
+        result = (0, resolveReferencesOnce_1.resolveReferencesOnce)(value, function (_a) {
+          var componentName = _a.componentName,
+            variableName = _a.variableName;
+          return (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("replaced ".concat(componentName, ":").concat(variableName), {
+            componentName: componentName
+          });
+        });
+        expect(result.parts).toEqual(["the other component has ", "replaced otherComponent:variableName", ", isn't that cool?"]);
+        return [2 /*return*/];
+      });
+    });
+  });
+  it("should keep references in replacement", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var value, result;
+      return __generator(this, function (_a) {
+        value = (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the other component has ${otherComponent:variableName}, isn't that cool?", {
+          componentName: "myComponent"
+        });
+        result = (0, resolveReferencesOnce_1.resolveReferencesOnce)(value, function (_a) {
+          var componentName = _a.componentName,
+            variableName = _a.variableName;
+          return (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("replaced ".concat(componentName, ":").concat(variableName, ", contains reference to ${thirdComponent:x}"), {
+            componentName: componentName
+          });
+        });
+        expect(result.parts).toEqual(["the other component has ", "replaced otherComponent:variableName, contains reference to ", new VariableValueContainingReferences_1.VariableReference("thirdComponent", "x"), ", isn't that cool?"]);
+        return [2 /*return*/];
+      });
+    });
+  });
+  it("can be run multiple times", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var value, replacer, result;
+      return __generator(this, function (_a) {
+        value = (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the other component has ${otherComponent:variableName}, isn't that cool?", {
+          componentName: "myComponent"
+        });
+        replacer = function (_a) {
+          var componentName = _a.componentName,
+            variableName = _a.variableName;
+          return (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)(componentName === "thirdComponent" ? "value from third component" : "replaced ".concat(componentName, ":").concat(variableName, ", contains reference to ${thirdComponent:x}"), {
+            componentName: componentName
+          });
+        };
+        result = (0, resolveReferencesOnce_1.resolveReferencesOnce)((0, resolveReferencesOnce_1.resolveReferencesOnce)(value, replacer), replacer);
+        expect(result.parts).toEqual(["the other component has ", "replaced otherComponent:variableName, contains reference to ", "value from third component", ", isn't that cool?"]);
+        return [2 /*return*/];
+      });
+    });
+  });
+  it("flags unresolveable", function () {
+    return __awaiter(void 0, void 0, void 0, function () {
+      var value, result;
+      return __generator(this, function (_a) {
+        value = (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)("the other component has ${otherComponent:variableName}, isn't that cool?", {
+          componentName: "myComponent"
+        });
+        result = (0, resolveReferencesOnce_1.resolveReferencesOnce)(value, function (_a) {
+          var componentName = _a.componentName,
+            variableName = _a.variableName;
+          return null;
+        });
+        expect(result.parts).toEqual(["the other component has ", new VariableValueContainingReferences_1.UnresolvableReference(new VariableValueContainingReferences_1.VariableReference("otherComponent", "variableName")), ", isn't that cool?"]);
+        return [2 /*return*/];
+      });
+    });
+  });
+});

package/dist/variables/__tests__/variableValue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/variables/__tests__/variableValue.test.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var VariableValueContainingReferences_1 = require("../VariableValueContainingReferences");
+describe("createVarialeValueFromString", function () {
+  it("should create a VariableValue from a simple string", function () {
+    var stringValue = "hello world";
+    var result = (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)(stringValue, {
+      componentName: "myComponent"
+    });
+    expect(result.parts).toEqual([stringValue]);
+  });
+  it("extracts references to other components", function () {
+    var stringValue = "the other component has ${otherComponent:variableName}, isn't that cool?";
+    var result = (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)(stringValue, {
+      componentName: "myComponent"
+    });
+    expect(result.parts).toEqual(["the other component has ", new VariableValueContainingReferences_1.VariableReference("otherComponent", "variableName"), ", isn't that cool?"]);
+  });
+  it("extracts self references", function () {
+    var stringValue = "my component has ${variableName}!";
+    var result = (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)(stringValue, {
+      componentName: "myComponent"
+    });
+    expect(result.parts).toEqual(["my component has ", new VariableValueContainingReferences_1.VariableReference("myComponent", "variableName"), "!"]);
+  });
+  it("extracts multiple references", function () {
+    var stringValue = "my component has ${variableName} and the other component has ${otherComponent:variableName}!";
+    var result = (0, VariableValueContainingReferences_1.createVariableValueContainingReferencesFromString)(stringValue, {
+      componentName: "myComponent"
+    });
+    expect(result.parts).toEqual(["my component has ", new VariableValueContainingReferences_1.VariableReference("myComponent", "variableName"), " and the other component has ", new VariableValueContainingReferences_1.VariableReference("otherComponent", "variableName"), "!"]);
+  });
+});

package/dist/variables/resolveAllReferences.d.ts

@@ -0,0 +1,3 @@
+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>>;