@squiz/job-runner-lib 1.66.1

package/src/domains/component-set/services/ComponentSetService.spec.ts

@@ -0,0 +1,144 @@
+import { ComponentSetComponentVersionInterface } from '../models/ComponentSetComponentVersion';
+import { ComponentSetWebModel } from '../web-models/ComponentSetForWeb';
+import { AbstractComponentSetService } from './ComponentSetService';
+import { PageQueryResult } from '@squiz/dx-common-lib';
+import { ComponentSet, ComponentSetInterface } from '../models/ComponentSet';
+import { RuntimeComponentSet } from './RuntimeComponentSet';
+import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
+
+type ComponentFunction = MANIFEST_MODELS.v1.ComponentFunction;
+
+class TestAbstractComponentSetService extends AbstractComponentSetService {
+  getComponentSet(): Promise<ComponentSet> {
+    throw new Error('Method not implemented.');
+  }
+  getComponentsRuntimeSetData(): Promise<RuntimeComponentSet> {
+    throw new Error('Method not implemented.');
+  }
+  addComponentSet(): Promise<ComponentSetWebModel> {
+    throw new Error('Method not implemented.');
+  }
+  updateComponentSet(): Promise<ComponentSetWebModel> {
+    throw new Error('Method not implemented.');
+  }
+  getComponentSetWebModel(): Promise<ComponentSetWebModel> {
+    throw new Error('Method not implemented.');
+  }
+  componentVersionInSet(): Promise<boolean> {
+    throw new Error('Method not implemented.');
+  }
+  deleteComponentSet(): Promise<number> {
+    throw new Error('Method not implemented.');
+  }
+  getAllComponentSets(): Promise<ComponentSetWebModel[]> {
+    throw new Error('Method not implemented.');
+  }
+  addComponentToSet(
+    _webPath: string,
+    _componentName: string,
+    _componentVersion: string,
+  ): Promise<ComponentSetComponentVersionInterface> {
+    throw new Error('Method not implemented.');
+  }
+  getPaginatedComponentSets(
+    _pageNumber: number,
+    _sortBy: (keyof ComponentSetInterface)[],
+  ): Promise<PageQueryResult<ComponentSetWebModel>> {
+    throw new Error('Method not implemented.');
+  }
+  componentVersionExcludedFromSet(
+    _webPath: string,
+    _componentName: string,
+    _componentVersion: string,
+  ): Promise<boolean> {
+    throw new Error('Method not implemented.');
+  }
+}
+
+describe('AbstractComponentSetService', () => {
+  const service = new TestAbstractComponentSetService();
+
+  describe('getComponentRuntimeHeaders', () => {
+    it('should not return any headers if no headers are set', () => {
+      const set: ComponentSet = {
+        webPath: 'my-set',
+        displayName: 'some-display-name',
+        description: 'some-description',
+        environmentVariables: {},
+        headers: {},
+      };
+      const componentFn: ComponentFunction = {
+        output: {
+          responseType: 'html',
+        },
+        entry: 'some-entry',
+        name: 'some-name',
+        input: {},
+      };
+      const runtimeSetHeaders = service.getComponentRuntimeHeaders(set, componentFn);
+
+      expect(runtimeSetHeaders).toEqual({});
+    });
+
+    it('should return headers set on function definition if component set has no headers set', () => {
+      const set: ComponentSet = {
+        webPath: 'my-set',
+        displayName: 'some-display-name',
+        description: 'some-description',
+        environmentVariables: {},
+        headers: {},
+      };
+      const componentFn: ComponentFunction = {
+        output: {
+          responseType: 'html',
+          headers: {
+            foo: 'bar',
+            foo2: 'bar2',
+          },
+        },
+        entry: 'some-entry',
+        name: 'some-name',
+        input: {},
+      };
+      const runtimeSetHeaders = service.getComponentRuntimeHeaders(set, componentFn);
+
+      expect(runtimeSetHeaders).toEqual({
+        foo: 'bar',
+        foo2: 'bar2',
+      });
+    });
+
+    it('should ovrride the headers set in function definition by the headers in the component set ', () => {
+      const set: ComponentSet = {
+        webPath: 'my-set',
+        displayName: 'some-display-name',
+        description: 'some-description',
+        environmentVariables: {},
+        headers: {
+          foo: 's-bar',
+          foo3: 's-bar3',
+        },
+      };
+      const componentFn: ComponentFunction = {
+        output: {
+          responseType: 'html',
+          headers: {
+            foo: 'f-bar',
+            foo2: 'f-bar2',
+            foo3: 'f-bar3',
+          },
+        },
+        entry: 'some-entry',
+        name: 'some-name',
+        input: {},
+      };
+      const runtimeSetHeaders = service.getComponentRuntimeHeaders(set, componentFn);
+
+      expect(runtimeSetHeaders).toEqual({
+        foo: 's-bar',
+        foo2: 'f-bar2',
+        foo3: 's-bar3',
+      });
+    });
+  });
+});

