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

package/lib/component-runner/environment-setup.d.ts

@@ -0,0 +1,17 @@
+import { ComponentInfo } from '@squiz/component-lib';
+declare type EnvironmentVariables = Record<string, string | undefined>;
+export declare class InvalidEnvironmentVariablesError extends Error {
+    readonly errors: [string, string][];
+    constructor(errors: [string, string][]);
+}
+export interface ComponentEnvironmentLoader {
+    getEnvironmentVariables(componentSet: string): Promise<EnvironmentVariables>;
+}
+interface EnvironmentVariableValidation {
+    valid: boolean;
+    errors: [string, string][];
+    variables: EnvironmentVariables;
+}
+export declare function loadEnvironment(info: ComponentInfo, environmentLoader: ComponentEnvironmentLoader): Promise<EnvironmentVariableValidation>;
+export declare function getProcessEnvironmentLoader(): ComponentEnvironmentLoader;
+export {};

package/lib/index.js

@@ -26322,6 +26322,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"
               },
@@ -94185,6 +94191,38 @@ var WorkerPool = class extends import_events.EventEmitter {
 
 // src/component-runner/index.ts
 var import_component_lib2 = __toESM(require_lib7());
+
+// src/component-runner/environment-setup.ts
+var InvalidEnvironmentVariablesError = class extends Error {
+  constructor(errors) {
+    const message2 = errors.map(([variableName, error]) => `"${variableName}" ${error}`).join("; ");
+    super(`Invalid Environment Variables: ${message2}`);
+    this.errors = errors;
+  }
+};
+function validateComponentVariables(functionVariables, environment) {
+  const allVariables = functionVariables.map((v) => [v, environment[v]]);
+  return {
+    valid: functionVariables.every((name) => name in environment),
+    errors: functionVariables.filter((name) => !(name in environment)).map((name) => [name, "is required"]),
+    variables: Object.fromEntries(allVariables)
+  };
+}
+async function loadEnvironment(info, environmentLoader) {
+  const variables = await environmentLoader.getEnvironmentVariables(info.set.name);
+  const functionDef = info.manifest.functions.find((f) => f.name === info.functionName);
+  const variableValidation = validateComponentVariables(functionDef.environment || [], variables);
+  return variableValidation;
+}
+function getProcessEnvironmentLoader() {
+  return {
+    getEnvironmentVariables(_componentSet) {
+      return Promise.resolve(process.env);
+    }
+  };
+}
+
+// src/component-runner/index.ts
 var DEFAULT_WORKER_FILE = import_path.default.resolve(__dirname, "./worker/worker-root.js");
 var ComponentRunner = class {
   static get() {
@@ -94231,7 +94269,20 @@ var ComponentRunner = class {
     this.singleton = void 0;
   }
   static buildExecute(pool, config) {
-    return (executeComponentTask) => {
+    const environmentLoader = config.doDevReload ? getProcessEnvironmentLoader() : {
+      getEnvironmentVariables(_2) {
+        return Promise.resolve({});
+      }
+    };
+    return async (executeComponentTask) => {
+      const {
+        variables: environment,
+        valid,
+        errors
+      } = await loadEnvironment(executeComponentTask.info, environmentLoader);
+      if (!valid) {
+        throw new InvalidEnvironmentVariablesError(errors);
+      }
       return new Promise((resolve, reject) => {
         const callback = (error, data) => {
           if (error || !error && !data) {
@@ -94249,7 +94300,7 @@ var ComponentRunner = class {
             resolve(data);
           }
         };
-        pool.runTask(executeComponentTask, callback, config.workerTimeout ?? 5e3);
+        pool.runTask({ ...executeComponentTask, environment }, callback, config.workerTimeout ?? 5e3);
       });
     };
   }
@@ -95115,10 +95166,10 @@ var _ComponentFixture = class {
     await import_promises2.default.writeFile(import_path6.default.join(componentDirectory, "static", "static.txt"), "hello");
     return { fixtureDirectory, version, componentName: import_path6.default.basename(fixtureDirectory) };
   }
-  static async new(returnObj) {
+  static async new(returnObj, { raw = false, environment = [] } = {}) {
     const tempDir = await import_promises2.default.mkdtemp(import_path6.default.join(_ComponentFixture.getFixtureRootDirectory(), "test-"));
     const componentPath = import_path6.default.join(tempDir, "main.js");
-    const data = jsFileData(returnObj);
+    const data = jsFileData(returnObj, { raw });
     await import_promises2.default.writeFile(componentPath, data);
     return {
       id: import_path6.default.basename(tempDir),
@@ -95130,7 +95181,17 @@ var _ComponentFixture = class {
           version: "1.0.0",
           $schema: "",
           "main-function": "main.js",
-          functions: []
+          functions: [
+            {
+              entry: "main.js",
+              name: "main",
+              environment,
+              input: {},
+              output: {
+                "response-type": "html"
+              }
+            }
+          ]
         },
         set: {
           name: "test-fixture-components",
@@ -95184,7 +95245,10 @@ var _ComponentFixture = class {
 };
 var ComponentFixture = _ComponentFixture;
 ComponentFixture.fixtureRootDirectory = void 0;
-function jsFileData(input) {
+function jsFileData(input, { raw = false } = {}) {
+  if (raw) {
+    return `module.exports = () => ${input}`;
+  }
   if (typeof input === "string") {
     return `module.exports = () => "${input}"`;
   } else {