@squiz/job-runner-lib 1.66.1

package/src/domains/job/utils/SlackClient/SlackClient.spec.ts

@@ -0,0 +1,176 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { faker } from '@faker-js/faker/locale/en';
+import { SlackClient } from './SlackClient';
+import {
+  SLACK_ALERT_LEVEL_ERROR,
+  SLACK_ALERT_LEVEL_INFO,
+  SLACK_ALERT_LEVEL_SUCCESS,
+  SLACK_ALERT_LEVEL_WARNING,
+  SlackAlertLevel,
+} from './types/SlackClient.types';
+
+describe('SlackClient singleton methods', () => {
+  let mockRegion: string;
+  let mockEnvironment: string;
+  let mockWebhookUrl: string;
+  let mockApplication: string;
+
+  let slackClient: SlackClient;
+
+  beforeEach(() => {
+    mockRegion = 'us';
+    mockEnvironment = 'dev';
+    mockWebhookUrl = 'https://example.com';
+    mockApplication = 'Job Runner';
+
+    SlackClient.initialize(mockEnvironment, mockRegion, mockWebhookUrl, mockApplication);
+
+    slackClient = SlackClient.getClient();
+  });
+
+  describe('initialize', () => {
+    it('should throw an error if environment, region, webhook URL or application are undefined', () => {
+      expect(() => SlackClient.initialize(undefined, mockRegion, mockWebhookUrl, mockApplication)).toThrowError(
+        new Error('Failed to initialize SlackClient, environment vars not set'),
+      );
+
+      expect(() => SlackClient.initialize(mockEnvironment, undefined, mockWebhookUrl, mockApplication)).toThrowError(
+        new Error('Failed to initialize SlackClient, environment vars not set'),
+      );
+
+      expect(() => SlackClient.initialize(mockEnvironment, mockRegion, undefined, mockApplication)).toThrowError(
+        new Error('Failed to initialize SlackClient, environment vars not set'),
+      );
+
+      expect(() => SlackClient.initialize(mockEnvironment, mockRegion, mockWebhookUrl, undefined)).toThrowError(
+        new Error('Failed to initialize SlackClient, environment vars not set'),
+      );
+
+      expect(() => SlackClient.initialize()).toThrowError(
+        new Error('Failed to initialize SlackClient, environment vars not set'),
+      );
+    });
+
+    it('should not throw an error if environment, region, webhook URL and application are defined/valid', () => {
+      expect(() =>
+        SlackClient.initialize(mockEnvironment, mockRegion, mockWebhookUrl, mockApplication),
+      ).not.toThrowError();
+    });
+  });
+
+  describe('getClient', () => {
+    it('should return the existing instance of SlackClient', () => {
+      const localSlackClient = SlackClient.getClient();
+      expect(localSlackClient).toBe(slackClient);
+    });
+  });
+
+  describe('getIcon', () => {
+    it('should return an icon matching the alert level', () => {
+      const errorIcon = SlackClient.getIcon(SLACK_ALERT_LEVEL_ERROR);
+      expect(errorIcon).toBe(':alert:');
+
+      const warningIcon = SlackClient.getIcon(SLACK_ALERT_LEVEL_WARNING);
+      expect(warningIcon).toBe('⚠️');
+
+      const infoIcon = SlackClient.getIcon(SLACK_ALERT_LEVEL_INFO);
+      expect(infoIcon).toBe('ℹ️');
+
+      const successIcon = SlackClient.getIcon(SLACK_ALERT_LEVEL_SUCCESS);
+      expect(successIcon).toBe('✅');
+    });
+
+    it('should return an "INFO" icon by default', () => {
+      const icon = SlackClient.getIcon();
+      expect(icon).toBe('ℹ️');
+    });
+
+    it('should return "null" for unknown alert level', () => {
+      const badIcon = SlackClient.getIcon('unknown' as SlackAlertLevel);
+      expect(badIcon).toBe(null);
+    });
+  });
+
+  describe('getRequestBody', () => {
+    it('should generate request body for Slack based on message and alert level', () => {
+      const mockMessage = faker.lorem.sentence();
+
+      const mockLevel: SlackAlertLevel = faker.helpers.arrayElement([
+        SLACK_ALERT_LEVEL_ERROR,
+        SLACK_ALERT_LEVEL_WARNING,
+        SLACK_ALERT_LEVEL_INFO,
+        SLACK_ALERT_LEVEL_SUCCESS,
+      ]);
+
+      const mockIcon = SlackClient.getIcon(mockLevel);
+
+      const requestBody = SlackClient.getRequestBody(mockMessage, mockLevel);
+
+      expect(requestBody.text).toContain(mockIcon);
+      expect(requestBody.text).toContain(mockMessage);
+      expect(requestBody.text).toContain(`${mockEnvironment[0].toUpperCase()}${mockEnvironment.slice(1)}`);
+      expect(requestBody.text).toContain(mockRegion.toUpperCase());
+      expect(requestBody.text).toContain(mockApplication);
+    });
+
+    it('should generate request body for an INFO alert if level not provided', () => {
+      const mockMessage = faker.lorem.sentence();
+      const mockInfoIcon = SlackClient.getIcon();
+
+      const requestBody = SlackClient.getRequestBody(mockMessage);
+
+      expect(requestBody.text).toContain(mockInfoIcon);
+    });
+  });
+
+  describe('sendAlert', () => {
+    const fetchSpy = jest.spyOn(global, 'fetch');
+
+    let mockMessage: string;
+
+    beforeEach(() => {
+      mockMessage = faker.lorem.sentence();
+
+      jest.resetAllMocks();
+    });
+
+    it('should make a POST request to the Slack webhook URL', async () => {
+      fetchSpy.mockImplementation(
+        jest.fn(() =>
+          Promise.resolve({
+            status: 200,
+            json: () => Promise.resolve({}),
+          }),
+        ) as jest.Mock,
+      );
+
+      expect(async () => await slackClient.sendAlert(mockMessage)).not.toThrowError();
+      expect(fetchSpy).toHaveBeenCalled();
+    });
+
+    it('should throw an error if request fails', async () => {
+      fetchSpy.mockImplementation(
+        jest.fn(() =>
+          Promise.resolve({
+            status: 401,
+            headers: new Headers({ 'Content-Type': 'application/json' }),
+            json: () => Promise.resolve({ message: 'Unauthorized' }),
+            text: () => Promise.resolve('Unauthorized'),
+          }),
+        ) as jest.Mock,
+      );
+      const consoleLogSpy = jest.spyOn(console, 'log');
+
+      const mockMessage = 'Test Alert Message';
+
+      await slackClient.sendAlert(mockMessage);
+
+      expect(consoleLogSpy).toBeCalledTimes(1);
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('SlackClient failed with 401 status'));
+    });
+  });
+});