package/src/domains/component-set/services/ComponentSetService.ts

@@ -0,0 +1,82 @@
+import { ComponentSetComponentVersionInterface } from '../models/ComponentSetComponentVersion';
+import { Manifest } from '../../manifest/ManifestModel';
+import {
+  ComponentSetWebModel,
+  ComponentSetWebModelForCreate,
+  ComponentSetWebModelForUpdate,
+} from '../web-models/ComponentSetForWeb';
+import { RuntimeComponentSet } from './RuntimeComponentSet';
+import { PageQueryResult } from '@squiz/dx-common-lib';
+import { ComponentSet, ComponentSetInterface } from '../models/ComponentSet';
+import { SortDirection } from '@squiz/db-lib';
+import { Headers } from './Headers';
+import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
+
+export interface ComponentSetService {
+  addComponentSet(componentSet: ComponentSetWebModelForCreate, userId?: string): Promise<ComponentSetWebModel>;
+  updateComponentSet(
+    webPath: string,
+    data: ComponentSetWebModelForUpdate,
+    userId?: string,
+  ): Promise<ComponentSetWebModel>;
+  getComponentSetWebModel(webPath: string): Promise<ComponentSetWebModel>;
+
+  getComponentSet(webPath: string): Promise<ComponentSet>;
+
+  componentVersionInSet(manifest: Manifest, webPath: string): Promise<boolean>;
+  deleteComponentSet(webPath: string, userId?: string): Promise<number>;
+  getAllComponentSets(): Promise<ComponentSetWebModel[]>;
+  getComponentsRuntimeSetData(manifest: Manifest, set: ComponentSet): Promise<RuntimeComponentSet>;
+  getComponentRuntimeHeaders(set: ComponentSet, componentFn: MANIFEST_MODELS.v1.ComponentFunction): Headers;
+  addComponentToSet(
+    webPath: string,
+    componentName: string,
+    componentVersion: string,
+    userId?: string,
+  ): Promise<ComponentSetComponentVersionInterface>;
+  getPaginatedComponentSets(
+    pageNumber: number,
+    sortBy: (keyof ComponentSetInterface)[] | undefined,
+    sortDirection: SortDirection | undefined,
+  ): Promise<PageQueryResult<ComponentSetWebModel>>;
+  componentVersionExcludedFromSet(webPath: string, componentName: string, componentVersion: string): Promise<boolean>;
+}
+
+export abstract class AbstractComponentSetService implements ComponentSetService {
+  abstract getComponentSet(webPath: string): Promise<ComponentSet>;
+  abstract addComponentSet(componentSet: ComponentSetWebModelForCreate, userId?: string): Promise<ComponentSetWebModel>;
+  abstract updateComponentSet(
+    webPath: string,
+    data: ComponentSetWebModelForUpdate,
+    userId?: string,
+  ): Promise<ComponentSetWebModel>;
+  abstract getComponentSetWebModel(webPath: string): Promise<ComponentSetWebModel>;
+  abstract componentVersionInSet(manifest: Manifest, webPath: string): Promise<boolean>;
+  abstract deleteComponentSet(webPath: string, userId?: string): Promise<number>;
+  abstract getAllComponentSets(): Promise<ComponentSetWebModel[]>;
+  abstract addComponentToSet(
+    webPath: string,
+    componentName: string,
+    componentVersion: string,
+    userId?: string,
+  ): Promise<ComponentSetComponentVersionInterface>;
+  abstract getPaginatedComponentSets(
+    pageNumber: number,
+    sortBy: (keyof ComponentSetInterface)[] | undefined,
+    sortDirection: SortDirection | undefined,
+  ): Promise<PageQueryResult<ComponentSetWebModel>>;
+  abstract componentVersionExcludedFromSet(
+    webPath: string,
+    componentName: string,
+    componentVersion: string,
+  ): Promise<boolean>;
+
+  abstract getComponentsRuntimeSetData(manifest: Manifest, set: ComponentSet): Promise<RuntimeComponentSet>;
+
+  getComponentRuntimeHeaders(set: ComponentSet, componentFn: MANIFEST_MODELS.v1.ComponentFunction): Headers {
+    const componentHeaders = componentFn.output.headers ?? {};
+    const setHeaders = set.headers ?? {};
+
+    return { ...componentHeaders, ...setHeaders };
+  }
+}

