@squiz/job-runner-lib 1.66.1

package/src/domains/component/component-context/__mocks__/mockedUriObjPreview.ts

@@ -0,0 +1,38 @@
+import { UriResource } from '../../services/content-item-uri-resolver/ComponentContentUriResolverForPreview';
+
+const mockedUriObjPreview: UriResource = {
+  id: '2',
+  type: 'root_folder',
+  type_name: 'Root Folder',
+  version: '0.0.1',
+  name: 'Root Folder',
+  short_name: '/',
+  status: {
+    id: 2,
+    code: 'under_construction',
+  },
+  created: {
+    date: '2020-02-27T09:47:27+11:00',
+    user_id: null,
+  },
+  updated: {
+    date: '2020-02-27T09:47:27+11:00',
+    user_id: '',
+  },
+  published: {
+    date: '2020-02-27T09:47:27+11:00',
+    user_id: 'null',
+  },
+  status_changed: {
+    date: '2020-02-27T09:47:27+11:00',
+    user_id: 'null',
+  },
+  url: 'xxx',
+  urls: [],
+  attributes: {
+    test: 'test',
+  },
+  additional: {},
+};
+
+export default mockedUriObjPreview;

package/src/domains/component/component-context/createComponentContextualFunctions.spec.ts

@@ -0,0 +1,299 @@
+import { RuntimeComponentSet } from '../../component-set/services/RuntimeComponentSet';
+import { createComponentContextualFunctions } from './createComponentContextualFunctions';
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+import mockedManifest from './__mocks__/mockedManifestModel';
+import mockedUriObj from './__mocks__/mockedUriObj';
+import mockedUriObjPreview from './__mocks__/mockedUriObjPreview';
+
+const manifest = mockedManifest;
+const webRequestEvents: EventEmitter = new EventEmitter();
+
+describe('createComponentContextualFunctions', () => {
+  const set: RuntimeComponentSet = { displayName: 'a name!!', webPath: 'my-set', environment: {} };
+  let requestId = randomUUID();
+
+  describe('getStaticResourceUrl', () => {
+    it('should have a function which returns urls to static resources', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set,
+        webRequestEvents,
+        requestId,
+      });
+      const url = ctx.getStaticResourceUrl('path/to/resource.png');
+      expect(url).toEqual(
+        `http://example.com/s/${manifest.namespace}/${manifest.name}/1.0.0/path/to/resource.png?_componentSet=my-set`,
+      );
+    });
+
+    it('should handle leading and trailing slashes', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set,
+        webRequestEvents,
+        requestId,
+      });
+      const url = ctx.getStaticResourceUrl('/path/to/resource.png'); // leading with slash
+      const url2 = ctx.getStaticResourceUrl('path/to/resource.png'); // without leading slash
+
+      expect(url).toEqual(
+        `http://example.com/s/${manifest.namespace}/${manifest.name}/1.0.0/path/to/resource.png?_componentSet=my-set`,
+      );
+      expect(url2).toEqual(
+        `http://example.com/s/${manifest.namespace}/${manifest.name}/1.0.0/path/to/resource.png?_componentSet=my-set`,
+      );
+      expect(url).toEqual(url2);
+
+      const ctx2 = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com',
+        set,
+        webRequestEvents,
+        requestId,
+      }); // without trailing slash
+      const url3 = ctx2.getStaticResourceUrl('/path/to/resource.png'); // leading with slash
+      const url4 = ctx2.getStaticResourceUrl('path/to/resource.png'); // without leading slash
+
+      expect(url3).toEqual(
+        `http://example.com/s/${manifest.namespace}/${manifest.name}/1.0.0/path/to/resource.png?_componentSet=my-set`,
+      );
+      expect(url4).toEqual(
+        `http://example.com/s/${manifest.namespace}/${manifest.name}/1.0.0/path/to/resource.png?_componentSet=my-set`,
+      );
+    });
+
+    it('should drop extra query parameters', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set,
+        webRequestEvents,
+        requestId,
+      });
+      const url = ctx.getStaticResourceUrl('/path/to/resource.png?param=123');
+
+      expect(url).toEqual(
+        `http://example.com/s/${manifest.namespace}/${manifest.name}/1.0.0/path/to/resource.png?_componentSet=my-set`,
+      );
+    });
+
+    it('should error when non-string is provided', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set,
+        webRequestEvents,
+        requestId,
+      });
+
+      /* @ts-expect-error requires string */
+      expect(() => ctx.getStaticResourceUrl(123)).toThrowError('getStaticResourceUrl: first argument must be a string');
+      /* @ts-expect-error requires string */
+      expect(() => ctx.getStaticResourceUrl({})).toThrowError('getStaticResourceUrl: first argument must be a string');
+      /* @ts-expect-error requires string */
+      expect(() => ctx.getStaticResourceUrl(undefined)).toThrowError(
+        'getStaticResourceUrl: first argument must be a string',
+      );
+      /* @ts-expect-error requires string */
+      expect(() => ctx.getStaticResourceUrl()).toThrowError('getStaticResourceUrl: first argument must be a string');
+    });
+  });
+
+  describe('getFunctionUrl', () => {
+    it('should return a fully qualified url for a function url', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        webRequestEvents,
+        requestId,
+      });
+
+      expect(ctx.getFunctionUrl('my-func')).toEqual('http://example.com/r/my-comp/1.0.0/my-func?_componentSet=my-set');
+    });
+
+    it('should convert a simple input object into query string', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        webRequestEvents,
+        requestId,
+      });
+
+      expect(
+        ctx.getFunctionUrl('my-func', {
+          myNum: 123,
+          myArray: ['1', '2'],
+        }),
+      ).toEqual('http://example.com/r/my-comp/1.0.0/my-func?_componentSet=my-set&myArray[]=1&myArray[]=2&myNum=123');
+    });
+
+    it('should use the preview route when a previewKey is provided', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        withPreviewKey: 'a-preview',
+        webRequestEvents,
+        requestId,
+      });
+      expect(ctx.getFunctionUrl('another-function')).toEqual(
+        'http://example.com/r/my-comp/1.0.0/another-function?_previewKey=a-preview',
+      );
+    });
+
+    it('should convert a simple input object into query string with preview', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        withPreviewKey: 'a-preview',
+        webRequestEvents,
+        requestId,
+      });
+
+      expect(
+        ctx.getFunctionUrl('my-func', {
+          myNum: 123,
+          myArray: ['1', '2'],
+        }),
+      ).toEqual('http://example.com/r/my-comp/1.0.0/my-func?_previewKey=a-preview&myArray[]=1&myArray[]=2&myNum=123');
+    });
+
+    it('should use the static file preview route when a previewKey is provided', () => {
+      const previewKey = 'some-preview-key';
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        withPreviewKey: previewKey,
+        webRequestEvents,
+        requestId,
+      });
+      const url = ctx.getStaticResourceUrl('path/to/resource.png');
+      expect(url).toEqual(
+        `http://example.com/s/${manifest.namespace}/${manifest.name}/1.0.0/path/to/resource.png?_previewKey=some-preview-key`,
+      );
+    });
+
+    it('should error when non-string is provided', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        webRequestEvents,
+        requestId,
+      });
+
+      /* @ts-expect-error requires string */
+      expect(() => ctx.getFunctionUrl(123)).toThrowError('getFunctionUrl: first argument must be a string');
+      /* @ts-expect-error requires string */
+      expect(() => ctx.getFunctionUrl({})).toThrowError('getFunctionUrl: first argument must be a string');
+      /* @ts-expect-error requires string */
+      expect(() => ctx.getFunctionUrl(undefined)).toThrowError('getFunctionUrl: first argument must be a string');
+      /* @ts-expect-error requires string */
+      expect(() => ctx.getFunctionUrl()).toThrowError('getFunctionUrl: first argument must be a string');
+    });
+
+    it('should ensure the function name is transformed to lowercase', () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        webRequestEvents,
+        requestId,
+      });
+
+      expect(ctx.getFunctionUrl('MY-FUNC')).toEqual('http://example.com/r/my-comp/1.0.0/my-func?_componentSet=my-set');
+    });
+  });
+
+  describe('resolveUri', () => {
+    const validRequestId = randomUUID();
+    requestId = validRequestId;
+    //mock the worker-root.ts
+    const workerMock = () => {
+      const handleUriRequest = async (uri: string, requestId: string, id: string): Promise<void> => {
+        if (uri === 'some-preview-uri') {
+          const [result] = await Promise.allSettled([Promise.resolve(mockedUriObjPreview)]);
+          webRequestEvents.emit('uri-response', result, requestId, id);
+        }
+        if (requestId === validRequestId) {
+          const [result] = await Promise.allSettled([Promise.resolve(mockedUriObj)]);
+          webRequestEvents.emit('uri-response', result, requestId, id);
+        }
+      };
+      webRequestEvents.on('uri-request', handleUriRequest);
+    };
+
+    workerMock();
+
+    it('should throw error when uri is not of type string', async () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        withPreviewKey: 'a-preview',
+        webRequestEvents,
+        requestId,
+      });
+      /* @ts-expect-error requires string */
+      await expect(async () => await ctx.resolveUri(123)).rejects.toThrowError(
+        'resolveUri: first argument must be a string',
+      );
+      /* @ts-expect-error requires string */
+      await expect(async () => await ctx.resolveUri(undefined)).rejects.toThrowError(
+        'resolveUri: first argument must be a string',
+      );
+      /* @ts-expect-error requires string */
+      await expect(async () => await ctx.resolveUri({})).rejects.toThrowError(
+        'resolveUri: first argument must be a string',
+      );
+    });
+
+    it('should return the mocked uri object for preview', async () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        withPreviewKey: 'a-preview',
+        webRequestEvents,
+        requestId,
+      });
+      const result = await ctx.resolveUri('some-preview-uri');
+      expect(result).toEqual(mockedUriObjPreview);
+    });
+
+    it('should return the mocked uri object for production', async () => {
+      const ctx = createComponentContextualFunctions({
+        componentName: 'my-comp',
+        manifest,
+        rootUrl: 'http://example.com/',
+        set: set,
+        withPreviewKey: 'a-preview',
+        webRequestEvents,
+        requestId,
+      });
+      const result = await ctx.resolveUri('some-uri-x');
+      expect(result).toEqual(mockedUriObj);
+    });
+  });
+});

