@squiz/job-runner-lib 1.66.1

package/src/domains/component-set/models/ComponentSet.spec.ts

@@ -0,0 +1,66 @@
+import { ComponentSet } from './ComponentSet';
+
+describe('ComponentSetImpl', () => {
+  it('should create object if only web path provided', () => {
+    expect(
+      new ComponentSet({
+        webPath: 'web-path',
+      }),
+    ).toEqual(
+      new ComponentSet({
+        webPath: 'web-path',
+      }),
+    );
+  });
+
+  it('should not allow empty web path', () => {
+    expect(
+      () =>
+        new ComponentSet({
+          webPath: '',
+          displayName: 'display-name',
+          description: 'description',
+
+          environmentVariables: {},
+          headers: {},
+        }),
+    ).toThrowErrorMatchingInlineSnapshot('"webPath.length must have length greater than 0"');
+  });
+
+  it('should not allow missing web path', () => {
+    expect(
+      () =>
+        new ComponentSet({
+          displayName: 'display-name',
+          description: 'description',
+
+          environmentVariables: {},
+          headers: {},
+        }),
+    ).toThrowErrorMatchingInlineSnapshot('"webPath must be a string"');
+  });
+
+  it('should set provided properties', () => {
+    expect(
+      new ComponentSet({
+        webPath: 'web-path',
+
+        displayName: 'display-name',
+        description: 'description',
+
+        environmentVariables: { my_var: '123' },
+        headers: { 'my-header': '123' },
+      }),
+    ).toEqual(
+      new ComponentSet({
+        webPath: 'web-path',
+
+        displayName: 'display-name',
+        description: 'description',
+
+        environmentVariables: { my_var: '123' },
+        headers: { 'my-header': '123' },
+      }),
+    );
+  });
+});

package/src/domains/component-set/models/ComponentSet.ts

@@ -0,0 +1,67 @@
+import {
+  assertIsDefined,
+  assertIsString,
+  assertIsMapOfStringString,
+  assertAssign,
+  assertAssignWithDefaultUndefinedValue,
+} from '@squiz/dx-common-lib';
+import { AssertionError } from 'assert';
+import { Headers } from '../services/Headers';
+
+export interface ComponentSetInterface {
+  webPath: string;
+  displayName: string;
+  description: string;
+
+  environmentVariables: { [key: string]: string };
+  headers: Headers;
+}
+
+const VALID_WEB_PATH_REGEX = /^[a-z0-9\-_.]+$/i;
+
+export class ComponentSet implements ComponentSetInterface {
+  public webPath: string;
+  public displayName: string;
+  public description: string;
+
+  public environmentVariables: { [key: string]: string };
+  public headers: Headers;
+
+  constructor(data?: Record<string, unknown>) {
+    assertIsDefined(data);
+
+    this.webPath = assertAssign(data.webPath, assertIsString, 'webPath must be a string');
+
+    this.displayName = assertAssignWithDefaultUndefinedValue(
+      data.displayName,
+      assertIsString,
+      '',
+      'displayName must be a string',
+    );
+    this.description = assertAssignWithDefaultUndefinedValue(
+      data.description,
+      assertIsString,
+      '',
+      'description must be a string',
+    );
+
+    this.environmentVariables = assertAssignWithDefaultUndefinedValue(
+      data.environmentVariables,
+      assertIsMapOfStringString,
+      {},
+    );
+    this.headers = assertAssignWithDefaultUndefinedValue(data.headers, assertIsMapOfStringString, {});
+
+    if (this.webPath.length === 0) {
+      throw new AssertionError({
+        message: 'webPath.length must have length greater than 0',
+      });
+    }
+
+    if (VALID_WEB_PATH_REGEX.test(this.webPath) === false) {
+      throw new AssertionError({
+        message: `Invalid Component Set web path, it must meet ${VALID_WEB_PATH_REGEX.toString()}`,
+      });
+    }
+  }
+}

package/src/domains/component-set/models/ComponentSetComponentVersion.spec.ts

