@squiz/job-runner-lib 1.66.2 → 2.2.0

package/src/domains/content/services/DynamicContentItemService.ts

@@ -1,30 +0,0 @@
-import { ContentApiService } from '@squiz/component-web-api-lib';
-import { AxiosError } from 'axios';
-import { UriResource } from '../../component';
-
-export class DynamicContentItemService {
-  constructor(private api: ContentApiService<UriResource>['dynamicContent']) {}
-
-  public async getDynamicContentItem(contentUri: string, apiKey: string): Promise<UriResource | undefined> {
-    try {
-      const headers: Record<string, string | number> = {
-        'x-api-key': apiKey,
-      };
-
-      const response = await this.api.getDynamicContentItem({ _contentUri: contentUri }, { headers });
-
-      return response.data;
-    } catch (e) {
-      const axiosError = e as AxiosError;
-      throw this.handleAxiosError(axiosError);
-    }
-  }
-
-  private handleAxiosError(error: AxiosError): Error {
-    const { response } = error;
-    if (!response || (typeof error == 'object' && !error.isAxiosError)) {
-      return error;
-    }
-    throw new Error(`Error occurred when resolving content from uri: ${(response.data as any)?.message}`);
-  }
-}

package/src/domains/content/utils/getContentSchemaName.spec.ts

@@ -1,7 +0,0 @@
-import { getContentSchemaName } from './getContentSchemaName';
-
-describe('getContentSchemaName', () => {
-  it('should join the component name, version and function by "/"', () => {
-    expect(getContentSchemaName('ns/foo', '1.1.1', 'main')).toEqual('ns/foo/1.1.1/main');
-  });
-});

package/src/domains/content/utils/getContentSchemaName.ts

@@ -1,7 +0,0 @@
-export function getContentSchemaName(
-  componentName: string,
-  componentVersion: string,
-  componentFunction: string,
-): string {
-  return [componentName, componentVersion, componentFunction].join('/');
-}

package/src/domains/db/ComponentConnectionManager.ts

@@ -1,4 +0,0 @@
-import { ConnectionManager } from '@squiz/db-lib';
-import { ComponentRepositories } from './ComponentRepositories';
-
-export type ComponentConnectionManager = ConnectionManager<ComponentRepositories>;

package/src/domains/db/ComponentRepositories.ts

@@ -1,31 +0,0 @@
-import { Repositories } from '@squiz/db-lib';
-import { ComponentSetComponentVersionRepository } from '../component-set/repositories/ComponentSetComponentVersionRepository';
-import { ComponentSetComponentVersionExcludedRepository } from '../component-set/repositories/ComponentSetComponentVersionExcludedRepository';
-import { ComponentSetComponentVersionEditableRepository } from '../component-set/repositories/ComponentSetComponentVersionEditableRepository';
-import { ComponentSetRepository } from '../component-set/repositories/ComponentSetRepository';
-import { ComponentSetRuleRepository } from '../component-set/repositories/ComponentSetRuleRepository';
-import { ComponentRepository } from '../component/repositories/ComponentRepository';
-import { ComponentVersionRepository } from '../component/repositories/ComponentVersionRepository';
-import { ComponentConnectionManager } from './ComponentConnectionManager';
-
-export interface ComponentRepositories extends Repositories {
-  component: ComponentRepository;
-  componentVersion: ComponentVersionRepository;
-  componentSet: ComponentSetRepository;
-  componentSetComponentVersion: ComponentSetComponentVersionRepository;
-  componentSetComponentVersionExcluded: ComponentSetComponentVersionExcludedRepository;
-  componentSetComponentVersionEditable: ComponentSetComponentVersionEditableRepository;
-  componentSetRule: ComponentSetRuleRepository;
-}
-
-export function createComponentRepositories(dbManager: ComponentConnectionManager): ComponentRepositories {
-  return {
-    component: new ComponentRepository(dbManager),
-    componentVersion: new ComponentVersionRepository(dbManager),
-    componentSet: new ComponentSetRepository(dbManager),
-    componentSetComponentVersion: new ComponentSetComponentVersionRepository(dbManager),
-    componentSetComponentVersionExcluded: new ComponentSetComponentVersionExcludedRepository(dbManager),
-    componentSetComponentVersionEditable: new ComponentSetComponentVersionEditableRepository(dbManager),
-    componentSetRule: new ComponentSetRuleRepository(dbManager),
-  };
-}