package/src/domains/component/component-context/createComponentContextualFunctions.ts

@@ -0,0 +1,108 @@
+import queryString from 'query-string';
+import { joinAbsoluteUrlPath } from '@squiz/dx-common-lib';
+import { RuntimeComponentSet } from '../../component-set/services/RuntimeComponentSet';
+import { ManifestModel } from '../../manifest/ManifestModel';
+import { EventEmitter } from 'stream';
+import { randomUUID } from 'crypto';
+import { UriResource } from '../services/content-item-uri-resolver/ComponentContentUriResolverForPreview';
+import { ComponentFunctionService, ManifestV1 } from '../../manifest';
+export interface ComponentContextualFunctions {
+  getStaticResourceUrl: (path: string) => string;
+  getFunctionUrl: (name: string, input?: { [key: string]: any } | undefined) => string;
+  resolveUri: (uri: string) => Promise<UriResource | undefined>;
+}
+
+export type CreateComponentContextualFunctionsInput = {
+  componentName: string;
+  manifest: ManifestModel;
+  rootUrl: string;
+  set: RuntimeComponentSet;
+  withPreviewKey?: string;
+  manifestPath?: string;
+  requestId: string;
+  webRequestEvents: EventEmitter;
+};
+
+export function createComponentContextualFunctions(
+  ctxInput: CreateComponentContextualFunctionsInput,
+): ComponentContextualFunctions {
+  const baseRenderUrl: string = joinAbsoluteUrlPath(
+    ctxInput.rootUrl,
+    'r',
+    ctxInput.componentName,
+    ctxInput.manifest.version,
+  );
+  const manifest = new ManifestV1(ctxInput.manifest, ctxInput.manifestPath || '');
+  return {
+    getStaticResourceUrl: (path: string) => {
+      if (typeof path !== 'string') {
+        throw new Error('getStaticResourceUrl: first argument must be a string');
+      }
+      const params = ctxInput.withPreviewKey
+        ? { _previewKey: ctxInput.withPreviewKey }
+        : { _componentSet: ctxInput.set.webPath };
+      const url = ComponentFunctionService.buildFileUrl(path, manifest, params, ctxInput.rootUrl);
+      return url;
+    },
+
+    getFunctionUrl: (name: string, input: { [key: string]: any } = {}) => {
+      if (typeof name !== 'string') {
+        throw new Error('getFunctionUrl: first argument must be a string');
+      }
+      name = name.toLowerCase();
+      if (ctxInput.withPreviewKey) {
+        return queryString.stringifyUrl(
+          {
+            url: joinAbsoluteUrlPath(baseRenderUrl, name),
+            query: {
+              ...input,
+              _previewKey: ctxInput.withPreviewKey,
+            },
+          },
+          { skipNull: true, encode: true, arrayFormat: 'bracket' },
+        );
+      }
+      return queryString.stringifyUrl(
+        {
+          url: joinAbsoluteUrlPath(baseRenderUrl, name),
+          query: {
+            ...input,
+            _componentSet: ctxInput.set.webPath,
+          },
+        },
+        { skipNull: true, encode: true, arrayFormat: 'bracket' },
+      );
+    },
+
+    resolveUri: async (uri: string): Promise<UriResource | undefined> => {
+      if (typeof uri !== 'string') {
+        throw new Error('resolveUri: first argument must be a string');
+      }
+
+      if (ctxInput.requestId === undefined) {
+        throw new Error('resolveUri: request id is undefined');
+      }
+
+      const id = randomUUID();
+
+      ctxInput.webRequestEvents.emit('uri-request', uri, ctxInput.requestId, id);
+
+      const resource = new Promise((resolve, reject) => {
+        const handleUriResponse = (data: PromiseSettledResult<UriResource>, requestId: string, uuid: string) => {
+          if (id == uuid) {
+            ctxInput.webRequestEvents.removeListener('uri-response', handleUriResponse);
+            if (data.status === 'fulfilled') {
+              resolve(data.value as UriResource);
+            }
+            if (data.status === 'rejected') {
+              reject(data.reason);
+            }
+          }
+        };
+        ctxInput.webRequestEvents.on('uri-response', handleUriResponse);
+      });
+
+      return (await resource) as UriResource | undefined;
+    },
+  };
+}

