@squiz/job-runner-lib 1.66.2 → 2.1.0

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

@@ -1 +0,0 @@
-export type EnvironmentVariables = Record<string, string | undefined>;

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

@@ -1 +0,0 @@
-export type Headers = Record<string, string | undefined>;

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

@@ -1,7 +0,0 @@
-import { EnvironmentVariables } from './EnvironmentVariables';
-
-export interface RuntimeComponentSet {
-  environment: EnvironmentVariables;
-  displayName: string;
-  webPath: string;
-}

package/src/domains/component-set/web-models/ComponentSetComponentVersionForWeb.ts

@@ -1,7 +0,0 @@
-import { EnvironmentVariablesWebModel } from './ComponentSetForWeb';
-
-// TODO - check if we still need this
-export type UpdateComponentSetComponentVersionWebModel = {
-  environmentVariables?: EnvironmentVariablesWebModel;
-  deleted?: boolean;
-};

package/src/domains/component-set/web-models/ComponentSetForWeb.ts

@@ -1,83 +0,0 @@
-/*
- * ************************
- * ************************ README
- * ************************
- *
- * There is a super fun gotcha in TSOA's OpenApi specification generation
- * It cannot interpret typescripts utility types. Although it looks like
- * you should be able to replace ComponentSetWebModelForCreate and
- * ComponentSetWebModelForUpdate with some combination of Partial, Omit
- * and Pick. You cant!!! The OpenApi spec will be created, but if you
- * follow all of the refs all the validation is of objects with no
- * fields. Everything passes.
- *
- */
-
-export type EnvironmentVariablesWebModel = {
-  [key: string]: string;
-};
-
-export type HeadersWebModel = {
-  [key: string]: string;
-};
-
-export type ComponentSetWebComponentVersion = {
-  readonly version: string;
-  environmentVariables?: EnvironmentVariablesWebModel;
-
-  readonly displayName: string;
-  readonly description: string;
-  readonly icon: any;
-  readonly editable: boolean;
-};
-
-export enum EditableComponentVersionTypes {
-  Latest = 'latest',
-}
-
-export type ComponentVersionRulesWebModel = {
-  renderableVersionPattern: string;
-  editableVersions: EditableComponentVersionTypes.Latest | string | string[];
-  excludedVersions: string[];
-};
-
-export type ComponentSetWebModel = {
-  webPath: string;
-  displayName: string;
-  description: string;
-
-  headers: HeadersWebModel;
-  environmentVariables?: EnvironmentVariablesWebModel;
-  components: { [key: string]: ComponentSetWebComponentVersion[] };
-  componentVersionRules: { [key: string]: ComponentVersionRulesWebModel };
-};
-
-// Create
-
-export type ComponentVersionWebModelForCreate = {
-  version: string;
-  environmentVariables?: EnvironmentVariablesWebModel;
-};
-
-export type ComponentSetWebModelForCreate = {
-  webPath: string;
-  displayName: string;
-  description: string;
-
-  headers?: HeadersWebModel;
-  environmentVariables?: EnvironmentVariablesWebModel;
-  components?: { [key: string]: ComponentVersionWebModelForCreate[] };
-  componentVersionRules?: { [key: string]: ComponentVersionRulesWebModel };
-};
-
-// Update
-
-export type ComponentSetWebModelForUpdate = {
-  displayName?: string;
-  description?: string;
-
-  headers?: HeadersWebModel;
-  environmentVariables?: EnvironmentVariablesWebModel;
-  components?: { [key: string]: ComponentVersionWebModelForCreate[] };
-  componentVersionRules?: { [key: string]: ComponentVersionRulesWebModel };
-};

package/src/domains/content/index.ts

@@ -1,4 +0,0 @@
-export * from './services/ContentItemService';
-export * from './services/ComponentContentSchemaService';
-export * from './services/DynamicContentItemService';
-export * from './utils/getContentSchemaName';

package/src/domains/content/services/ComponentContentSchemaService.spec.ts