package/src/domains/db/createConnectionManager.ts

@@ -1,24 +0,0 @@
-import { ConnectionManager, getConnectionInfo } from '@squiz/db-lib';
-import { ComponentConnectionManager } from './ComponentConnectionManager';
-import { ComponentRepositories, createComponentRepositories } from './ComponentRepositories';
-import migrationList from './migration-list';
-
-type DbConfig = Parameters<typeof getConnectionInfo>[0];
-
-export async function createConnectionManager(
-  applicationName: string,
-  connectionInfo: DbConfig,
-  migrationDirectory: string,
-): Promise<ComponentConnectionManager> {
-  const connection = await getConnectionInfo(connectionInfo);
-
-  const manager = new ConnectionManager<ComponentRepositories>(
-    applicationName,
-    connection,
-    migrationDirectory,
-    migrationList,
-    createComponentRepositories,
-  );
-
-  return manager;
-}

package/src/domains/db/index.ts

@@ -1,3 +0,0 @@
-export * from './ComponentConnectionManager';
-export * from './ComponentRepositories';
-export * from './createConnectionManager';

package/src/domains/db/migration-list.ts

@@ -1,16 +0,0 @@
-export default [
-  '20220704054051_initial.sql',
-  '20220718172237_adding_component_sets.sql',
-  '20220728113941_add_env_vars_field.sql',
-  '20220817113300_removing_null_props_from_jsonb.sql',
-  '20223525103556_component_set_rule.sql',
-  '20221027151225_dummy.sql',
-  '20221117151200_add_detail_columns_to_component_version.js',
-  '20221220151200_add_required_to_manifests.js',
-  '20221222151200_add_required_to_manifests.js',
-  '20230111095522_update_environment_property.js',
-  '20230203084900_ensure_static_root_exists.js',
-  '20230210143300_lowercase_all_uri_names.js',
-  '20230217151212_component_set_component_version_updates.sql',
-  '20230218121212_add_component_set_rules.js',
-];

package/src/domains/manifest/AbstractManifest.ts

@@ -1,57 +0,0 @@
-import { ManifestModel } from './ManifestModel';
-import util from 'util';
-import { getComponentName } from '../component/utils/getComponentName';
-import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
-
-export type SchemaVersions = keyof typeof MANIFEST_MODELS;
-export const SCHEMA_VERSIONS = Object.keys(MANIFEST_MODELS) as string[];
-export const schemaVersionRegex = /\/schemas\/(?<schema>v\d+)\.json#?$/;
-
-interface Manifest {
-  getNamespace(): string;
-  getName(): string;
-  getVersion(): string;
-  getSchemaVersion(): SchemaVersions;
-  getModel(): ManifestModel;
-
-  id: `${string}/${string}/${string}`;
-}
-
-export abstract class AbstractManifest implements Manifest {
-  constructor(protected manifest: ManifestModel) {}
-
-  public abstract getSchemaVersion(): SchemaVersions;
-  public abstract getModel(): ManifestModel;
-
-  public getNamespace(): string {
-    return this.manifest.namespace;
-  }
-
-  get id(): `${string}/${string}/${string}` {
-    return `${this.manifest.namespace}/${this.manifest.name}/${this.manifest.version}`;
-  }
-
-  /**
-   * Name identifier for the component
-   *
-   * @returns {string} The component name in the format namespace/name
-   */
-  public getName(): string {
-    return getComponentName(this.manifest.namespace, this.manifest.name);
-  }
-
-  /**
-   * Version for this instance of the component
-   *
-   * @returns {string} The component version
-   */
-  public getVersion(): string {
-    return this.manifest.version;
-  }
-
-  public getInputSchemas(): { name: string; schema: object }[] {
-    return this.manifest.functions
-      .map((cFn) => ({ name: cFn.name, schema: cFn.input }))
-      .filter((inputSchema) => !util.isDeepStrictEqual(inputSchema.schema, {}));
-  }
-}

package/src/domains/manifest/ManifestV1.spec.ts