package/src/domains/component/errors/ComponentError.ts

@@ -0,0 +1,22 @@
+import { ErrorWithHttpStatusCode } from '@squiz/dx-common-lib';
+
+export class ComponentError extends ErrorWithHttpStatusCode {
+  name = 'ComponentError';
+
+  constructor(
+    public requestId: string,
+    public error: Error | any,
+
+    public functionName: string,
+    public componentName: string,
+    public componentVersion: string,
+    public setWebPath: string,
+    public responseType: 'json' | 'html',
+
+    statusCode: number = 500,
+  ) {
+    super(statusCode, error?.message || 'An error occurred with no additional information available');
+
+    this.stack = error?.stack;
+  }
+}

package/src/domains/component/errors/JobError.ts

@@ -0,0 +1,20 @@
+import { ErrorWithHttpStatusCode } from '@squiz/dx-common-lib';
+
+export class JobError extends ErrorWithHttpStatusCode {
+  name = 'JobError';
+
+  constructor(
+    public requestId: string,
+    public error: Error | any,
+
+    public functionName: string,
+    public jobName: string,
+    public jobVersion: string,
+
+    statusCode: number = 500,
+  ) {
+    super(statusCode, error?.message || 'An error occurred with no additional information available');
+
+    this.stack = error?.stack;
+  }
+}