@@ -1,264 +0,0 @@
-import { ContentApiService } from '@squiz/component-web-api-lib';
-import { ComponentContentSchemaService } from './ComponentContentSchemaService';
-import { ManifestV1 } from '../../manifest/ManifestV1';
-import { AxiosError } from 'axios';
-
-describe('ComponentContentSchemaService', () => {
-  let service: ComponentContentSchemaService;
-  let api: ContentApiService<null>['contentSchema'];
-  const manifestPath = '';
-  const mockcreateContentSchema = jest.fn();
-  beforeAll(() => {
-    api = {
-      createContentSchema: mockcreateContentSchema,
-      getPaginatedContentSchemas: jest.fn(),
-      getContentSchema: jest.fn(),
-      getContentSchemaSchema: jest.fn(),
-      updateContentSchema: jest.fn(),
-      deleteContentSchema: jest.fn(),
-    };
-    service = new ComponentContentSchemaService(api);
-  });
-
-  beforeEach(() => {
-    mockcreateContentSchema.mockClear();
-  });
-
-  it('should add schema for the component function', async () => {
-    const manifest = new ManifestV1(
-      {
-        $schema: 'http://localhost:3000/schemas/v2.json#',
-        name: 'bar',
-        version: '1',
-        mainFunction: 'main',
-        namespace: 'foo',
-        displayName: 'some display name',
-        description: 'some description',
-        functions: [
-          {
-            name: 'f1',
-            input: {
-              type: 'object',
-            },
-            entry: 'f1.js',
-            output: { responseType: 'html' },
-          },
-        ],
-      },
-      manifestPath,
-    );
-    await service.createComponentContentSchemas(manifest);
-    expect(api.createContentSchema).toHaveBeenCalledTimes(1);
-    expect(mockcreateContentSchema.mock.calls[0]).toEqual([
-      {
-        contentSchemaType: 'component',
-        schema: {
-          type: 'object',
-        },
-        name: 'foo/bar/1/f1',
-      },
-      {
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      },
-    ]);
-  });
-
-  it('should pass through api key if one was provided', async () => {
-    const manifest = new ManifestV1(
-      {
-        $schema: 'http://localhost:3000/schemas/v2.json#',
-        name: 'bar2',
-        version: '1',
-        mainFunction: 'main',
-        namespace: 'foo',
-        displayName: 'some display name',
-        description: 'some description',
-        functions: [
-          {
-            name: 'f1',
-            input: {
-              type: 'object',
-            },
-            entry: 'f1.js',
-            output: { responseType: 'html' },
-          },
-        ],
-      },
-      manifestPath,
-    );
-    await service.createComponentContentSchemas(manifest, 'Bearer xxx.yyy.zzz');
-    expect(api.createContentSchema).toHaveBeenCalledTimes(1);
-    expect(mockcreateContentSchema.mock.calls[0]).toEqual([
-      {
-        contentSchemaType: 'component',
-        schema: {
-          type: 'object',
-        },
-        name: 'foo/bar2/1/f1',
-      },
-      {
-        headers: {
-          'Content-Type': 'application/json',
-          authorization: 'Bearer xxx.yyy.zzz',
-        },
-      },
-    ]);
-  });
-
-  it('should add schema for the each non-empty component function', async () => {
-    const manifest = new ManifestV1(
-      {
-        $schema: 'http://localhost:3000/schemas/v2.json#',
-        name: 'bar',
-        version: '1',
-        mainFunction: 'main',
-        namespace: 'foo',
-        displayName: 'some display name',
-        description: 'some description',
-        functions: [
-          {
-            name: 'f1',
-            input: {
-              type: 'object',
-            },
-            entry: 'f1.js',
-            output: { responseType: 'html' },
-          },
-          {
-            name: 'f2',
-            input: {},
-            entry: 'f1.js',
-            output: { responseType: 'html' },
-          },
-          {
-            name: 'f3',
-            input: {
-              type: 'object',
-            },
-            entry: 'f3.js',
-            output: { responseType: 'html' },
-          },
-        ],
-      },
-      manifestPath,
-    );
-    await service.createComponentContentSchemas(manifest);
-    expect(api.createContentSchema).toHaveBeenCalledTimes(2);
-    expect(mockcreateContentSchema.mock.calls[0]).toEqual([
-      {
-        contentSchemaType: 'component',
-        schema: {
-          type: 'object',
-        },
-        name: 'foo/bar/1/f1',
-      },
-      {
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      },
-    ]);
-    expect(mockcreateContentSchema.mock.calls[1]).toEqual([
-      {
-        contentSchemaType: 'component',
-        schema: {
-          type: 'object',
-        },
-        name: 'foo/bar/1/f3',
-      },
-      {
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      },
-    ]);
-  });
-
-  it('should not add any schema for the empty component function', async () => {
-    const manifest = new ManifestV1(
-      {
-        $schema: 'http://localhost:3000/schemas/v2.json#',
-        name: 'bar',
-        version: '1',
-        mainFunction: 'main',
-        namespace: 'foo',
-        displayName: 'some display name',
-        description: 'some description',
-        functions: [],
-      },
-      manifestPath,
-    );
-    await service.createComponentContentSchemas(manifest);
-    expect(api.createContentSchema).toHaveBeenCalledTimes(0);
-  });
-
-  it('should handle errors - Axios error', async () => {
-    const manifest = new ManifestV1(
-      {
-        $schema: 'http://localhost:3000/schemas/v2.json#',
-        name: 'bar',
-        version: '1',
-        mainFunction: 'main',
-        namespace: 'foo',
-        displayName: 'some display name',
-        description: 'some description',
-        functions: [
-          {
-            name: 'f1',
-            input: {
-              type: 'object',
-            },
-            entry: 'f1.js',
-            output: { responseType: 'html' },
-          },
-        ],
-      },
-      manifestPath,
-    );
-    mockcreateContentSchema.mockImplementation(async () => {
-      const err = new AxiosError('some axios error');
-      err.response = {
-        data: {
-          message: 'some response error msg',
-        },
-        status: 400,
-        statusText: 'some status text',
-        headers: {},
-        config: {} as any,
-      };
-      throw err;
-    });
-    await expect(() => service.createComponentContentSchemas(manifest)).rejects.toThrowError('some response error msg');
-  });
-
-  it('should handle errors - other error', async () => {
-    const manifest = new ManifestV1(
-      {
-        $schema: 'http://localhost:3000/schemas/v2.json#',
-        name: 'bar',
-        version: '1',
-        mainFunction: 'main',
-        namespace: 'foo',
-        displayName: 'some display name',
-        description: 'some description',
-        functions: [
-          {
-            name: 'f1',
-            input: {
-              type: 'object',
-            },
-            entry: 'f1.js',
-            output: { responseType: 'html' },
-          },
-        ],
-      },
-      manifestPath,
-    );
-    mockcreateContentSchema.mockImplementation(async () => {
-      throw new Error('some other error');
-    });
-    await expect(() => service.createComponentContentSchemas(manifest)).rejects.toThrowError('some other error');
-  });
-});

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

