@squiz/job-runner-lib 1.66.1

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

@@ -0,0 +1,436 @@
+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',
+      );
+    });
+  });
+});

package/src/domains/manifest/ManifestV1.ts

@@ -0,0 +1,146 @@
+import { ManifestV1Model } from './ManifestModel';
+import { AbstractManifest, SchemaVersions } from './AbstractManifest';
+import { BadRequestError, ResourceNotFoundError } from '@squiz/dx-common-lib';
+import { MANIFEST_MODELS } from '@squiz/dx-json-schema-lib';
+import path from 'path';
+import { pathExists } from 'fs-extra';
+import fsp from 'fs/promises';
+
+export class ManifestV1 extends AbstractManifest {
+  constructor(protected manifest: ManifestV1Model, protected manifestPath: string) {
+    super(manifest);
+  }
+
+  public getSchemaVersion(): SchemaVersions {
+    return 'v1';
+  }
+
+  public getModel(): ManifestV1Model {
+    return this.manifest;
+  }
+
+  public getComponentFunctionByName(fnName: string = ''): MANIFEST_MODELS.v1.ComponentFunction {
+    const manifestModel = this.getModel();
+    if (!fnName) {
+      if (manifestModel.mainFunction) {
+        fnName = manifestModel.mainFunction;
+      } else {
+        throw new ResourceNotFoundError('Component main function is not defined');
+      }
+    }
+    const functionDefinition = manifestModel.functions.find((a) => a.name === fnName);
+
+    if (!functionDefinition) {
+      throw new ResourceNotFoundError(
+        `"${fnName}" function for ${this.getName()} ${this.getVersion()} could not be found`,
+      );
+    }
+    return functionDefinition;
+  }
+
+  public async getComponentFunctionEntryFilePath(
+    componentFunction: MANIFEST_MODELS.v1.ComponentFunction,
+  ): Promise<string> {
+    const componentDirectory = this.getComponentDirectory();
+    const inputPath = path.resolve(path.join(componentDirectory, componentFunction.entry));
+    return inputPath;
+  }
+
+  public getComponentDirectory() {
+    return path.resolve(path.join(this.manifestPath, '..'));
+  }
+
+  public async getManifestPath() {
+    return this.manifestPath;
+  }
+
+  public getFunctionPreviewConfiguration(
+    previewKey: string,
+    functionDefinition: MANIFEST_MODELS.v1.ComponentFunction,
+  ): MANIFEST_MODELS.v1.FunctionPreviewConfiguration | undefined {
+    const previewDefinition = this.manifest.previews?.[previewKey];
+
+    if (previewDefinition === undefined) {
+      let message;
+
+      if (this.manifest.previews) {
+        const validPreviewKeys = Object.keys(this.manifest.previews).join(', ');
+        message = `Component has not defined preview with key "${previewKey}", the defined preview keys for this component are "${validPreviewKeys}"`;
+      } else {
+        message = `Component has no previews defined`;
+      }
+
+      throw new ResourceNotFoundError(message);
+    }
+
+    const functionPreview = previewDefinition.functionData[functionDefinition.name];
+
+    return functionPreview;
+  }
+
+  public async getFunctionPreviewData(previewFunction: MANIFEST_MODELS.v1.FunctionPreviewConfiguration) {
+    switch (previewFunction?.inputData?.type) {
+      case 'file': {
+        const dataFilePath = path.resolve(this.getComponentDirectory(), previewFunction.inputData.path);
+
+        if (path.dirname(dataFilePath).startsWith(this.getComponentDirectory()) === false) {
+          throw new BadRequestError(
+            `Preview inputData file "${previewFunction.inputData.path}" is outside the component directory`,
+          );
+        }
+
+        if ((await pathExists(dataFilePath)) === false) {
+          throw new BadRequestError(`Preview inputData file "${previewFunction.inputData.path}" does not exist`);
+        }
+
+        return this.loadDataFromFile(dataFilePath);
+      }
+      case 'inline':
+        return previewFunction.inputData.value;
+      default:
+        throw new Error('Unknown Preview Configuration Type');
+    }
+  }
+
+  public async getMockedUriObject(uri: string) {
+    const data = this.manifest.mockedUris !== undefined ? this.manifest.mockedUris[uri] : undefined;
+
+    if (data === undefined) {
+      throw new BadRequestError(`Mocked URI object "${uri}" not defined in the manifest`);
+    }
+
+    switch (data.type) {
+      case 'file': {
+        const dataFilePath = path.resolve(this.getComponentDirectory(), data.path);
+
+        if (path.dirname(dataFilePath).startsWith(this.getComponentDirectory()) === false) {
+          throw new BadRequestError(`Mocked URI object file "${data.path}" is outside the component directory`);
+        }
+
+        if ((await pathExists(dataFilePath)) === false) {
+          throw new BadRequestError(`Mocked URI object file "${data.path}" does not exist`);
+        }
+
+        return this.loadDataFromFile(dataFilePath);
+      }
+      case 'inline':
+        return data.value;
+      default:
+        throw new Error('Unknown Mocked URL object type');
+    }
+  }
+
+  protected async loadDataFromFile(filePath: string) {
+    switch (path.extname(filePath)) {
+      case '.json': {
+        const contents = await fsp.readFile(filePath, { encoding: 'utf-8' });
+        return JSON.parse(contents);
+      }
+      case '.js':
+        // TODO: DEVX-679 handle cases where export is a function
+        return require(filePath);
+      default:
+        throw new Error('Unknown filetype to load data');
+    }
+  }
+}

package/src/domains/manifest/errors/ManifestLocationError.ts

@@ -0,0 +1,9 @@
+import { ManifestModel } from '../ManifestModel';
+
+export class ManifestLocationError extends Error {
+  constructor(message: string, public manifest: ManifestModel, error?: Error) {
+    super(message);
+    this.stack = error?.stack;
+    this.name = 'ManifestLocationError';
+  }
+}

package/src/domains/manifest/errors/ManifestValidationError.ts

@@ -0,0 +1,7 @@
+export class ManifestValidationError extends Error {
+  constructor(message: string, error?: Error) {
+    super(message);
+    this.stack = error?.stack;
+    this.name = 'ManifestValidationError';
+  }
+}

package/src/domains/manifest/index.ts

@@ -0,0 +1,18 @@
+export * from './services/AbstractManifestService';
+export * from './services/ManifestServiceForDev';
+export * from './services/ManifestServiceForProduction';
+export * from './services/ComponentFunctionService';
+export * from './services/JobFunctionService';
+
+export * from './utils/assertFuncEntryFilesAreValid';
+export * from './utils/assertStaticFilesAreValid';
+export * from './utils/getAndAssertManifestVersion';
+export * from './utils/getAndAssertJobManifestVersion';
+export * from './utils/isValidManifestVersion';
+
+export * from './AbstractManifest';
+export * from './ManifestModel';
+export * from './ManifestV1';
+export * from '../job/manifest/JobManifestV1';
+export * from './errors/ManifestLocationError';
+export * from './errors/ManifestValidationError';