package/src/domains/component/index.ts

@@ -0,0 +1,17 @@
+export * from './models/Component';
+export * from './models/ComponentVersion';
+
+export * from './repositories/ComponentRepository';
+export * from './repositories/ComponentVersionRepository';
+
+export * from './services/ComponentService';
+export * from './services/content-item-uri-resolver/ComponentContentUriResolverForPreview';
+
+export * from './web-models/ComponentForWeb';
+export * from './web-models/ComponentsForWeb';
+export * from './web-models/ComponentVersionWebModel';
+
+export * from './component-context/createComponentContextualFunctions';
+export * from './errors/ComponentError';
+export * from './errors/JobError';
+export * from './utils/getComponentFileSystemFolder';

package/src/domains/component/models/Component.spec.ts

@@ -0,0 +1,21 @@
+import { Component } from './Component';
+
+describe('Component', () => {
+  it('should not allow creation without name', () => {
+    expect(() => new Component({})).toThrowErrorMatchingInlineSnapshot('"value is not a string"');
+  });
+
+  it('should create if name is provided', () => {
+    expect(new Component({ name: 'component' })).toEqual(new Component({ name: 'component' }));
+  });
+
+  it('should throw if name is not a string', () => {
+    expect(() => new Component({ name: 123 })).toThrowErrorMatchingInlineSnapshot('"value is not a string"');
+  });
+
+  it('should throw if no data provided', () => {
+    expect(() => new Component()).toThrowErrorMatchingInlineSnapshot(
+      `"Expected 'val' to be defined, but received undefined"`,
+    );
+  });
+});

package/src/domains/component/models/Component.ts