package/src/domains/job/utils/SlackClient/SlackClient.ts

@@ -0,0 +1,132 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import {
+  SLACK_ALERT_LEVEL_ERROR,
+  SLACK_ALERT_LEVEL_INFO,
+  SLACK_ALERT_LEVEL_SUCCESS,
+  SLACK_ALERT_LEVEL_WARNING,
+  SlackAlertLevel,
+  SlackAlertRequestBody,
+} from './types/SlackClient.types';
+
+export class SlackClient {
+  private static instance: SlackClient;
+  protected static application: string;
+  protected static environment: string;
+  protected static region: string;
+  protected static webhookUrl: string;
+
+  /**
+   * Initializes the Slack Client with the required environment vars.
+   * @param {string} environment Deployment environment of application.
+   * @param {string} region Region application is deployed to 'us' | 'uk' | 'au' as per AWS environment.
+   * @param {string} webhookUrl Webhook URL for sending Slack messages.
+   * @param {string} application Name of the application.
+   */
+  public static initialize(environment = '', region = '', webhookUrl = '', application = ''): void {
+    if (environment === '' || region === '' || webhookUrl === '' || application === '') {
+      throw new Error('Failed to initialize SlackClient, environment vars not set');
+    } else {
+      SlackClient.environment = `${environment[0].toUpperCase()}${environment.slice(1)}`;
+      SlackClient.region = region.toUpperCase();
+      SlackClient.webhookUrl = webhookUrl;
+      SlackClient.application = application;
+    }
+  }
+
+  /**
+   * The static method that controls the access to the singleton instance for Slack Client.
+   * @returns {SlackClient} The singleton instance.
+   */
+  public static getClient(): SlackClient {
+    if (!SlackClient.instance) {
+      SlackClient.instance = new SlackClient();
+    }
+
+    return SlackClient.instance;
+  }
+
+  /**
+   * Generate the body of the request for sending to Slack.
+   * @param {SlackAlertLevel} level Level associated with alert.
+   * @returns {string | null} The icon matching the alert level.
+   */
+  public static getIcon = (level: SlackAlertLevel = SLACK_ALERT_LEVEL_INFO): string | null => {
+    let icon = null;
+
+    switch (level) {
+      case SLACK_ALERT_LEVEL_ERROR:
+        icon = ':alert:';
+        break;
+      case SLACK_ALERT_LEVEL_WARNING:
+        icon = '⚠️';
+        break;
+      case SLACK_ALERT_LEVEL_INFO:
+        icon = 'ℹ️';
+        break;
+      case SLACK_ALERT_LEVEL_SUCCESS:
+        icon = '✅';
+        break;
+      default:
+        icon = null;
+        break;
+    }
+
+    return icon;
+  };
+
+  /**
+   * Generate the body of the request for sending to Slack.
+   * @param {string} message Message to be sent to Slack channel.
+   * @param {SlackAlertLevel} level Level associated with alert.
+   * @returns {SlackAlertRequestBody} Slack alert request body.
+   */
+  public static getRequestBody = (
+    message: string,
+    level: SlackAlertLevel = SLACK_ALERT_LEVEL_INFO,
+  ): SlackAlertRequestBody => {
+    const icon = this.getIcon(level);
+
+    const header = `${icon} *[${SlackClient.environment}] ${SlackClient.application} ${SlackClient.region}*`;
+    const text = `${header}\n${message}`;
+
+    const requestBody: SlackAlertRequestBody = {
+      text,
+    };
+    return requestBody;
+  };
+
+  /**
+   * Post a new message/alert to the Webhook URL.
+   * @param {string} message Message to be sent.
+   * @param {SlackAlertLevel} level Level associated with message.
+   */
+  public sendAlert = async (message: string, level: SlackAlertLevel = SLACK_ALERT_LEVEL_INFO): Promise<void> => {
+    const requestBody = SlackClient.getRequestBody(message, level);
+
+    try {
+      const request = new Request(`${SlackClient.webhookUrl}`, {
+        method: 'POST',
+        body: JSON.stringify(requestBody),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      const response = await fetch(request);
+
+      if (response.status !== 200) {
+        // eslint-disable-next-line no-console
+        console.log(`SlackClient failed with ${response.status} status`);
+        return;
+      }
+    } catch (e) {
+      /* eslint-disable-next-line no-console */
+      console.log(`Slack Client api call: ${e}`);
+      throw e;
+    }
+  };
+}

package/src/domains/job/utils/SlackClient/types/SlackClient.types.ts

@@ -0,0 +1,70 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+/**
+ * The alert level expected to be sent to Slack Client.
+ * @export
+ */
+export type SlackAlertLevel =
+  | SlackAlertLevelInfo
+  | SlackAlertLevelError
+  | SlackAlertLevelWarning
+  | SlackAlertLevelSuccess;
+
+/**
+ * The alert level info type.
+ * @export
+ */
+export type SlackAlertLevelInfo = typeof SLACK_ALERT_LEVEL_INFO;
+
+/**
+ * The alert level error type.
+ * @export
+ */
+export type SlackAlertLevelError = typeof SLACK_ALERT_LEVEL_ERROR;
+
+/**
+ * The alert level warning type.
+ * @export
+ */
+export type SlackAlertLevelWarning = typeof SLACK_ALERT_LEVEL_WARNING;
+
+/**
+ * The alert level success type.
+ * @export
+ */
+export type SlackAlertLevelSuccess = typeof SLACK_ALERT_LEVEL_SUCCESS;
+
+/**
+ * The alert level info constant.
+ * @export
+ */
+export const SLACK_ALERT_LEVEL_INFO = `INFO`;
+
+/**
+ * The alert level error constant.
+ * @export
+ */
+export const SLACK_ALERT_LEVEL_ERROR = `ERROR`;
+
+/**
+ * The alert level warning constant.
+ * @export
+ */
+export const SLACK_ALERT_LEVEL_WARNING = `WARNING`;
+
+/**
+ * The alert level success constant.
+ * @export
+ */
+export const SLACK_ALERT_LEVEL_SUCCESS = `SUCCESS`;
+
+/**
+ * The request body expected to be sent to Slack Client.
+ * @export
+ */
+export type SlackAlertRequestBody = {
+  text: string;
+};

package/src/domains/job/utils/SortByTimeQueued/SortByTimeQueued.spec.ts

@@ -0,0 +1,28 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { faker } from '@faker-js/faker/locale/en';
+import { createMockJobExecution } from '../../model/JobExecution';
+import { sortByTimeQueued } from './SortByTimeQueued';
+
+describe(`sortByTimeQueued`, () => {
+  const earlierExecution = createMockJobExecution({ timeQueued: faker.date.recent().toISOString() });
+  const laterExecution = createMockJobExecution({ timeQueued: faker.date.soon().toISOString() });
+
+  it(`should return -1 if the first execution comes BEFORE the second execution`, () => {
+    const result = sortByTimeQueued(earlierExecution, laterExecution);
+    expect(result).toBe(-1);
+  });
+
+  it(`should return 1 if the first execution comes AFTER the second execution`, () => {
+    const result = sortByTimeQueued(laterExecution, earlierExecution);
+    expect(result).toBe(1);
+  });
+
+  it(`should return 0 if both executions share the same time queued`, () => {
+    const result = sortByTimeQueued(earlierExecution, earlierExecution);
+    expect(result).toBe(0);
+  });
+});

package/src/domains/job/utils/SortByTimeQueued/SortByTimeQueued.ts

@@ -0,0 +1,21 @@
+/*!
+ * @license
+ * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
+ */
+
+import { JobExecution } from '../../model/JobExecution';
+
+/**
+ * The comparison function to sort job executions by time added to queue (`timeQueued`).
+ */
+export const sortByTimeQueued = (a: JobExecution, b: JobExecution): number => {
+  if (a.timeQueued < b.timeQueued) {
+    return -1;
+  }
+
+  if (a.timeQueued > b.timeQueued) {
+    return 1;
+  }
+
+  return 0;
+};

package/src/domains/job/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './SlackClient/SlackClient';
+export * from './SlackClient/types/SlackClient.types';
+export * from './SortByTimeQueued/SortByTimeQueued';

package/src/domains/manifest/AbstractManifest.ts

@@ -0,0 +1,57 @@
+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/ManifestModel.ts

@@ -0,0 +1,9 @@
+import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
+import { ManifestV1 } from './ManifestV1';
+
+export type ManifestV1Model = MANIFEST_MODELS.v1.ComponentManifest;
+export type ManifestModel = ManifestV1Model;
+export type Manifest = ManifestV1;
+
+export type JobManifestV1Model = MANIFEST_MODELS.JobV1.JobManifest;
+export type JobManifestModel = JobManifestV1Model;