@@ -1,53 +0,0 @@
-import { ContentApiService, ContentApi } from '@squiz/component-web-api-lib';
-import { Manifest } from '../../manifest';
-import { getContentSchemaName } from '../utils/getContentSchemaName';
-import { AxiosError } from 'axios';
-
-export class ComponentContentSchemaService {
-  constructor(private api: ContentApiService<null>['contentSchema']) {}
-
-  public async createComponentContentSchemas(componentManifest: Manifest, authorization?: string) {
-    const inputSchemas = componentManifest.getInputSchemas();
-
-    for (const inputSchema of inputSchemas) {
-      if (inputSchema.schema && Object.keys(inputSchema.schema).length) {
-        const name = getContentSchemaName(
-          componentManifest.getName(),
-          componentManifest.getVersion(),
-          inputSchema.name,
-        );
-
-        await this.createContentSchema(name, inputSchema.schema, authorization);
-      }
-    }
-  }
-
-  private async createContentSchema(name: string, schema: object, authorization?: string) {
-    try {
-      const headers: Record<string, string | number> = { 'Content-Type': 'application/json' };
-
-      if (authorization) {
-        headers['authorization'] = authorization;
-      }
-
-      await this.api.createContentSchema(
-        {
-          contentSchemaType: ContentApi.ContentSchemaType.Component,
-          schema: schema,
-          name: name,
-        },
-        { headers: headers },
-      );
-    } catch (e) {
-      throw this.handleAxiosError(e as AxiosError);
-    }
-  }
-
-  private handleAxiosError(error: AxiosError): Error {
-    const { response } = error;
-    if (!response || (typeof error == 'object' && !error.isAxiosError)) {
-      return error;
-    }
-    throw new Error(`Error occurred when creating content schema: ${(response.data as any)?.message}`);
-  }
-}