@@ -0,0 +1,16 @@
+import { assertIsDefined, assertIsString } from '@squiz/dx-common-lib';
+
+export interface ComponentInterface {
+  name: string;
+}
+
+export class Component implements ComponentInterface {
+  public name: string;
+
+  constructor(data?: Record<string, unknown>) {
+    assertIsDefined(data);
+    assertIsString(data.name);
+
+    this.name = data.name;
+  }
+}

package/src/domains/component/models/ComponentVersion.spec.ts

@@ -0,0 +1,77 @@
+import { ComponentVersion } from './ComponentVersion';
+
+describe('ComponentVersion', () => {
+  it('should allow creation with required fields', () => {
+    const model = new ComponentVersion({
+      componentName: 'name',
+      version: '1.0.0',
+      displayName: 'display name',
+      description: 'description',
+    });
+
+    expect(model.componentName).toEqual('name');
+    expect(model.version).toEqual('1.0.0');
+  });
+
+  it('should allow creation with optional icon', () => {
+    const model = new ComponentVersion({
+      componentName: 'name',
+      version: '1.0.0',
+      displayName: 'display name',
+      description: 'description',
+
+      icon: { id: '', color: { type: '', value: '' } },
+    });
+
+    expect(model.componentName).toEqual('name');
+    expect(model.version).toEqual('1.0.0');
+  });
+
+  it('should throw if componentName not provided', () => {
+    expect(
+      () =>
+        new ComponentVersion({
+          version: '0.0.0',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"componentName must be a string"`);
+  });
+
+  it('should throw if version not provided', () => {
+    expect(
+      () =>
+        new ComponentVersion({
+          componentName: 'name',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"version must be a string"`);
+  });
+
+  it('should throw if version is not in semver format', () => {
+    expect(
+      () =>
+        new ComponentVersion({
+          componentName: 'name',
+          version: 'version',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"ComponentVersion.version must be in the form of semver 0.0.0"`);
+  });
+
+  it('should throw if version is not in semver format, must have 3 parts', () => {
+    expect(
+      () =>
+        new ComponentVersion({
+          componentName: 'name',
+          version: '1.0',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"ComponentVersion.version must be in the form of semver 0.0.0"`);
+  });
+
+  it('should throw if version is not in semver format, must not contain letters', () => {
+    expect(
+      () =>
+        new ComponentVersion({
+          componentName: 'name',
+          version: '1.0.zzz',
+        }),
+    ).toThrowErrorMatchingInlineSnapshot(`"ComponentVersion.version must be in the form of semver 0.0.0"`);
+  });
+});

package/src/domains/component/models/ComponentVersion.ts

@@ -0,0 +1,55 @@
+import { assertIsString, assertIsDefined, assertAssign } from '@squiz/dx-common-lib';
+import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
+
+type Icon = MANIFEST_MODELS.v1.DxComponentIconsJson;
+type ColorHex = MANIFEST_MODELS.v1.ColorHex;
+type ColorEnum = MANIFEST_MODELS.v1.ColorEnum;
+
+export interface ComponentVersionInterface {
+  componentName: string;
+  version: string;
+
+  displayName: string;
+  description: string;
+  icon: Icon | undefined;
+}
+
+const SEMVER_REGEX = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
+
+export class ComponentVersion implements ComponentVersionInterface {
+  public componentName: string = '';
+  public version: string = '';
+  public displayName: string = '';
+  public description: string = '';
+  public icon: Icon | undefined;
+
+  constructor(data?: Record<string, unknown>) {
+    assertIsDefined(data);
+
+    this.componentName = assertAssign(data.componentName, assertIsString, 'componentName must be a string');
+    this.version = assertAssign(data.version, assertIsString, 'version must be a string');
+
+    this.displayName = assertAssign(data.displayName || '', assertIsString, 'displayName must be a string');
+    this.description = assertAssign(data.description || '', assertIsString, 'description must be a string');
+
+    if (data.icon && isIcon(data.icon)) {
+      this.icon = data.icon;
+    }
+
+    if (SEMVER_REGEX.test(this.version) == false) {
+      throw new Error(`ComponentVersion.version must be in the form of semver 0.0.0`);
+    }
+  }
+}
+
+function isIcon(value: unknown): value is Icon {
+  if (!!value && typeof value === 'object' && 'id' in value && 'color' in value && isColor((value as any).color)) {
+    return true;
+  }
+
+  return false;
+}
+
+function isColor(value: unknown): value is ColorHex | ColorEnum {
+  return !!value && typeof value === 'object' && 'type' in value && 'value' in value;
+}