package/src/domains/component-set/services/ComponentSetServiceForLocalDev.spec.ts

@@ -0,0 +1,209 @@
+import { MethodNotImplementedError } from '@squiz/dx-common-lib';
+
+import { getLogger, Logger } from '@squiz/dx-logger-lib';
+import path from 'path';
+import { ManifestServiceForDev } from '../../manifest';
+import { ComponentSetServiceForLocalDev } from './ComponentSetServiceForLocalDev';
+
+const logger: Logger = getLogger({
+  name: 'component-lib',
+});
+describe('environment loading for ComponentSetServiceForLocalDev', () => {
+  const compSetServiceLocal = new ComponentSetServiceForLocalDev(logger);
+  const componentRoot = path.join(__dirname, '..', '..', '..', '..', '..', '..', 'test-components');
+  const manifestService = new ManifestServiceForDev(componentRoot, logger);
+
+  describe('updateComponentSet', () => {
+    it('should throw a not implemented error', async () => {
+      await expect(() => compSetServiceLocal.updateComponentSet()).rejects.toThrowError(
+        new MethodNotImplementedError(`updateComponentSet is not implemented for local development`),
+      );
+    });
+  });
+
+  describe('getAllComponentSets', () => {
+    it('should throw a not implemented error', async () => {
+      await expect(() => compSetServiceLocal.getAllComponentSets()).rejects.toThrowError(
+        new MethodNotImplementedError(`getAllComponentSets is not implemented for local development`),
+      );
+    });
+  });
+
+  describe('addComponentSet', () => {
+    it('should throw a not implemented error', async () => {
+      await expect(() => compSetServiceLocal.addComponentSet()).rejects.toThrowError(
+        new MethodNotImplementedError(`addComponentSet is not implemented for local development`),
+      );
+    });
+  });
+
+  describe('deleteComponentSet', () => {
+    it('should throw a not implemented error', async () => {
+      await expect(() => compSetServiceLocal.deleteComponentSet()).rejects.toThrowError(
+        new MethodNotImplementedError(`deleteComponentSet is not implemented for local development`),
+      );
+    });
+  });
+
+  describe('getPaginatedComponentSets', () => {
+    it('should throw a not implemented error', async () => {
+      await expect(() => compSetServiceLocal.getPaginatedComponentSets()).rejects.toThrowError(
+        new MethodNotImplementedError(`getPaginatedComponentSets is not implemented for local development`),
+      );
+    });
+  });
+
+  describe('getComponentSet', () => {
+    it('should return a debug set, with the passed in web-path and all available env vars', async () => {
+      process.env.MY_CUSTOM_VAR = 'exists';
+      const { environmentVariables, ...set } = await compSetServiceLocal.getComponentSetWebModel('custom-path');
+
+      expect(set).toEqual({
+        webPath: 'custom-path',
+        componentVersionRules: {},
+        components: {},
+        description: 'debug set',
+        displayName: 'set',
+        headers: {},
+      });
+
+      expect(environmentVariables?.MY_CUSTOM_VAR).toEqual('exists');
+    });
+  });
+
+  describe('getComponentsRuntimeSetData', () => {
+    it('should return only the environment variables the component expects', async () => {
+      process.env.TEST_VARIABLE = 'the one and only';
+      const manifest = await manifestService.loadManifest(
+        'unit-test-components',
+        'test-environment-variables',
+        '1.0.0',
+      );
+      const set = await compSetServiceLocal.getComponentSet('set-path');
+
+      const output = await compSetServiceLocal.getComponentsRuntimeSetData(manifest, set);
+      expect(output.environment).toEqual({ TEST_VARIABLE: process.env.TEST_VARIABLE });
+    });
+
+    it('does not give environment variable not listed in manifest', async () => {
+      process.env.TEST_VARIABLE = 'the one and only';
+      const manifest = await manifestService.loadManifest(
+        'unit-test-components',
+        'test-environment-variables',
+        '1.0.1',
+      );
+      const set = await compSetServiceLocal.getComponentSet('set-path');
+
+      const output = await compSetServiceLocal.getComponentsRuntimeSetData(manifest, set);
+      expect(Object.entries(output.environment)).toHaveLength(0);
+    });
+
+    it('errors when required environment variables are not provided', async () => {
+      delete process.env.TEST_VARIABLE;
+      const manifest = await manifestService.loadManifest(
+        'unit-test-components',
+        'test-environment-variables',
+        '1.0.0',
+      );
+      const set = await compSetServiceLocal.getComponentSet('set-path');
+
+      await expect(compSetServiceLocal.getComponentsRuntimeSetData(manifest, set)).rejects.toThrow(
+        new Error('Missing required environment variables: "TEST_VARIABLE"'),
+      );
+    });
+
+    it('errors when required env vars are not provided - with both mandatory and non-mandatory vars', async () => {
+      // manifest defines M_VAR and M_VAR2 as mandatory vars and NM_VAR as non-mandatory
+      delete process.env.M_VAR;
+      delete process.env.M_VAR2;
+      delete process.env.NM_VAR;
+      const manifest = await manifestService.loadManifest(
+        'unit-test-components',
+        'test-environment-variables',
+        '1.0.4',
+      );
+      const set = await compSetServiceLocal.getComponentSet('set-path');
+
+      await expect(compSetServiceLocal.getComponentsRuntimeSetData(manifest, set)).rejects.toThrow(
+        new Error('Missing required environment variables: "M_VAR","M_VAR2"'),
+      );
+    });
+
+    it('should have runtime set return all defined env vars in the manifest that are provided', async () => {
+      // manifest defines M_VAR and M_VAR2 as mandatory vars and NM_VAR as non-mandatory
+      process.env.M_VAR = 'mandatory-var-val';
+      process.env.M_VAR2 = 'mandatory-var-val2';
+      process.env.NM_VAR = 'non-mandatory-var-val';
+      const manifest = await manifestService.loadManifest(
+        'unit-test-components',
+        'test-environment-variables',
+        '1.0.4',
+      );
+      const set = await compSetServiceLocal.getComponentSet('set-path');
+      const output = await compSetServiceLocal.getComponentsRuntimeSetData(manifest, set);
+      expect(output.environment).toEqual({
+        M_VAR: 'mandatory-var-val',
+        M_VAR2: 'mandatory-var-val2',
+        NM_VAR: 'non-mandatory-var-val',
+      });
+    });
+
+    it('should have runtime set not return non-mandatory env vars that are not provided', async () => {
+      // manifest defines M_VAR and M_VAR2 as mandatory vars and NM_VAR as non-mandatory
+      delete process.env.NM_VAR;
+      process.env.M_VAR = 'mandatory-var-val';
+      process.env.M_VAR2 = 'mandatory-var-val2';
+      const manifest = await manifestService.loadManifest(
+        'unit-test-components',
+        'test-environment-variables',
+        '1.0.4',
+      );
+      const set = await compSetServiceLocal.getComponentSet('set-path');
+      const output = await compSetServiceLocal.getComponentsRuntimeSetData(manifest, set);
+      expect(output.environment).toEqual({
+        M_VAR: 'mandatory-var-val',
+        M_VAR2: 'mandatory-var-val2',
+      });
+    });
+
+    it('does not errors when non-mandatory environment variables are not provided', async () => {
+      delete process.env.TEST_VARIABLE;
+      const manifest = await manifestService.loadManifest(
+        'unit-test-components',
+        'test-environment-variables',
+        '1.0.3',
+      );
+      const set = await compSetServiceLocal.getComponentSet('set-path');
+
+      const output = await compSetServiceLocal.getComponentsRuntimeSetData(manifest, set);
+      expect(output.environment).toEqual({});
+    });
+
+    it('does not error when env variable is falsy', async () => {
+      process.env.TEST_VARIABLE = '';
+      const manifest = await manifestService.loadManifest(
+        'unit-test-components',
+        'test-environment-variables',
+        '1.0.0',
+      );
+      const set = await compSetServiceLocal.getComponentSet('set-path');
+      const output = await compSetServiceLocal.getComponentsRuntimeSetData(manifest, set);
+
+      expect(output.environment).toEqual({ TEST_VARIABLE: '' });
+    });
+  });
+
+  describe('componentVersionInSet', () => {
+    it('should always return true', async () => {
+      await expect(compSetServiceLocal.componentVersionInSet({} as any, {} as any)).resolves.toEqual(true);
+    });
+  });
+
+  describe('componentVersionExcludedFromSet', () => {
+    it('should always return false', async () => {
+      await expect(
+        compSetServiceLocal.componentVersionExcludedFromSet({} as any, {} as any, {} as any),
+      ).resolves.toEqual(false);
+    });
+  });
+});