@@ -0,0 +1,106 @@
+import { ComponentSetComponentVersion, ComponentSetComponentVersionStatus } from './ComponentSetComponentVersion';
+
+describe('ComponentSetComponentVersion', () => {
+  it('should create component set component version if webPath, component name and version are provided', () => {
+    const model = new ComponentSetComponentVersion({
+      componentSetWebPath: 'web-path',
+      componentName: 'name',
+      componentVersion: 'version',
+    });
+
+    expect(model.componentSetWebPath).toEqual('web-path');
+    expect(model.componentName).toEqual('name');
+    expect(model.componentVersion).toEqual('version');
+  });
+
+  it('should set default status to "active" when not provided', () => {
+    const model = new ComponentSetComponentVersion({
+      componentSetWebPath: 'web-path',
+      componentName: 'name',
+      componentVersion: 'version',
+    });
+
+    expect(model.status).toEqual(ComponentSetComponentVersionStatus.active);
+  });
+
+  it('should allow creation with optional environmentVariables', () => {
+    const model = new ComponentSetComponentVersion({
+      componentSetWebPath: 'web-path',
+      componentName: 'name',
+      componentVersion: 'version',
+
+      environmentVariables: {
+        var: '123',
+      },
+    });
+
+    expect(model.componentSetWebPath).toEqual('web-path');
+    expect(model.componentName).toEqual('name');
+    expect(model.componentVersion).toEqual('version');
+    expect(model.environmentVariables).toEqual({
+      var: '123',
+    });
+  });
+
+  it('should allow "status" to be set', () => {
+    const model = new ComponentSetComponentVersion({
+      componentSetWebPath: 'web-path',
+      componentName: 'name',
+      componentVersion: 'version',
+      status: ComponentSetComponentVersionStatus.excluded,
+    });
+
+    expect(model.componentSetWebPath).toEqual('web-path');
+    expect(model.componentName).toEqual('name');
+    expect(model.componentVersion).toEqual('version');
+    expect(model.status).toEqual(ComponentSetComponentVersionStatus.excluded);
+  });
+
+  it('should throw error if componentSetWebPath not provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersion({
+          componentName: 'name',
+          componentVersion: 'version',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"componentSetWebPath must be a string"`);
+  });
+
+  it('should throw error if componentName not provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersion({
+          componentSetWebPath: 'web-path',
+
+          componentVersion: 'version',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"componentName must be a string"`);
+  });
+
+  it('should throw error if componentVersion not provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersion({
+          componentSetWebPath: 'web-path',
+          componentName: 'name',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"componentVersion must be a string"`);
+  });
+
+  it('should throw error if "status" is not a valid enum value', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersion({
+          componentSetWebPath: 'web-path',
+          componentName: 'name',
+          componentVersion: 'version',
+          status: 'foo',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      "'foo' in [
+        'active',
+        'excluded'
+      ]"
+    `);
+  });
+});

package/src/domains/component-set/models/ComponentSetComponentVersion.ts

@@ -0,0 +1,54 @@
+import {
+  assertIsString,
+  assertIsDefined,
+  assertIsMapOfStringString,
+  assertAssign,
+  assertAssignWithDefaultUndefinedValue,
+  assertIsEnumValue,
+} from '@squiz/dx-common-lib';
+
+export enum ComponentSetComponentVersionStatus {
+  active = 'active',
+  excluded = 'excluded',
+}
+
+export interface ComponentSetComponentVersionInterface {
+  componentSetWebPath: string;
+  componentName: string;
+  componentVersion: string;
+  environmentVariables: { [key: string]: string };
+  status: ComponentSetComponentVersionStatus;
+}
+
+export class ComponentSetComponentVersion implements ComponentSetComponentVersionInterface {
+  public componentSetWebPath: string = '';
+  public componentName: string = '';
+  public componentVersion: string = '';
+  public environmentVariables: { [key: string]: string };
+  public status: ComponentSetComponentVersionStatus = ComponentSetComponentVersionStatus.active;
+
+  constructor(data?: Record<string, unknown>) {
+    assertIsDefined(data);
+
+    this.componentSetWebPath = assertAssign(
+      data.componentSetWebPath,
+      assertIsString,
+      'componentSetWebPath must be a string',
+    );
+
+    this.componentName = assertAssign(data.componentName, assertIsString, 'componentName must be a string');
+    this.componentVersion = assertAssign(data.componentVersion, assertIsString, 'componentVersion must be a string');
+
+    this.environmentVariables = assertAssignWithDefaultUndefinedValue(
+      data.environmentVariables,
+      assertIsMapOfStringString,
+      {},
+    );
+
+    if (data.status === undefined) {
+      data.status = ComponentSetComponentVersionStatus.active;
+    }
+    assertIsEnumValue(data.status, ComponentSetComponentVersionStatus);
+    this.status = data.status as ComponentSetComponentVersionStatus;
+  }
+}

package/src/domains/component-set/models/ComponentSetComponentVersionEditable.spec.ts