package/src/domains/content/services/ContentItemService.spec.ts

@@ -1,108 +0,0 @@
-import { ContentApiService } from '@squiz/component-web-api-lib';
-import { ContentItemService } from './ContentItemService';
-import { AxiosError } from 'axios';
-
-describe('ContentItemService', () => {
-  let service: ContentItemService;
-  let api: ContentApiService<null>['contentItem'];
-  const mockGetContentItem = jest.fn();
-  beforeAll(() => {
-    api = {
-      createContentItem: jest.fn(),
-      getPaginatedContentItems: jest.fn(),
-      updateContentItem: jest.fn(),
-      getContentItem: mockGetContentItem,
-      deleteContentItemById: jest.fn(),
-    };
-    service = new ContentItemService(api);
-  });
-
-  beforeEach(() => {
-    mockGetContentItem.mockClear();
-  });
-
-  it('should return the component item for given ID', async () => {
-    mockGetContentItem.mockImplementation(async () => {
-      return { data: { content: 'some-item-content' } };
-    });
-
-    const itemContent = await service.getContentItem('some-id-x');
-    expect(itemContent).toEqual('some-item-content');
-    expect(api.getContentItem).toHaveBeenCalledTimes(1);
-    expect(mockGetContentItem.mock.calls[0]).toEqual([
-      'some-id-x',
-      {
-        resolveDynamicContent: true,
-      },
-      {
-        headers: {},
-      },
-    ]);
-  });
-
-  it('should return NULL if component item not found for given ID', async () => {
-    mockGetContentItem.mockImplementation(async () => {
-      const err = new AxiosError('item not found');
-      err.response = {
-        data: {
-          message: 'item not found',
-        },
-        status: 404,
-        statusText: 'some status text',
-        headers: {},
-        config: {} as any,
-      };
-      throw err;
-    });
-
-    const itemContent = await service.getContentItem('some-id-x');
-    expect(itemContent).toEqual(undefined);
-    expect(api.getContentItem).toHaveBeenCalledTimes(1);
-    expect(mockGetContentItem.mock.calls[0]).toEqual([
-      'some-id-x',
-      {
-        resolveDynamicContent: true,
-      },
-      {
-        headers: {},
-      },
-    ]);
-  });
-
-  it('should handle errors - Axios error', async () => {
-    mockGetContentItem.mockImplementation(async () => {
-      const err = new AxiosError('some axios error');
-      err.response = {
-        data: {
-          message: 'some response error msg',
-        },
-        status: 400,
-        statusText: 'some status text',
-        headers: {},
-        config: {} as any,
-      };
-      throw err;
-    });
-    await expect(service.getContentItem('some-id-x')).rejects.toThrowError('some response error msg');
-  });
-
-  it('should handle errors - other error', async () => {
-    mockGetContentItem.mockImplementation(async () => {
-      throw new Error('some other error');
-    });
-    await expect(service.getContentItem('some-id-x')).rejects.toThrowError('some other error');
-  });
-
-  it('should proxy the api key to the underlying service', async () => {
-    mockGetContentItem.mockClear();
-    mockGetContentItem.mockImplementation(async () => ({ data: { content: {} } }));
-
-    await service.getContentItem('some id', 'some-key');
-
-    expect(mockGetContentItem).toHaveBeenCalledWith(
-      'some id',
-      { resolveDynamicContent: true },
-      { headers: { 'x-api-key': 'some-key' } },
-    );
-  });
-});

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