package/src/domains/component-set/services/ComponentSetServiceForLocalDev.ts

@@ -0,0 +1,111 @@
+import { MethodNotImplementedError, PageQueryResult } from '@squiz/dx-common-lib';
+import type { ComponentSetWebModel } from '../web-models/ComponentSetForWeb';
+import { AbstractComponentSetService } from './ComponentSetService';
+import { Logger } from '@squiz/dx-logger-lib';
+import { ComponentSetComponentVersionInterface } from '../models/ComponentSetComponentVersion';
+import { ComponentSet, ComponentSetInterface } from '../models/ComponentSet';
+import { SortDirection } from '@squiz/db-lib';
+import { Manifest } from '../../manifest';
+import { RuntimeComponentSet } from './RuntimeComponentSet';
+import { EnvironmentVariables } from './EnvironmentVariables';
+
+export class ComponentSetServiceForLocalDev extends AbstractComponentSetService {
+  constructor(protected logger: Logger) {
+    super();
+  }
+
+  public async updateComponentSet(): Promise<ComponentSetWebModel> {
+    throw new MethodNotImplementedError(`updateComponentSet is not implemented for local development`);
+  }
+  public async getAllComponentSets(): Promise<ComponentSetWebModel[]> {
+    throw new MethodNotImplementedError(`getAllComponentSets is not implemented for local development`);
+  }
+  public async addComponentSet(): Promise<ComponentSetWebModel> {
+    throw new MethodNotImplementedError(`addComponentSet is not implemented for local development`);
+  }
+  public async deleteComponentSet(): Promise<number> {
+    throw new MethodNotImplementedError(`deleteComponentSet is not implemented for local development`);
+  }
+
+  public addComponentToSet(
+    _webPath: string,
+    _componentName: string,
+    _componentVersion: string,
+  ): Promise<ComponentSetComponentVersionInterface> {
+    throw new MethodNotImplementedError(`addComponentToSet is not implemented for local development`);
+  }
+
+  public async getPaginatedComponentSets(
+    _pageNumber: number = 1,
+    _sortBy: (keyof ComponentSetInterface)[] = [],
+    _sortDirection: SortDirection = 'asc',
+  ): Promise<PageQueryResult<ComponentSetWebModel>> {
+    throw new MethodNotImplementedError(`getPaginatedComponentSets is not implemented for local development`);
+  }
+
+  public async getComponentSetWebModel(webPath: string): Promise<ComponentSetWebModel> {
+    const set: ComponentSetWebModel = {
+      webPath,
+      displayName: 'set',
+      description: 'debug set',
+      environmentVariables: process.env as any,
+      headers: {},
+      components: {
+        // TODO potentially list all local components and versions using ManifestService
+      },
+      componentVersionRules: {},
+    };
+
+    return set;
+  }
+
+  public async getComponentSet(webPath: string): Promise<ComponentSet> {
+    const set: ComponentSet = {
+      webPath,
+      displayName: 'set',
+      description: 'debug set',
+      environmentVariables: process.env as any,
+      headers: {},
+    };
+
+    return set;
+  }
+
+  public async getComponentsRuntimeSetData(manifest: Manifest, set: ComponentSet): Promise<RuntimeComponentSet> {
+    const envVars: EnvironmentVariables = {};
+    const requestEnvVars = manifest.getModel().environment || [];
+
+    const missingVariables: string[] = [];
+    for (const envVar of requestEnvVars) {
+      if (set.environmentVariables[envVar.name] === undefined) {
+        // Note that "required" must be specifically set to false to ignore
+        if (envVar.required !== false) {
+          missingVariables.push(envVar.name);
+        }
+      } else {
+        envVars[envVar.name] = set.environmentVariables[envVar.name];
+      }
+    }
+    if (missingVariables.length > 0) {
+      throw new Error(`Missing required environment variables: "${missingVariables.join('","')}"`);
+    }
+
+    return {
+      environment: envVars,
+      displayName: set.displayName,
+      webPath: set.webPath,
+    };
+  }
+
+  public async componentVersionInSet(_: Manifest, _webPath: string): Promise<boolean> {
+    return true;
+  }
+
+  public async componentVersionExcludedFromSet(
+    _webPath: string,
+    _componentName: string,
+    _componentVersion: string,
+  ): Promise<boolean> {
+    return false;
+  }
+}