@@ -0,0 +1,82 @@
+import { ComponentSetComponentVersionEditable } from './ComponentSetComponentVersionEditable';
+
+describe('ComponentSetComponentVersionEditable', () => {
+  it('should create component set component version editable if webPath, component name and version are provided', () => {
+    const model = new ComponentSetComponentVersionEditable({
+      componentSetWebPath: 'web-path',
+      componentName: 'name',
+      componentVersion: '1.1.1',
+    });
+
+    expect(model.componentSetWebPath).toEqual('web-path');
+    expect(model.componentName).toEqual('name');
+    expect(model.componentVersion).toEqual('1.1.1');
+  });
+
+  it('should throw error if componentSetWebPath not provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersionEditable({
+          componentName: 'name',
+          componentVersion: 'version',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+  });
+
+  it('should throw error if componentName not provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersionEditable({
+          componentSetWebPath: 'web-path',
+
+          componentVersion: 'version',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+  });
+
+  it('should throw error if componentVersion not provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersionEditable({
+          componentSetWebPath: 'web-path',
+          componentName: 'name',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"value is not a string"`);
+  });
+
+  it('should create component set component version editable if "latest" version value is provided', () => {
+    const model = new ComponentSetComponentVersionEditable({
+      componentSetWebPath: 'web-path',
+      componentName: 'name',
+      componentVersion: 'latest',
+    });
+
+    expect(model.componentSetWebPath).toEqual('web-path');
+    expect(model.componentName).toEqual('name');
+    expect(model.componentVersion).toEqual('latest');
+  });
+
+  it('should throw error if invalid semvar version is provided', () => {
+    ['foo', '1.1.', '1.2.*', '1.1.1.1'].map((v) => {
+      expect(
+        () =>
+          new ComponentSetComponentVersionEditable({
+            componentSetWebPath: 'web-path',
+            componentName: 'name',
+            componentVersion: v,
+          }),
+      ).toThrowErrorMatchingInlineSnapshot(`"editable component version must be a valid semver version or "latest""`);
+    });
+  });
+
+  it('should throw error if invalid version is provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersionEditable({
+          componentSetWebPath: 'web-path',
+          componentName: 'name',
+          componentVersion: '*&.1.1',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"editable component version must be a valid semver version or "latest""`);
+  });
+});

package/src/domains/component-set/models/ComponentSetComponentVersionEditable.ts

@@ -0,0 +1,46 @@
+import { assertIsString, assertIsDefined, assertIsMapOfStringString } from '@squiz/dx-common-lib';
+import * as assert from 'assert/strict';
+import * as semver from 'semver';
+import { EditableComponentVersionTypes } from '../web-models/ComponentSetForWeb';
+
+export interface ComponentSetComponentVersionEditableInterface {
+  componentSetWebPath: string;
+  componentName: string;
+  componentVersion: string;
+}
+
+export class ComponentSetComponentVersionEditable implements ComponentSetComponentVersionEditableInterface {
+  public componentSetWebPath: string = '';
+  public componentName: string = '';
+  public componentVersion: string = '';
+
+  constructor(data?: Record<string, unknown>) {
+    assertIsComponentVersionEditable(data);
+
+    this.componentSetWebPath = data.componentSetWebPath;
+    this.componentName = data.componentName;
+    this.componentVersion = data.componentVersion;
+  }
+}
+
+export function assertIsComponentVersionEditable(
+  data?: unknown,
+): asserts data is ComponentSetComponentVersionEditableInterface {
+  assertIsDefined(data);
+  assertIsMapOfStringString(data);
+
+  assertIsString(data['componentName']);
+  assert.ok(data['componentName'].length > 0, 'componentName must not be an empty string');
+
+  assertIsString(data['componentSetWebPath']);
+  assert.ok(data['componentSetWebPath'].length > 0, 'componentSetWebPath must not be an empty string');
+
+  assertIsString(data['componentVersion']);
+  assert.ok(data['componentVersion'].length > 0, 'editable component version must not be an empty string');
+  if (data['componentVersion'] !== EditableComponentVersionTypes.Latest) {
+    assert.ok(
+      semver.valid(data['componentVersion']),
+      `editable component version must be a valid semver version or "${EditableComponentVersionTypes.Latest}"`,
+    );
+  }
+}

package/src/domains/component-set/models/ComponentSetComponentVersionExcluded.spec.ts