@@ -1,436 +0,0 @@
-import { ManifestV1 } from './ManifestV1';
-import { ManifestV1Model } from './ManifestModel';
-import { ManifestServiceForProduction } from './services/ManifestServiceForProduction';
-import { BadRequestError, ResourceNotFoundError } from '@squiz/dx-common-lib';
-
-import { getLogger } from '@squiz/dx-logger-lib';
-import path from 'path';
-
-const fileRoot = process.cwd();
-
-describe('ManifestV1', () => {
-  const manifestModel = {
-    $schema: 'http://localhost:3000/schemas/v2.json#',
-    name: 'bar',
-    version: '1.0.0',
-    mainFunction: 'main',
-    namespace: 'foo',
-    displayName: 'some display name',
-    description: 'some description',
-    functions: [
-      {
-        name: 'main',
-        input: {
-          type: 'string',
-        },
-        entry: 'main.js',
-        output: { 'response-type': 'html' },
-      },
-      {
-        name: 'f1',
-        input: {
-          type: 'string',
-        },
-        entry: 'f1.js',
-        output: { 'response-type': 'html' },
-      },
-      {
-        name: 'f2',
-        input: {},
-        entry: 'f1.js',
-        output: { responseType: 'html' },
-      },
-      {
-        name: 'f3',
-        input: {
-          type: 'object',
-        },
-        entry: 'f3.js',
-        output: { 'response-type': 'html' },
-      },
-    ],
-
-    previews: {
-      'test-preview': {
-        functionData: {
-          main: {
-            headers: { header: 'header value' },
-            inputData: { type: 'inline', value: { input: 'from preview' } },
-          },
-        },
-      },
-    },
-  } as ManifestV1Model;
-  const manifestModelWithoutMainFunction = {
-    $schema: 'http://localhost:3000/schemas/v2.json#',
-    name: 'bar',
-    version: '1.0.0',
-    mainFunction: 'main',
-    namespace: 'foo',
-    displayName: 'some display name',
-    description: 'some description',
-    functions: [
-      {
-        name: 'f1',
-        input: {
-          type: 'string',
-        },
-        entry: 'f1.js',
-        output: { 'response-type': 'html' },
-      },
-      {
-        name: 'f2',
-        input: {},
-        entry: 'f1.js',
-        output: { responseType: 'html' },
-      },
-      {
-        name: 'f3',
-        input: {
-          type: 'object',
-        },
-        entry: 'f3.js',
-        output: { 'response-type': 'html' },
-      },
-    ],
-  } as ManifestV1Model;
-  const manifestPath = 'folder';
-  const manifest = new ManifestV1(manifestModel, manifestPath);
-  const manifestWithoutMainFunction = new ManifestV1(manifestModelWithoutMainFunction, manifestPath);
-
-  it('returns correct value for getName()', async () => {
-    expect(manifest.getName()).toEqual('foo/bar');
-  });
-
-  it('returns correct value for getNamespace()', async () => {
-    expect(manifest.getNamespace()).toEqual('foo');
-  });
-
-  it('returns correct value for getSchemaVersion()', async () => {
-    expect(manifest.getSchemaVersion()).toEqual('v1');
-  });
-
-  it('returns correct value for getModel()', async () => {
-    expect(manifest.getModel()).toEqual(manifestModel);
-  });
-
-  it('returns correct value for getInputSchemas()', async () => {
-    expect(manifest.getInputSchemas()).toEqual([
-      {
-        name: 'main',
-        schema: {
-          type: 'string',
-        },
-      },
-      {
-        name: 'f1',
-        schema: {
-          type: 'string',
-        },
-      },
-      {
-        name: 'f3',
-        schema: {
-          type: 'object',
-        },
-      },
-    ]);
-  });
-
-  it('should return the component function associated with the function name', async () => {
-    const loadedFunction = manifest.getComponentFunctionByName('f1');
-    const expectedFunction = {
-      name: 'f1',
-      input: {
-        type: 'string',
-      },
-      entry: 'f1.js',
-      output: { 'response-type': 'html' },
-    };
-    expect(loadedFunction).toEqual(expectedFunction);
-  });
-
-  it('should return the component main function definition when the function name is undefined', async () => {
-    const loadedFunction = manifest.getComponentFunctionByName(undefined);
-    const expectedFunction = {
-      name: 'main',
-      input: {
-        type: 'string',
-      },
-      entry: 'main.js',
-      output: { 'response-type': 'html' },
-    };
-    expect(loadedFunction).toEqual(expectedFunction);
-  });
-
-  it('should throw a meaningful error when the component main function does not exist and function name passed in is undefined', async () => {
-    await expect(async () =>
-      manifestWithoutMainFunction.getComponentFunctionByName(undefined),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(`""main" function for foo/bar 1.0.0 could not be found"`);
-  });
-
-  it('should throw a meaningful error a function associated with the function name does not exist on the manifest', async () => {
-    await expect(async () =>
-      manifest.getComponentFunctionByName('fake-function-name'),
-    ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `""fake-function-name" function for foo/bar 1.0.0 could not be found"`,
-    );
-  });
-
-  it('should return a functions absolute path to its entry file', async () => {
-    const f1 = manifest.getComponentFunctionByName('f1');
-    await expect(manifest.getComponentFunctionEntryFilePath(f1)).resolves.toEqual(fileRoot + path.sep + 'f1.js');
-  });
-
-  it('should return the components directory', async () => {
-    const componentDirectory = manifest.getComponentDirectory();
-    expect(componentDirectory).toEqual(fileRoot);
-  });
-
-  describe('loadManifest', () => {
-    const manifestService = new ManifestServiceForProduction(
-      process.env.DATA_MOUNT_POINT!,
-      getLogger({
-        name: 'loadManifest',
-      }),
-    );
-
-    it("should throw a BadRequestError if preview js file doesn't exist", async () => {
-      const manifest = manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.1');
-      await expect(manifest).rejects.toThrowError(
-        new BadRequestError(
-          `Invalid preview data for preview "preview-js-doesnt-exist": Preview inputData file "missing.js" does not exist`,
-        ),
-      );
-    });
-
-    it("should throw a BadRequestError if json file doesn't exist in preview data", async () => {
-      const manifest = manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.2');
-      await expect(manifest).rejects.toThrowError(
-        new BadRequestError(
-          `Invalid preview data for preview "preview-json-doesnt-exist": Preview inputData file "missing.json" does not exist`,
-        ),
-      );
-    });
-
-    it('should throw a BadRequestError if json file is outside the component directory in preview data', async () => {
-      const manifest = manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.3');
-      await expect(manifest).rejects.toThrowError(
-        new BadRequestError(
-          `Invalid preview data for preview "preview-json-outside-of-root": Preview inputData file "../preview-data.json" is outside the component directory`,
-        ),
-      );
-    });
-  });
-
-  describe('getFunctionPreviewConfiguration', () => {
-    const manifestService = new ManifestServiceForProduction(
-      process.env.DATA_MOUNT_POINT!,
-      getLogger({
-        name: 'getFunctionPreviewConfiguration',
-      }),
-    );
-
-    it('should throw an error if component has no previews defined', async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-component', '1.0.9');
-
-      expect(() =>
-        manifest.getFunctionPreviewConfiguration(
-          'no-preview-defined-in-manifest',
-          manifest.getComponentFunctionByName('console-log'),
-        ),
-      ).toThrowError(new ResourceNotFoundError(`Component has no previews defined`));
-    });
-
-    it('should throw an error with public facing message if component has previews defined, but the one requested is missing', async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.0');
-
-      expect(() =>
-        manifest.getFunctionPreviewConfiguration('not-a-real-preview', manifest.getComponentFunctionByName('main')),
-      ).toThrowError(
-        new ResourceNotFoundError(
-          `Component has not defined preview with key "not-a-real-preview", the defined preview keys for this component are "first-preview, second-preview, test-preview, another-preview, preview-js-data-good-data"`,
-        ),
-      );
-    });
-
-    it("should return undefined when preview exists, but doesn't include information for requested function", async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.0');
-
-      expect(
-        manifest.getFunctionPreviewConfiguration('first-preview', manifest.getComponentFunctionByName('other')),
-      ).toEqual(undefined);
-    });
-
-    it('should return functions preview definition if it exists ion the manifest', async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.0');
-
-      expect(
-        manifest.getFunctionPreviewConfiguration('test-preview', manifest.getComponentFunctionByName('main')),
-      ).toEqual({
-        inputData: {
-          type: 'inline',
-          value: {
-            integerValue: 8,
-            nested: {
-              content: 'this is nested content',
-            },
-          },
-        },
-      });
-    });
-  });
-
-  describe('getFunctionPreviewData', () => {
-    const manifestService = new ManifestServiceForProduction(
-      process.env.DATA_MOUNT_POINT!,
-      getLogger({
-        name: 'getFunctionPreviewConfiguration',
-      }),
-    );
-
-    it('should return the input data from the manifest if input is defined as inline', async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.0');
-      const previewConfig = manifest.getFunctionPreviewConfiguration(
-        'first-preview',
-        manifest.getComponentFunctionByName('main'),
-      );
-      await expect(manifest.getFunctionPreviewData(previewConfig!)).resolves.toEqual({
-        input: 'from preview',
-      });
-    });
-
-    it('should return the input data from file if the input data is defined as json', async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.0');
-      const definition = manifest.getFunctionPreviewConfiguration(
-        'another-preview',
-        manifest.getComponentFunctionByName('main'),
-      );
-      await expect(manifest.getFunctionPreviewData(definition!)).resolves.toEqual({
-        integerValue: 123,
-        nested: {
-          content: 'this is also nested content',
-        },
-      });
-    });
-
-    it('should return the input data from file if the input data is defined as js', async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.2.0');
-      const definition = manifest.getFunctionPreviewConfiguration(
-        'preview-js-data-good-data',
-        manifest.getComponentFunctionByName('main'),
-      );
-      await expect(manifest.getFunctionPreviewData(definition!)).resolves.toEqual({
-        something: 'works',
-      });
-    });
-  });
-
-  describe('getMockedUriObject', () => {
-    const manifestService = new ManifestServiceForProduction(
-      process.env.DATA_MOUNT_POINT!,
-      getLogger({
-        name: 'getMockedUriObject',
-      }),
-    );
-
-    it('should return mocked uri object for valid inline uri', async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.1.1');
-      const output = manifest.getMockedUriObject('foo://valid-inline-uri');
-      await expect(output).resolves.toMatchInlineSnapshot(`
-        {
-          "additional": {},
-          "attributes": {
-            "test": "test",
-          },
-          "created": {
-            "date": "2020-02-27T09:47:27+11:00",
-            "user_id": null,
-          },
-          "id": "id-inline",
-          "name": "Root Folder",
-          "published": {
-            "date": "2020-02-27T09:47:27+11:00",
-            "user_id": "null",
-          },
-          "short_name": "/",
-          "status": {
-            "code": "under_construction",
-            "id": 2,
-          },
-          "status_changed": {
-            "date": "2020-02-27T09:47:27+11:00",
-            "user_id": "null",
-          },
-          "type": "root_folder",
-          "type_name": "Root Folder",
-          "updated": {
-            "date": "2020-02-27T09:47:27+11:00",
-            "user_id": "",
-          },
-          "url": "xxx",
-          "urls": [],
-          "version": "0.0.1",
-        }
-      `);
-    });
-
-    it('should return throw error for uri not defined in the manifest', async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.1.1');
-      const output = manifest.getMockedUriObject('bad-uri');
-      await expect(output).rejects.toThrowError('Mocked URI object "bad-uri" not defined in the manifest');
-    });
-
-    it('should return mocked uri for file ref uri', async () => {
-      const manifest = await manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.1.1');
-      const output = manifest.getMockedUriObject('foo://valid-file-uri');
-      await expect(output).resolves.toMatchInlineSnapshot(`
-        {
-          "attributes": {
-            "test": "test",
-          },
-          "created": {
-            "date": "2020-02-27T09:47:27+11:00",
-            "user_id": null,
-          },
-          "id": "id-file",
-          "name": "Root Folder",
-          "published": {
-            "date": "2020-02-27T09:47:27+11:00",
-            "user_id": "null",
-          },
-          "short_name": "/",
-          "status": {
-            "code": "under_construction",
-            "id": 2,
-          },
-          "status_changed": {
-            "date": "2020-02-27T09:47:27+11:00",
-            "user_id": "null",
-          },
-          "type": "root_folder",
-          "type_name": "Root Folder",
-          "updated": {
-            "date": "2020-02-27T09:47:27+11:00",
-            "user_id": "",
-          },
-          "url": "xxx",
-          "urls": [],
-          "version": "0.0.1",
-        }
-      `);
-    });
-
-    it('should return throw error for non-existent file ref uri', async () => {
-      const manifest = manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.1.2');
-      await expect(manifest).rejects.toThrowError('Mocked URI object file "./non-existent-uri.json" does not exist');
-    });
-
-    it('should return throw error for outside file ref uri', async () => {
-      const manifest = manifestService.loadManifest('unit-test-components', 'test-preview-component', '1.1.3');
-      await expect(manifest).rejects.toThrowError(
-        'Mocked URI object file "../1.0.0/manifest.json" is outside the component directory',
-      );
-    });
-  });
-});