@squiz/render-runtime-lib 1.2.1-alpha.86 → 1.2.1-alpha.90

package/lib/worker/worker-root.js

@@ -1234,6 +1234,9 @@ var require_acorn = __commonJS({
         if (options.allowReserved == null) {
           options.allowReserved = options.ecmaVersion < 5;
         }
+        if (opts.allowHashBang == null) {
+          options.allowHashBang = options.ecmaVersion >= 14;
+        }
         if (isArray(options.onToken)) {
           var tokens = options.onToken;
           options.onToken = function(token) {
@@ -1480,7 +1483,7 @@ var require_acorn = __commonJS({
         }
         var parens = isAssign ? refDestructuringErrors.parenthesizedAssign : refDestructuringErrors.parenthesizedBind;
         if (parens > -1) {
-          this.raiseRecoverable(parens, "Parenthesized pattern");
+          this.raiseRecoverable(parens, isAssign ? "Assigning to rvalue" : "Parenthesized pattern");
         }
       };
       pp$9.checkExpressionErrors = function(refDestructuringErrors, andThrow) {
@@ -2481,7 +2484,7 @@ var require_acorn = __commonJS({
         }
       };
       pp$8.isDirectiveCandidate = function(statement) {
-        return statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && typeof statement.expression.value === "string" && (this.input[statement.start] === '"' || this.input[statement.start] === "'");
+        return this.options.ecmaVersion >= 5 && statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && typeof statement.expression.value === "string" && (this.input[statement.start] === '"' || this.input[statement.start] === "'");
       };
       var pp$7 = Parser.prototype;
       pp$7.toAssignable = function(node, isBinding, refDestructuringErrors) {
@@ -3545,14 +3548,6 @@ var require_acorn = __commonJS({
             }
             return this.finishNode(prop, "RestElement");
           }
-          if (this.type === types$1.parenL && refDestructuringErrors) {
-            if (refDestructuringErrors.parenthesizedAssign < 0) {
-              refDestructuringErrors.parenthesizedAssign = this.start;
-            }
-            if (refDestructuringErrors.parenthesizedBind < 0) {
-              refDestructuringErrors.parenthesizedBind = this.start;
-            }
-          }
           prop.argument = this.parseMaybeAssign(false, refDestructuringErrors);
           if (this.type === types$1.comma && refDestructuringErrors && refDestructuringErrors.trailingComma < 0) {
             refDestructuringErrors.trailingComma = this.start;
@@ -5627,7 +5622,7 @@ var require_acorn = __commonJS({
         }
         return this.finishToken(type, word);
       };
-      var version = "8.7.1";
+      var version = "8.8.0";
       Parser.acorn = {
         Parser,
         version,
@@ -8107,6 +8102,12 @@ var require_v1 = __commonJS({
                 description: "Function name, this will be used as part of the url to access this function. It must be a valid url"
               },
               entry: { type: "string" },
+              environment: {
+                type: "array",
+                items: {
+                  type: "string"
+                }
+              },
               input: {
                 type: "object"
               },
@@ -8126,8 +8127,58 @@ var require_v1 = __commonJS({
                           additionalProperties: false,
                           properties: {
                             location: { oneOf: [{ const: "header" }, { const: "footer" }] },
-                            file: { type: "string" },
-                            type: { oneOf: [{ const: "library" }] }
+                            file: {
+                              oneOf: [
+                                {
+                                  type: "object",
+                                  title: "JsFile",
+                                  additionalProperties: false,
+                                  properties: {
+                                    type: { const: "js" },
+                                    filepath: { type: "string" },
+                                    defer: { type: "boolean" },
+                                    async: { type: "boolean" },
+                                    crossorigin: { oneOf: [{ const: "anonymous" }, { const: "use-credentials" }] },
+                                    referrerpolicy: {
+                                      oneOf: [
+                                        { const: "no-referrer" },
+                                        { const: "no-referrer-when-downgrade" },
+                                        { const: "origin" },
+                                        { const: "origin-when-cross-origin" },
+                                        { const: "same-origin" },
+                                        { const: "strict-origin" },
+                                        { const: "strict-origin-when-cross-origin" },
+                                        { const: "unsafe-url" }
+                                      ]
+                                    }
+                                  },
+                                  required: ["filepath", "type"]
+                                },
+                                {
+                                  type: "object",
+                                  title: "CssFile",
+                                  additionalProperties: false,
+                                  properties: {
+                                    type: { const: "css" },
+                                    filepath: { type: "string" },
+                                    crossorigin: { oneOf: [{ const: "anonymous" }, { const: "use-credentials" }] },
+                                    referrerpolicy: {
+                                      oneOf: [
+                                        { const: "no-referrer" },
+                                        { const: "no-referrer-when-downgrade" },
+                                        { const: "origin" },
+                                        { const: "origin-when-cross-origin" },
+                                        { const: "same-origin" },
+                                        { const: "strict-origin" },
+                                        { const: "strict-origin-when-cross-origin" },
+                                        { const: "unsafe-url" }
+                                      ]
+                                    }
+                                  },
+                                  required: ["filepath"]
+                                }
+                              ]
+                            }
                           },
                           required: ["location", "file"]
                         }
@@ -8154,7 +8205,10 @@ var require_v1 = __commonJS({
       },
       required: ["name", "version", "functions", "$schema", "main-function"],
       $defs: {
-        "name-pattern": { pattern: "^[a-zA-Z0-9_\\-]+$" }
+        "name-pattern": {
+          type: "string",
+          pattern: "^[a-zA-Z0-9_\\-]+$"
+        }
       }
     };
   }
@@ -14815,7 +14869,7 @@ var require_schemas = __commonJS({
     exports.schemaVersions = exports.schemaVersionRegex = void 0;
     var v1_json_1 = __importDefault(require_v1());
     var ajv_1 = __importDefault(require_ajv());
-    var ajv = new ajv_1.default();
+    var ajv = new ajv_1.default({ allErrors: true });
     exports.schemaVersionRegex = /\/(?<schema>\w+)\.json#?$/i;
     exports.schemaVersions = { v1: v1_json_1.default };
     for (const [version, schema] of Object.entries(exports.schemaVersions)) {
@@ -22814,6 +22868,7 @@ var require_LoadedComponent = __commonJS({
     var isValidationFailure_1 = require_isValidationFailure();
     var never_1 = require_never();
     var types_1 = require("util/types");
+    var ajv = new ajv_1.default({ allErrors: true, strict: true, strictTypes: true });
     var LoadedComponent = class {
       constructor(manifest, componentFilesRoot, componentRootUrl, componentExecutor) {
         this.manifest = manifest;
@@ -22821,12 +22876,17 @@ var require_LoadedComponent = __commonJS({
         this.componentRootUrl = componentRootUrl;
         this.componentExecutor = componentExecutor;
         this.mainFunction = manifest["main-function"];
-        this.ajv = new ajv_1.default({ allErrors: true });
         for (const func of manifest.functions) {
           const slug = this.getFunctionComponentSlug(func.name);
           const output = this.getOutputValidationSchema(func.output, manifest);
-          this.ajv.addSchema(func.input, `${slug}-input`);
-          this.ajv.addSchema(output, `${slug}-output`);
+          const inputSchemaName = `${slug}-input`;
+          const outputSchemaName = `${slug}-output`;
+          if (ajv.schemas[inputSchemaName] === void 0) {
+            ajv.addSchema(func.input, inputSchemaName);
+          }
+          if (ajv.schemas[outputSchemaName] === void 0) {
+            ajv.addSchema(output, outputSchemaName);
+          }
         }
       }
       componentHasFunction(functionName) {
@@ -22883,7 +22943,7 @@ var require_LoadedComponent = __commonJS({
           throw new Error(`input value for ${functionName} cannot be undefined`);
         }
         const slug = this.getFunctionComponentSlug(functionName);
-        const validator = this.ajv.getSchema(`${slug}-input`);
+        const validator = ajv.getSchema(`${slug}-input`);
         if (!validator) {
           throw new Error(`${functionName} has no input schema registered`);
         }
@@ -22892,7 +22952,7 @@ var require_LoadedComponent = __commonJS({
       }
       validateOutput(functionName, output) {
         const slug = this.getFunctionComponentSlug(functionName);
-        const validator = this.ajv.getSchema(`${slug}-output`);
+        const validator = ajv.getSchema(`${slug}-output`);
         if (!validator) {
           throw new Error(`${functionName} has no output schema registered`);
         }
@@ -23201,11 +23261,11 @@ var require_loadComponent = __commonJS({
       const staticFileRoot = path_1.default.join(componentRoot, staticFileLocationRoot);
       const staticFiles = func.output["static-files"] || [];
       for (const staticFile of staticFiles) {
-        if (staticFile.file.startsWith("http://") || staticFile.file.startsWith("https://")) {
+        if (staticFile.file.filepath.startsWith("http://") || staticFile.file.filepath.startsWith("https://")) {
           continue;
         }
-        if ((0, isPathTryingToAccessOutsideOfRoot_1.isPathTryingToAccessOutsideOfRoot)(staticFileRoot, staticFile.file) || !await isReadable(staticFileRoot, staticFile.file)) {
-          throw new Error(`access to a static file "${staticFile.file}" for "${func.name}" outside the parent directory in "${manifest.name} ${manifest.version}" is not alllowed`);
+        if ((0, isPathTryingToAccessOutsideOfRoot_1.isPathTryingToAccessOutsideOfRoot)(staticFileRoot, staticFile.file.filepath) || !await isReadable(staticFileRoot, staticFile.file.filepath)) {
+          throw new Error(`access to a static file "${staticFile.file.filepath}" for "${func.name}" outside the parent directory in "${manifest.name} ${manifest.version}" is not alllowed`);
         }
       }
     }
@@ -40698,6 +40758,432 @@ var require_getNodeEnv = __commonJS({
   }
 });
 
+// ../component-lib/lib/component-service/services/ComponentService.js
+var require_ComponentService = __commonJS({
+  "../component-lib/lib/component-service/services/ComponentService.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ComponentService = void 0;
+    var path_1 = __importDefault(require("path"));
+    var fs_extra_1 = __importDefault(require_lib4());
+    var error_1 = require_error();
+    var validateManifest_1 = require_validateManifest();
+    var ComponentService = class {
+      constructor(db, logger, dataMountPoint) {
+        this.db = db;
+        this.logger = logger;
+        this.dataMountPoint = dataMountPoint;
+      }
+      async saveComponent(componentLocation) {
+        const manifest = await this.readManifest(componentLocation);
+        this.assertManifestIsValid(manifest);
+        if (await this.componentVersionExists(manifest.name, manifest.version)) {
+          throw new error_1.BadRequestError(`Component ${manifest.name} ${manifest.version} already exists`);
+        }
+        const destPath = await this.getValidComponentDestinationPath(manifest);
+        await this.moveFilesAndUpdateDb(manifest, componentLocation, destPath);
+      }
+      async componentVersionExists(name, version) {
+        const componentVersion = await this.db.repositories.componentVersion.getComponentByNameAndVersion(name, version);
+        return componentVersion !== void 0;
+      }
+      async deleteComponent(componentName) {
+        this.assertValidComponentName(componentName);
+        await this.assertComponentExists(componentName);
+        const compPath = path_1.default.join(this.dataMountPoint, componentName);
+        try {
+          await this.db.repositories.componentVersion.delete({ componentName });
+        } catch (e) {
+          this.logger.error(e);
+        }
+        try {
+          await this.db.repositories.component.delete({ name: componentName });
+        } catch (e) {
+          this.logger.error(e);
+        }
+        try {
+          await fs_extra_1.default.rm(compPath, { force: true, recursive: true });
+        } catch (e) {
+          this.logger.error(e);
+        }
+        const componentExists = await this.db.repositories.component.componentExists(componentName);
+        const filesExist = await fs_extra_1.default.pathExists(compPath);
+        if (componentExists) {
+          throw new Error(`failed to remove ${componentName} from DB`);
+        }
+        if (filesExist) {
+          throw new Error(`failed to remove ${componentName} files from the disk`);
+        }
+      }
+      async deleteComponentVersion(componentName, version) {
+        this.assertValidComponentVersion(componentName, version);
+        await this.assertComponentVersionExists(componentName, version);
+        const compVersionPath = path_1.default.join(this.dataMountPoint, componentName, version);
+        try {
+          await this.db.repositories.componentVersion.delete({ componentName, version });
+          await fs_extra_1.default.rm(compVersionPath, { force: true, recursive: true });
+        } catch (e) {
+          this.logger.error(e);
+        }
+        const componentVersionExists = await this.db.repositories.componentVersion.componentVersionExists(componentName, version);
+        const filesExist = await fs_extra_1.default.pathExists(compVersionPath);
+        if (componentVersionExists) {
+          throw new Error(`failed to remove ${componentName} from DB`);
+        }
+        if (filesExist) {
+          throw new Error(`failed to remove ${componentName} files from the disk`);
+        }
+      }
+      assertValidComponentName(componentName) {
+        const rootDir = path_1.default.resolve(this.dataMountPoint);
+        const compPath = path_1.default.join(this.dataMountPoint, componentName);
+        const checkPath = path_1.default.resolve(this.dataMountPoint) + path_1.default.sep + componentName;
+        if (checkPath !== compPath || rootDir === compPath) {
+          throw new error_1.ResourceNotFoundError(`component name ${componentName} is invalid`);
+        }
+      }
+      assertValidComponentVersion(componentName, version) {
+        const versionPath = path_1.default.join(this.dataMountPoint, componentName, version);
+        const checkPath = [path_1.default.resolve(this.dataMountPoint), componentName, version].join(path_1.default.sep);
+        if (checkPath !== versionPath) {
+          throw new error_1.ResourceNotFoundError(`Component version ${version} is invalid`);
+        }
+      }
+      async assertComponentExists(componentName) {
+        const compPath = path_1.default.join(this.dataMountPoint, componentName);
+        if (!await this.db.repositories.component.componentExists(componentName) && !await fs_extra_1.default.pathExists(compPath)) {
+          throw new error_1.ResourceNotFoundError(`Component ${componentName} not found`);
+        }
+      }
+      async assertComponentVersionExists(componentName, version) {
+        await this.assertComponentExists(componentName);
+        const compVersionPath = path_1.default.join(this.dataMountPoint, componentName, version);
+        if (!await this.db.repositories.componentVersion.componentVersionExists(componentName, version) && !await fs_extra_1.default.pathExists(compVersionPath)) {
+          throw new error_1.ResourceNotFoundError(`Component version ${version} for component ${componentName} not found`);
+        }
+      }
+      async moveFilesAndUpdateDb(manifest, location, destPath) {
+        try {
+          await fs_extra_1.default.move(location, destPath, {
+            overwrite: false
+          });
+          await fs_extra_1.default.chmod(destPath, "755");
+        } catch (e) {
+          fs_extra_1.default.rm(location, { force: true, recursive: true });
+          throw e;
+        }
+        try {
+          await this.addComponentVersion(manifest);
+        } catch (e) {
+          fs_extra_1.default.rm(destPath, { force: true, recursive: true });
+          throw e;
+        }
+      }
+      async addComponentVersion(manifest) {
+        if (await this.db.repositories.component.componentExists(manifest.name) === false) {
+          await this.db.repositories.component.addComponent(manifest.name);
+        }
+        await this.db.repositories.componentVersion.addComponentVersion(manifest.name, manifest.version);
+      }
+      async getValidComponentDestinationPath(manifest) {
+        const destPath = path_1.default.join(this.dataMountPoint, manifest.name, manifest.version);
+        const pathExists = await fs_extra_1.default.pathExists(destPath);
+        if (pathExists) {
+          throw new error_1.BadRequestError(`${manifest.name} version ${manifest.version} already exists and cannot be uploaded`);
+        }
+        return destPath;
+      }
+      assertManifestIsValid(manifest) {
+        const manifestValidationResult = (0, validateManifest_1.validateManifest)(manifest);
+        if (manifestValidationResult.isValid == false) {
+          throw new error_1.BadRequestError(`uploaded manifest is invalid, "${manifestValidationResult.message}"`);
+        }
+      }
+      async readManifest(location) {
+        const manifest = await fs_extra_1.default.readJson(path_1.default.join(location, "manifest.json"), { encoding: "utf-8" });
+        return manifest;
+      }
+    };
+    exports.ComponentService = ComponentService;
+  }
+});
+
+// ../component-lib/lib/component-service/services/ComponentSetService.js
+var require_ComponentSetService = __commonJS({
+  "../component-lib/lib/component-service/services/ComponentSetService.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ComponentSetService = void 0;
+    var error_1 = require_error();
+    var ComponentSetService = class {
+      constructor(db, logger) {
+        this.db = db;
+        this.logger = logger;
+      }
+      async addComponentSet(componentSet) {
+        await this.assertValidCreateComponentSet(componentSet);
+        try {
+          const createdSet = await this.db.executeInTransaction(async (client) => {
+            const set = await this.db.repositories.componentSet.create({
+              webPath: componentSet.webPath,
+              displayName: componentSet.displayName,
+              description: componentSet.description,
+              envVars: componentSet.envVars,
+              headers: componentSet.headers
+            }, client);
+            await this.saveComponentSetComponets(componentSet.webPath, componentSet.components, client);
+            return set;
+          });
+          const savedSet = await this.getComponentSet(createdSet.webPath);
+          return savedSet;
+        } catch (e) {
+          this.logger.error(`Error occurred when updating component set ${componentSet.webPath}: ${e}`);
+          throw e;
+        }
+      }
+      async updateComponentSet(webPath, data) {
+        const existing = await this.db.repositories.componentSet.getComponentSetByWebPath(webPath);
+        if (!existing) {
+          throw new error_1.ResourceNotFoundError(`Component set with web path ${webPath} does not exist`);
+        }
+        await this.assertValidComponentSet(data, this.normalise(existing, await this.getExistingComponents(webPath)));
+        const values = {};
+        if (data.displayName !== void 0) {
+          values.displayName = data.displayName;
+        }
+        if (data.description !== void 0) {
+          values.description = data.description;
+        }
+        if (data.headers !== void 0) {
+          values.headers = data.headers;
+        }
+        if (data.envVars !== void 0) {
+          values.envVars = data.envVars;
+        }
+        try {
+          await this.db.executeInTransaction(async (client) => {
+            if (Object.keys(values).length > 0) {
+              await this.db.repositories.componentSet.update({ webPath }, values, client);
+            }
+            if (data.components !== void 0) {
+              await this.saveComponentSetComponets(webPath, data.components, client);
+            }
+          });
+          return this.getComponentSet(webPath);
+        } catch (e) {
+          this.logger.error(`Error occurred when updating component set ${webPath}: ${e}`);
+          throw e;
+        }
+      }
+      async getComponentSet(webPath) {
+        const set = await this.db.repositories.componentSet.getComponentSetByWebPath(webPath);
+        if (set === void 0) {
+          throw new error_1.ResourceNotFoundError(`Component set with web path ${webPath} does not exist`);
+        }
+        return this.normalise(set, await this.getExistingComponents(webPath));
+      }
+      async deleteComponentSet(webPath) {
+        if (!await this.db.repositories.componentSet.componentSetExists(webPath)) {
+          throw new error_1.ResourceNotFoundError(`Component set with web path ${webPath} does not exist`);
+        }
+        return await this.db.repositories.componentSet.delete({ webPath });
+      }
+      normalise(set, components) {
+        var _a, _b, _c, _d, _e;
+        return {
+          webPath: (_a = set.webPath) !== null && _a !== void 0 ? _a : "",
+          displayName: (_b = set.displayName) !== null && _b !== void 0 ? _b : "",
+          description: (_c = set.description) !== null && _c !== void 0 ? _c : "",
+          envVars: (_d = set.envVars) !== null && _d !== void 0 ? _d : {},
+          headers: (_e = set.headers) !== null && _e !== void 0 ? _e : {},
+          components: components !== null && components !== void 0 ? components : {}
+        };
+      }
+      async saveComponentSetComponets(webPath, components, client = null) {
+        const existingComponents = [];
+        Object.entries(await this.getExistingComponents(webPath)).forEach(([cn, cvs]) => {
+          cvs.forEach((cv) => {
+            existingComponents.push({ componentName: cn, info: cv });
+          });
+        });
+        const inputComponents = [];
+        Object.entries(components).forEach(([cn, cvs]) => {
+          cvs.forEach((cv) => {
+            inputComponents.push({ componentName: cn, info: cv });
+          });
+        });
+        const toDelete = existingComponents.filter((ec) => !inputComponents.find((c) => ec.componentName === c.componentName && ec.info.version === c.info.version));
+        const toCreate = inputComponents.filter((c) => !existingComponents.find((ec) => ec.componentName === c.componentName && ec.info.version === c.info.version));
+        const toUpdate = inputComponents.filter((c) => existingComponents.find((ec) => ec.componentName === c.componentName && ec.info.version === c.info.version && JSON.stringify(ec.info.envVars) !== JSON.stringify(c.info.envVars)));
+        const repo = this.db.repositories.componentSetComponentVersion;
+        const toDeletePromises = toDelete.map((c) => repo.delete({
+          componentSetWebPath: webPath,
+          componentName: c.componentName,
+          componentVersion: c.info.version
+        }, client));
+        const toCreatePromises = toCreate.map((c) => {
+          var _a;
+          return repo.create({
+            componentSetWebPath: webPath,
+            componentName: c.componentName,
+            componentVersion: c.info.version,
+            envVars: (_a = c.info.envVars) !== null && _a !== void 0 ? _a : {}
+          }, client);
+        });
+        const toUpdatePromises = toUpdate.map((c) => {
+          var _a;
+          return repo.update({
+            componentSetWebPath: webPath,
+            componentName: c.componentName,
+            componentVersion: c.info.version
+          }, {
+            envVars: (_a = c.info.envVars) !== null && _a !== void 0 ? _a : {}
+          }, client);
+        });
+        await Promise.all([...toDeletePromises, ...toCreatePromises, ...toUpdatePromises]);
+      }
+      async getExistingComponents(webPath) {
+        const dbEntries = await this.db.repositories.componentSetComponentVersion.find({ componentSetWebPath: webPath });
+        const components = {};
+        dbEntries.forEach((row) => {
+          var _a;
+          if (components[row.componentName] === void 0) {
+            components[row.componentName] = [];
+          }
+          components[row.componentName].push({
+            version: row.componentVersion,
+            envVars: (_a = row.envVars) !== null && _a !== void 0 ? _a : {}
+          });
+        });
+        Object.entries(components).forEach(([key, versions]) => {
+          components[key] = versions.sort((a, b) => {
+            if (a.version < b.version)
+              return -1;
+            if (a.version > b.version)
+              return 1;
+            return 0;
+          });
+        });
+        return components;
+      }
+      async assertValidCreateComponentSet(componentSet) {
+        if (!componentSet.webPath) {
+          throw new error_1.BadRequestError("Component set 'webPath' must be specificed and non-empty");
+        }
+        if (!componentSet.displayName) {
+          throw new error_1.BadRequestError("Component set 'displayName' must be specificed and non-empty");
+        }
+        this.assertValidWebPath(componentSet.webPath);
+        if (await this.db.repositories.componentSet.componentSetExists(componentSet.webPath)) {
+          throw new error_1.BadRequestError(`Component set with web path ${componentSet.webPath} already exists`);
+        }
+        await this.assertValidComponentSet(componentSet);
+      }
+      async assertValidComponentSet(componentSet, currentComponentSet = void 0) {
+        var _a;
+        if (componentSet.envVars !== void 0) {
+          this.assertValidEnvVars(componentSet.envVars);
+        }
+        if (componentSet.headers !== void 0) {
+          this.assertValidHeaders(componentSet.headers);
+        }
+        if (componentSet.components !== void 0) {
+          const csEnvVars = (_a = componentSet.envVars) !== null && _a !== void 0 ? _a : currentComponentSet ? currentComponentSet.envVars : {};
+          await this.assertValidComponents(componentSet.components, csEnvVars);
+        }
+      }
+      assertValidWebPath(webPath) {
+        if (webPath.replace(/[^a-z0-9\-_.]/i, "") !== webPath) {
+          throw new error_1.BadRequestError("Invalid Component Set web path. Only [A-Za-z0-9_-.] chars are allowed");
+        }
+      }
+      assertValidEnvVars(envVars) {
+        Object.entries(envVars).forEach(([envVarName, envVarValue]) => {
+          if (envVarName.replace(/[^a-z0-9\-_.]/i, "") !== envVarName) {
+            throw new error_1.BadRequestError(`Invalid env var '${envVarName}'. Only [A-Za-z0-9_-.] chars are allowed`);
+          }
+          if (typeof envVarValue !== "string") {
+            throw new error_1.BadRequestError(`Env var '${envVarName}' value must be a string`);
+          }
+        });
+      }
+      assertValidHeaders(_headers) {
+      }
+      async assertValidComponents(components, componentSetEnvVars) {
+        const repo = this.db.repositories.componentVersion;
+        for (const [componentName, versions] of Object.entries(components)) {
+          if (!componentName) {
+            throw new error_1.BadRequestError(`Component name must be non-empty`);
+          }
+          const setVersions = [];
+          for (const v of versions) {
+            if (!v.version) {
+              throw new error_1.BadRequestError(`Component version must set and be non-empty`);
+            }
+            if (setVersions.includes(v.version)) {
+              throw new error_1.BadRequestError(`Multiple componet version entries for component ${componentName} with version ${v.version}`);
+            }
+            setVersions.push(v.version);
+            if (v.envVars !== void 0) {
+              this.assertValidEnvVars(v.envVars);
+              const unknownEnvVars = Object.keys(v.envVars).filter((ev) => !Object.keys(componentSetEnvVars).includes(ev));
+              if (unknownEnvVars.length) {
+                throw new error_1.BadRequestError(`Env var(s) '${unknownEnvVars.join("', '")}' defined on component ${componentName} with version ${v.version} is/are not defined on the component set`);
+              }
+            }
+            if (!await repo.componentVersionExists(componentName, v.version)) {
+              throw new error_1.BadRequestError(`Component ${componentName} with version ${v.version} does not exists`);
+            }
+          }
+        }
+      }
+      async getAllComponentSets() {
+        const rows = await this.db.repositories.componentSet.findAll();
+        const componentSets = [];
+        for (const row of rows) {
+          const components = await this.getExistingComponents(row.webPath);
+          componentSets.push(this.normalise(row, components));
+        }
+        return componentSets;
+      }
+    };
+    exports.ComponentSetService = ComponentSetService;
+  }
+});
+
+// ../component-lib/lib/component-service/services/index.js
+var require_services = __commonJS({
+  "../component-lib/lib/component-service/services/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        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 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_ComponentService(), exports);
+    __exportStar(require_ComponentSetService(), exports);
+  }
+});
+
 // ../component-lib/lib/index.js
 var require_lib6 = __commonJS({
   "../component-lib/lib/index.js"(exports) {
@@ -40723,7 +41209,7 @@ var require_lib6 = __commonJS({
           __createBinding(exports2, m, p);
     };
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.transformResponseForLogging = exports.transformRequestForLogging = exports.errorMiddleware = exports.schemaVersions = void 0;
+    exports.test = exports.ComponentSetService = exports.ComponentService = exports.transformResponseForLogging = exports.transformRequestForLogging = exports.errorMiddleware = exports.schemaVersions = void 0;
     __exportStar(require_validateManifest(), exports);
     var schemas_1 = require_schemas();
     Object.defineProperty(exports, "schemaVersions", { enumerable: true, get: function() {
@@ -40756,6 +41242,17 @@ var require_lib6 = __commonJS({
     __exportStar(require_parseEnvVarForVar(), exports);
     __exportStar(require_getNodeEnv(), exports);
     __exportStar(require_isPathTryingToAccessOutsideOfRoot(), exports);
+    var services_1 = require_services();
+    Object.defineProperty(exports, "ComponentService", { enumerable: true, get: function() {
+      return services_1.ComponentService;
+    } });
+    Object.defineProperty(exports, "ComponentSetService", { enumerable: true, get: function() {
+      return services_1.ComponentSetService;
+    } });
+    function test() {
+      console.log("a");
+    }
+    exports.test = test;
   }
 });
 
@@ -40792,7 +41289,7 @@ var vm = new import_vm2.NodeVM({
 var script = new import_vm2.VMScript(` const events = require('events');
     const asyncHooks = require('async_hooks');
 
-    module.exports = function(id, entry, input, info){
+    module.exports = function(id, entry, input, info, environment = {}){
       const emitter = new events.EventEmitter();
 
       setImmediate(()=>{
@@ -40820,6 +41317,9 @@ var script = new import_vm2.VMScript(` const events = require('events');
           return (activeResources);
         }
           
+
+          // Should we override this or merge then unmerge?
+          process.env = environment;
           let script = require(entry);
 
           if(typeof script === 'object') {
@@ -40879,7 +41379,7 @@ if (import_worker_threads.parentPort) {
   });
   import_worker_threads.parentPort.on("message", async (task) => {
     var _a;
-    const data = await executeComponent(task.path, task.id, task.input, task.info);
+    const data = await executeComponent(task);
     (_a = import_worker_threads.parentPort) == null ? void 0 : _a.postMessage(data);
   });
 } else {
@@ -40889,14 +41389,14 @@ var executeComponentFunc = vm.run(script, {
   strict: false,
   wrapper: "commonjs"
 });
-async function executeComponent(entry, id, input, info) {
+async function executeComponent({ path: entry, id, input, info, environment }) {
   return new Promise((resolve, reject) => {
     const componentContext = {
       manifest: info.manifest,
       set: info.set,
       ctx: (0, import_component_lib.createComponentContext)(info.manifest.name, info.manifest.version, info.componentRoot, info.set)
     };
-    const componentExecutionWatcher = executeComponentFunc(id, entry, input, componentContext);
+    const componentExecutionWatcher = executeComponentFunc(id, entry, input, componentContext, environment || {});
     componentExecutionWatcher.on("console", (args) => {
       var _a;
       const message = JSON.parse(JSON.stringify(args.message));