@@ -0,0 +1,46 @@
+import { ComponentSetComponentVersionExcluded } from './ComponentSetComponentVersionExcluded';
+
+describe('ComponentSetComponentVersionExcluded', () => {
+  it('should create component set component version excluded if webPath, component name and version are provided', () => {
+    const model = new ComponentSetComponentVersionExcluded({
+      componentSetWebPath: 'web-path',
+      componentName: 'name',
+      componentVersion: 'version',
+    });
+
+    expect(model.componentSetWebPath).toEqual('web-path');
+    expect(model.componentName).toEqual('name');
+    expect(model.componentVersion).toEqual('version');
+  });
+
+  it('should throw error if componentSetWebPath not provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersionExcluded({
+          componentName: 'name',
+          componentVersion: 'version',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"componentSetWebPath must be a string"`);
+  });
+
+  it('should throw error if componentName not provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersionExcluded({
+          componentSetWebPath: 'web-path',
+
+          componentVersion: 'version',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"componentName must be a string"`);
+  });
+
+  it('should throw error if componentVersion not provided', () => {
+    expect(
+      () =>
+        new ComponentSetComponentVersionExcluded({
+          componentSetWebPath: 'web-path',
+          componentName: 'name',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"componentVersion must be a string"`);
+  });
+});

package/src/domains/component-set/models/ComponentSetComponentVersionExcluded.ts

@@ -0,0 +1,26 @@
+import { assertIsString, assertIsDefined, assertAssign } from '@squiz/dx-common-lib';
+
+export interface ComponentSetComponentVersionExcludedInterface {
+  componentSetWebPath: string;
+  componentName: string;
+  componentVersion: string;
+}
+
+export class ComponentSetComponentVersionExcluded implements ComponentSetComponentVersionExcludedInterface {
+  public componentSetWebPath: string = '';
+  public componentName: string = '';
+  public componentVersion: string = '';
+
+  constructor(data?: Record<string, unknown>) {
+    assertIsDefined(data);
+
+    this.componentSetWebPath = assertAssign(
+      data.componentSetWebPath,
+      assertIsString,
+      'componentSetWebPath must be a string',
+    );
+
+    this.componentName = assertAssign(data.componentName, assertIsString, 'componentName must be a string');
+    this.componentVersion = assertAssign(data.componentVersion, assertIsString, 'componentVersion must be a string');
+  }
+}

package/src/domains/component-set/models/ComponentSetRule.spec.ts

@@ -0,0 +1,39 @@
+import { ComponentSetRule } from './ComponentSetRule';
+
+describe('ComponentSetRule', () => {
+  const validAttributes = {
+    componentName: 'some componentName',
+    componentSet: 'some componentSet',
+    versionPattern: '^1.0.0',
+  };
+
+  it('returns a valid model with valid attributes', () => {
+    expect(new ComponentSetRule(validAttributes)).toEqual(validAttributes);
+  });
+
+  it('returns a valid model with a superset of valid attributes', () => {
+    expect(new ComponentSetRule({ ...validAttributes, notRealAttribute: '124' })).toEqual(validAttributes);
+  });
+
+  const requiredAttributes = ['componentName', 'componentSet'];
+  it.each(requiredAttributes)('errors for %s on empty property', (property) => {
+    expect(() => new ComponentSetRule({ ...validAttributes, [property]: '' })).toThrowError(
+      `${property} must not be an empty string`,
+    );
+  });
+
+  const invalidSemvers = ['abc', '1.0.0.0', '$1.0.0', 'abc-1.0.0', '1*'];
+  it.each(invalidSemvers)('errors on invalid versionPattern with %s', (invalidVersion) => {
+    expect(() => new ComponentSetRule({ ...validAttributes, versionPattern: invalidVersion })).toThrowError(
+      'versionPattern must be a valid semver',
+    );
+  });
+
+  const validSemvers = ['^1.0.0', '1.4.5', '~0.0.1', '*', '1.*', ''];
+  it.each(validSemvers)('returns a valid model with valid versionPattern %s', (validVersion) => {
+    expect(new ComponentSetRule({ ...validAttributes, versionPattern: validVersion })).toHaveProperty(
+      'versionPattern',
+      validVersion,
+    );
+  });
+});

package/src/domains/component-set/models/ComponentSetRule.ts

@@ -0,0 +1,37 @@
+import { assertIsDefined, assertIsMapOfStringString, assertIsString } from '@squiz/dx-common-lib';
+import * as assert from 'assert/strict';
+import * as semver from 'semver';
+
+export interface ComponentSetRuleInterface {
+  componentName: string;
+  componentSet: string;
+  versionPattern: string;
+}
+
+export class ComponentSetRule implements ComponentSetRuleInterface {
+  public componentName: string;
+  public componentSet: string;
+  public versionPattern: string;
+
+  constructor(data?: Record<string, unknown>) {
+    assertIsCompenentSetRule(data);
+
+    this.componentName = data.componentName;
+    this.componentSet = data.componentSet;
+    this.versionPattern = data.versionPattern;
+  }
+}
+
+export function assertIsCompenentSetRule(data?: unknown): asserts data is ComponentSetRuleInterface {
+  assertIsDefined(data);
+  assertIsMapOfStringString(data);
+
+  assertIsString(data['componentName']);
+  assert.ok(data['componentName'].length > 0, 'componentName must not be an empty string');
+
+  assertIsString(data['componentSet']);
+  assert.ok(data['componentSet'].length > 0, 'componentSet must not be an empty string');
+
+  assertIsString(data['versionPattern']);
+  assert.ok(semver.validRange(data['versionPattern']), 'versionPattern must be a valid semver');
+}