@squiz/job-runner-lib 1.66.1 → 2.1.0

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

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

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

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

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