@@ -1,34 +0,0 @@
-import { ContentApiService } from '@squiz/component-web-api-lib';
-import { AxiosError } from 'axios';
-
-export class ContentItemService {
-  constructor(private api: ContentApiService<null>['contentItem']) {}
-
-  public async getContentItem(contentItemId: string, apiKey?: string): Promise<unknown> {
-    try {
-      const headers: Record<string, string | number> = {};
-
-      if (apiKey) {
-        headers['x-api-key'] = apiKey;
-      }
-
-      const response = await this.api.getContentItem(contentItemId, { resolveDynamicContent: true }, { headers });
-
-      return response.data.content;
-    } catch (e) {
-      const axiosError = e as AxiosError;
-      if (axiosError.response?.status === 404) {
-        return undefined;
-      }
-      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 in Component Content Item service: ${(response.data as any)?.message}`);
-  }
-}

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

@@ -1,97 +0,0 @@
-import { ContentApiService } from '@squiz/component-web-api-lib';
-import { DynamicContentItemService } from './DynamicContentItemService';
-import { AxiosError } from 'axios';
-
-describe('DynamicContentItemService', () => {
-  let service: DynamicContentItemService;
-  let api: ContentApiService<null>['dynamicContent'];
-  const mockGetContentItem = jest.fn();
-  beforeAll(() => {
-    api = {
-      getDynamicContentItem: mockGetContentItem,
-    };
-    service = new DynamicContentItemService(api);
-  });
-
-  beforeEach(() => {
-    mockGetContentItem.mockClear();
-  });
-
-  it('should return the component item for given ID', async () => {
-    mockGetContentItem.mockImplementation(async () => {
-      return { data: { content: 'some-item-content' } };
-    });
-
-    const itemContent = await service.getDynamicContentItem('some-id-x', 'some-key');
-    expect(itemContent).toEqual({ content: 'some-item-content' });
-    expect(api.getDynamicContentItem).toHaveBeenCalledTimes(1);
-    expect(mockGetContentItem.mock.calls[0]).toEqual([
-      {
-        _contentUri: 'some-id-x',
-      },
-      {
-        headers: {
-          'x-api-key': 'some-key',
-        },
-      },
-    ]);
-  });
-
-  it('should return an error when content item cant be found', async () => {
-    mockGetContentItem.mockImplementation(async () => {
-      const err = new AxiosError('item not found');
-      err.response = {
-        data: {
-          message: 'item not found',
-        },
-        status: 404,
-        statusText: 'some status text',
-        headers: {},
-        config: {} as any,
-      };
-      throw err;
-    });
-
-    await expect(service.getDynamicContentItem('some-id-x', 'some-key')).rejects.toThrowErrorMatchingInlineSnapshot(
-      `"Error occurred when resolving content from uri: item not found"`,
-    );
-  });
-
-  it('should handle errors - Axios error', async () => {
-    mockGetContentItem.mockImplementation(async () => {
-      const err = new AxiosError('some axios error');
-      err.response = {
-        data: {
-          message: 'some response error msg',
-        },
-        status: 400,
-        statusText: 'some status text',
-        headers: {},
-        config: {} as any,
-      };
-      throw err;
-    });
-    await expect(service.getDynamicContentItem('some-id-x', 'some-key')).rejects.toThrowError(
-      'some response error msg',
-    );
-  });
-
-  it('should handle errors - other error', async () => {
-    mockGetContentItem.mockImplementation(async () => {
-      throw new Error('some other error');
-    });
-    await expect(service.getDynamicContentItem('some-id-x', 'some-key')).rejects.toThrowError('some other error');
-  });
-
-  it('should proxy the api key to the underlying service', async () => {
-    mockGetContentItem.mockClear();
-    mockGetContentItem.mockImplementation(async () => ({ data: { content: {} } }));
-
-    await service.getDynamicContentItem('some id', 'some-key');
-
-    expect(mockGetContentItem).toHaveBeenCalledWith(
-      { _contentUri: 'some id' },
-      { headers: { 'x-api-key': 'some-key' } },
-    );
-  });
-});