@squiz/job-runner-lib 1.66.1

package/src/domains/component/repositories/ComponentRepository.integration.spec.ts

@@ -0,0 +1,148 @@
+import { ComponentRepository } from './ComponentRepository';
+
+import { randomUUID } from 'crypto';
+import { ComponentConnectionManager } from '../../db/ComponentConnectionManager';
+import { createConnectionManager } from '../../db/createConnectionManager';
+import path from 'path';
+
+describe('ComponentRepository', () => {
+  let manager: ComponentConnectionManager;
+
+  let service: ComponentRepository;
+
+  beforeAll(async () => {
+    manager = await createConnectionManager(
+      'component-lib-test',
+      {
+        databaseConnectionString: process.env.COMPONENT_DB_CONNECTION_STRING!,
+      },
+      path.join(__dirname, '../../../../migrations'),
+    );
+    service = new ComponentRepository(manager);
+
+    await manager.applyMigrations();
+  });
+
+  afterAll(() => {
+    manager.close();
+  });
+
+  describe('CRUD', () => {
+    const componentName = randomUUID().substring(0, 5);
+    const componentName2 = randomUUID().substring(0, 6);
+
+    it('should insert', async () => {
+      const createdComponent = await service.create({
+        name: componentName,
+      });
+
+      expect(createdComponent).toEqual({ name: componentName });
+    });
+
+    it('should be able to find one', async () => {
+      const foundComponent = await service.findOne({
+        name: componentName,
+      });
+
+      expect(foundComponent).toEqual({ name: componentName });
+    });
+
+    it('should throw an error if no properties passed to findOne', async () => {
+      await expect(service.findOne({})).rejects.toThrowError(
+        new Error('Values cannot be an empty object. It must have at least one property'),
+      );
+    });
+
+    it('should be able to update properties', async () => {
+      const updated = await service.update({ name: componentName }, { name: componentName2 });
+
+      expect(updated).toEqual([
+        {
+          name: componentName2,
+        },
+      ]);
+
+      const updatedComp = await service.findOne({ name: componentName2 });
+      const oldComp = await service.findOne({ name: componentName });
+
+      expect(updatedComp).toEqual({ name: componentName2 });
+      expect(oldComp).toBeUndefined();
+    });
+
+    it('should be able to delete cerated component', async () => {
+      const result = await service.delete({
+        name: componentName2,
+      });
+
+      expect(result).toEqual(1);
+    });
+
+    it('should be able to find many rows', async () => {
+      const comp = await service.create({ name: componentName });
+
+      const result = await service.find({
+        name: componentName,
+      });
+
+      expect(result).toEqual([{ name: componentName }]);
+
+      await service.delete(comp);
+    });
+  });
+
+  describe('getComponentByName', () => {
+    const componentName = randomUUID().substring(0, 5);
+
+    beforeAll(async () => {
+      await service.create({ name: componentName });
+    });
+
+    afterAll(async () => {
+      await service.delete({ name: componentName });
+    });
+
+    it('should find a component by name', async () => {
+      expect(await service.getComponentByName(componentName)).toEqual({ name: componentName });
+    });
+
+    it('should return undefined if no component found', async () => {
+      expect(await service.getComponentByName('not-real')).toEqual(undefined);
+    });
+  });
+
+  describe('componentExists', () => {
+    const componentName = randomUUID().substring(0, 5);
+
+    beforeAll(async () => {
+      await service.create({ name: componentName });
+    });
+
+    afterAll(async () => {
+      await service.delete({ name: componentName });
+    });
+
+    it('should return true if component exists', async () => {
+      expect(await service.componentExists(componentName)).toEqual(true);
+    });
+
+    it("should return false if component doesn't exist", async () => {
+      expect(await service.componentExists('not-real')).toEqual(false);
+    });
+  });
+
+  describe('addComponent', () => {
+    const componentName = randomUUID().substring(0, 5);
+
+    afterAll(async () => {
+      await service.delete({ name: componentName });
+    });
+
+    it('should create a new component', async () => {
+      expect(await service.addComponent(componentName)).toEqual({ name: componentName });
+    });
+
+    it('should throw an error if name is empty', async () => {
+      await expect(service.addComponent('')).rejects.toThrowError(new Error('component name cannot be empty'));
+    });
+  });
+});

package/src/domains/component/repositories/ComponentRepository.ts

@@ -0,0 +1,37 @@
+import { AbstractRepository, Pool } from '@squiz/db-lib';
+import { ComponentRepositories } from '../../db/ComponentRepositories';
+import { ComponentInterface, Component } from '../models/Component';
+
+export class ComponentRepository extends AbstractRepository<ComponentInterface, Component> {
+  constructor(options: { repositories: ComponentRepositories; pool: Pool }) {
+    super(
+      options.repositories,
+      options.pool,
+      'component',
+      {
+        name: 'name',
+      },
+      Component,
+    );
+  }
+
+  async getComponentByName(componentName: string): Promise<ComponentInterface | undefined> {
+    return this.findOne({ name: componentName });
+  }
+
+  async componentExists(componentName: string): Promise<boolean> {
+    const comp = await this.getComponentByName(componentName);
+
+    return comp != null;
+  }
+
+  async addComponent(componentName: string): Promise<ComponentInterface> {
+    if (componentName === '') {
+      throw new Error(`component name cannot be empty`);
+    }
+
+    const comp = await this.create({ name: componentName });
+
+    return comp;
+  }
+}

package/src/domains/component/repositories/ComponentVersionRepository.integration.spec.ts

@@ -0,0 +1,523 @@
+import { randomUUID } from 'crypto';
+import { ComponentInterface } from '../models/Component';
+import { ComponentVersionInterface } from '../models/ComponentVersion';
+import { ComponentVersionRepository } from './ComponentVersionRepository';
+import { createConnectionManager } from '../../db/createConnectionManager';
+import path from 'path';
+import { ComponentConnectionManager } from '../../db/ComponentConnectionManager';
+import { ComponentSetComponentVersionStatus } from '../../component-set/models/ComponentSetComponentVersion';
+
+describe('ComponentVersionRepository', () => {
+  let manager: ComponentConnectionManager;
+  let service: ComponentVersionRepository;
+
+  beforeAll(async () => {
+    manager = await createConnectionManager(
+      'component-lib-test',
+      {
+        databaseConnectionString: process.env.COMPONENT_DB_CONNECTION_STRING!,
+      },
+      path.join(__dirname, '../../../../migrations'),
+    );
+    service = new ComponentVersionRepository(manager);
+
+    await manager.applyMigrations();
+  });
+
+  afterAll(async () => {
+    await manager.close();
+  });
+
+  describe('CRUD', () => {
+    const componentName = randomUUID().substring(0, 5);
+    const componentName2 = randomUUID().substring(0, 5);
+    let component: ComponentInterface;
+    let componentVersion: ComponentVersionInterface;
+
+    beforeAll(async () => {
+      component = await manager.repositories.component.addComponent(componentName);
+    });
+
+    it('should be able to create a component version', async () => {
+      componentVersion = await service.addComponentVersion(component.name, '1.0.0', component.name, '', undefined);
+
+      expect(componentVersion).toEqual({
+        componentName: componentName,
+        version: '1.0.0',
+        displayName: componentName,
+        description: '',
+      });
+    });
+
+    it('should be able to update a component version', async () => {
+      const updatedVersion = await service.update(
+        {
+          componentName: componentName,
+          version: componentVersion.version,
+        },
+        {
+          version: '1.0.1',
+        },
+      );
+
+      expect(updatedVersion).toEqual([
+        {
+          componentName: componentName,
+          version: '1.0.1',
+          displayName: componentName,
+          description: '',
+        },
+      ]);
+    });
+
+    it('should be able find one component version', async () => {
+      const foundComponent = await service.findOne({ componentName: component.name, version: '1.0.1' });
+
+      expect(foundComponent).toEqual({
+        componentName: componentName,
+        version: '1.0.1',
+        description: '',
+        displayName: componentName,
+      });
+    });
+
+    it('should not be able to find the old version', async () => {
+      const foundComponent = await service.findOne({ componentName: component.name, version: '1.0.0' });
+      expect(foundComponent).toBeUndefined();
+    });
+
+    it('should be able to find many component versions', async () => {
+      await service.addComponentVersion(component.name, '1.0.0', component.name, 'd1', undefined);
+      await service.addComponentVersion(component.name, '1.0.2', component.name, 'd2', {
+        id: 'anchor',
+        color: { type: 'enum', value: 'gray' },
+      });
+
+      const versions = (await service.find({ componentName: componentName })).sort((a, b) =>
+        a.version > b.version ? 1 : -1,
+      );
+
+      expect(versions).toEqual([
+        { componentName: component.name, version: '1.0.0', displayName: component.name, description: 'd1' },
+        { componentName: component.name, version: '1.0.1', displayName: component.name, description: '' },
+        {
+          componentName: component.name,
+          version: '1.0.2',
+          displayName: component.name,
+          description: 'd2',
+          icon: {
+            id: 'anchor',
+            color: { type: 'enum', value: 'gray' },
+          },
+        },
+      ]);
+    });
+
+    it('should cascade updates from component name', async () => {
+      await manager.repositories.component.update(
+        {
+          name: componentName,
+        },
+        { name: componentName2 },
+      );
+
+      const versionOldName = (await service.find({ componentName: componentName })).sort((a, b) =>
+        a.version > b.version ? 1 : -1,
+      );
+
+      expect(versionOldName).toEqual([]);
+
+      const versions = (await service.find({ componentName: componentName2 })).sort((a, b) =>
+        a.version > b.version ? 1 : -1,
+      );
+
+      expect(versions).toEqual([
+        { componentName: componentName2, version: '1.0.0', description: 'd1', displayName: componentName },
+        { componentName: componentName2, version: '1.0.1', description: '', displayName: componentName },
+        {
+          componentName: componentName2,
+          version: '1.0.2',
+          description: 'd2',
+          displayName: componentName,
+          icon: {
+            color: {
+              type: 'enum',
+              value: 'gray',
+            },
+            id: 'anchor',
+          },
+        },
+      ]);
+    });
+
+    it('should be able to delete a single version', async () => {
+      await manager.repositories.componentVersion.delete({
+        version: '1.0.2',
+        componentName: componentName2,
+      });
+
+      const versions = (await service.find({ componentName: componentName2 })).sort((a, b) =>
+        a.version > b.version ? 1 : -1,
+      );
+
+      expect(versions).toEqual([
+        { componentName: componentName2, version: '1.0.0', description: 'd1', displayName: componentName },
+        { componentName: componentName2, version: '1.0.1', description: '', displayName: componentName },
+      ]);
+    });
+
+    it('deleting component should cascade deletes', async () => {
+      await manager.repositories.component.delete({
+        name: componentName2,
+      });
+
+      const versions = await service.find({ componentName: componentName2 });
+
+      expect(versions).toEqual([]);
+    });
+  });
+
+  describe('getComponentByNameAndVersion', () => {
+    const componentName = randomUUID().substring(0, 5);
+
+    let component: ComponentInterface;
+    let componentVersion: ComponentVersionInterface;
+
+    beforeAll(async () => {
+      component = await manager.repositories.component.addComponent(componentName);
+      componentVersion = await service.addComponentVersion(
+        componentName,
+        '1.0.0',
+        componentName,
+        'getComponentByNameAndVersion test',
+        undefined,
+      );
+    });
+
+    afterAll(async () => {
+      await manager.repositories.component.delete({
+        name: component.name,
+      });
+    });
+
+    it('should find component by name and version', async () => {
+      expect(await service.getComponentByNameAndVersion(componentName, componentVersion.version)).toEqual({
+        componentName: component.name,
+        version: '1.0.0',
+        description: 'getComponentByNameAndVersion test',
+        displayName: component.name,
+      });
+    });
+
+    it('should return undefined if no component version is found', async () => {
+      expect(await service.getComponentByNameAndVersion(componentName, 'no real version')).toBeUndefined();
+      expect(await service.getComponentByNameAndVersion('not-real-name', '1.0.0')).toBeUndefined();
+    });
+  });
+
+  describe('addComponentVersion', () => {
+    const componentName = randomUUID().substring(0, 5);
+
+    let component: ComponentInterface;
+
+    beforeAll(async () => {
+      component = await manager.repositories.component.addComponent(componentName);
+    });
+
+    afterAll(async () => {
+      await manager.repositories.component.delete({
+        name: component.name,
+      });
+    });
+
+    it('should add a component version', async () => {
+      const version = await service.addComponentVersion(component.name, '1.0.0', component.name, '', undefined);
+
+      expect(version).toEqual({
+        componentName: component.name,
+        version: '1.0.0',
+        description: '',
+        displayName: component.name,
+      });
+    });
+
+    it("should throw an error if componentName doesn't exist", async () => {
+      await expect(service.addComponentVersion('invalid-name', '1.0.0', '', '', undefined)).rejects.toThrowError(
+        new Error(
+          'insert or update on table "component_version" violates foreign key constraint "component_version_component_name_fkey"',
+        ),
+      );
+    });
+
+    it('should throw an error if component version is not semver', async () => {
+      await expect(service.addComponentVersion('invalid-name', '10.0', '', '', undefined)).rejects.toThrowError(
+        new Error(
+          'ComponentVersion does not follow the semver convention. Component version must be in the form of major.minor.patch',
+        ),
+      );
+    });
+  });
+
+  describe('componentExists', () => {
+    const componentName = randomUUID().substring(0, 5);
+    let component: ComponentInterface;
+
+    beforeAll(async () => {
+      component = await manager.repositories.component.addComponent(componentName);
+      await service.addComponentVersion(componentName, '1.0.0', '', '', undefined);
+    });
+
+    afterAll(async () => {
+      await manager.repositories.component.delete({
+        name: component.name,
+      });
+    });
+
+    it('should return true if component exists', async () => {
+      expect(await service.componentVersionExists(componentName, '1.0.0')).toEqual(true);
+    });
+
+    it('should return false if component exists', async () => {
+      expect(await service.componentVersionExists(componentName, '2.0.0')).toEqual(false);
+    });
+  });
+
+  describe('getPaginatedMaxComponentVersion', () => {
+    const component1Name = 'test-cmp1' + randomUUID().substring(0, 5);
+    const component2Name = 'test-cmp2' + randomUUID().substring(0, 5);
+    const component3Name = 'test-cmp3' + randomUUID().substring(0, 5);
+
+    let component1: ComponentInterface;
+    let component2: ComponentInterface;
+    let component3: ComponentInterface;
+
+    beforeAll(async () => {
+      // Component 1 tests
+      component1 = await manager.repositories.component.addComponent(component1Name);
+      await service.addComponentVersion(component1Name, '1.0.0', component1Name, 'paginatedComponents test', undefined);
+      await service.addComponentVersion(component1Name, '5.0.0', component1Name, 'paginatedComponents test', undefined);
+      await service.addComponentVersion(component1Name, '1.5.0', component1Name, 'paginatedComponents test', undefined);
+
+      component2 = await manager.repositories.component.addComponent(component2Name);
+      await service.addComponentVersion(component2Name, '1.0.1', component2Name, 'paginatedComponents test', undefined);
+      await service.addComponentVersion(
+        component2Name,
+        '100.1.0',
+        component2Name,
+        'paginatedComponents test',
+        undefined,
+      );
+
+      component3 = await manager.repositories.component.addComponent(component3Name);
+      await service.addComponentVersion(component3Name, '0.7.7', component3Name, 'paginatedComponents test', undefined);
+    });
+
+    afterAll(async () => {
+      await manager.repositories.component.delete({ name: component1.name });
+      await manager.repositories.component.delete({ name: component2.name });
+      await manager.repositories.component.delete({ name: component3.name });
+    });
+
+    it('should list the components on a page and display highest version', async () => {
+      let page = 1;
+      let validComponents = 0;
+
+      for (;;) {
+        const pageResult = await service.getPaginatedMaxComponentVersion(page, [], 'asc');
+
+        if (!pageResult.items.length) {
+          break;
+        }
+
+        pageResult.items.forEach((component: ComponentVersionInterface) => {
+          // Found component 1
+          if (component.componentName === component1.name) {
+            expect(component.version).toEqual('5.0.0');
+            validComponents++;
+            // Found component 2
+          } else if (component.componentName === component2.name) {
+            expect(component.version).toEqual('100.1.0');
+            validComponents++;
+            // Found component 3
+          } else if (component.componentName === component3.name) {
+            expect(component.version).toEqual('0.7.7');
+            validComponents++;
+          }
+        });
+
+        page++;
+      }
+
+      expect(validComponents).toEqual(3);
+    });
+
+    it.each(['displayName', 'componentName', 'version', 'description'])(
+      'should sort by any property field in a component',
+      async (field: string) => {
+        await expect(
+          service.getPaginatedMaxComponentVersion(1, [field as keyof ComponentVersionInterface], 'asc'),
+        ).resolves.not.toThrow();
+      },
+    );
+
+    it('should return number of result based on the specified page size', async () => {
+      const result = await service.getPaginatedMaxComponentVersion(
+        1,
+        ['componentName' as keyof ComponentVersionInterface],
+        'asc',
+        1,
+      );
+      expect(result.items).toHaveLength(1);
+
+      const result2 = await service.getPaginatedMaxComponentVersion(
+        1,
+        ['componentName' as keyof ComponentVersionInterface],
+        'asc',
+        2,
+      );
+      expect(result2.items).toHaveLength(2);
+    });
+
+    it('should return result based on the specified component name search filter - 0 match', async () => {
+      const result = await service.getPaginatedMaxComponentVersion(
+        1,
+        ['componentName' as keyof ComponentVersionInterface],
+        'asc',
+        null,
+        {
+          componentName: 'this-will-not-match',
+        },
+      );
+      expect(result.items).toHaveLength(0);
+    });
+
+    it('should return result based on the specified component name search filter - 1 match', async () => {
+      const result = await service.getPaginatedMaxComponentVersion(
+        1,
+        ['componentName' as keyof ComponentVersionInterface],
+        'asc',
+        null,
+        {
+          componentName: 'test-cmp1',
+        },
+      );
+      expect(result.items).toHaveLength(1);
+    });
+
+    it('should return result based on the specified component name search filter - more than 1 match', async () => {
+      const result = await service.getPaginatedMaxComponentVersion(
+        1,
+        ['componentName' as keyof ComponentVersionInterface],
+        'asc',
+        null,
+        {
+          componentName: 'test-cmp',
+        },
+      );
+      expect(result.items).toHaveLength(3);
+    });
+  });
+
+  describe('getComponentSetComponentVersionByWebPath', () => {
+    const componentSetWebPath = randomUUID().substring(0, 5);
+    const componentName = 'get-component-set-component-version-by-webpath-test-comp';
+
+    let component: ComponentInterface;
+
+    beforeAll(async () => {
+      await manager.repositories.componentSet.create({
+        webPath: componentSetWebPath,
+        displayName: 'some displayName',
+        description: 'some description',
+        environmentVariables: {},
+        headers: {},
+      });
+
+      component = await manager.repositories.component.addComponent(componentName);
+      await service.addComponentVersion(componentName, '1.0.0', componentName, 'v1', undefined);
+      await service.addComponentVersion(componentName, '2.0.0', componentName, 'v2', undefined);
+
+      await manager.repositories.componentSetComponentVersion.create({
+        componentSetWebPath: componentSetWebPath,
+        componentName: componentName,
+        componentVersion: '1.0.0',
+        environmentVariables: {},
+        status: ComponentSetComponentVersionStatus.active,
+      });
+      await manager.repositories.componentSetComponentVersion.create({
+        componentSetWebPath: componentSetWebPath,
+        componentName: componentName,
+        componentVersion: '2.0.0',
+        environmentVariables: {},
+        status: ComponentSetComponentVersionStatus.excluded,
+      });
+    });
+
+    afterAll(async () => {
+      await manager.repositories.component.delete({ name: component.name });
+      await manager.repositories.componentSet.delete({ webPath: componentSetWebPath });
+    });
+
+    it('should all component versions in the set by default', async () => {
+      const result = await service.getComponentSetComponentVersionByWebPath(componentSetWebPath);
+      expect(result.sort()).toMatchInlineSnapshot(`
+        [
+          {
+            "componentName": "get-component-set-component-version-by-webpath-test-comp",
+            "description": "v1",
+            "displayName": "get-component-set-component-version-by-webpath-test-comp",
+            "environmentVariables": {},
+            "icon": undefined,
+            "version": "1.0.0",
+          },
+          {
+            "componentName": "get-component-set-component-version-by-webpath-test-comp",
+            "description": "v2",
+            "displayName": "get-component-set-component-version-by-webpath-test-comp",
+            "environmentVariables": {},
+            "icon": undefined,
+            "version": "2.0.0",
+          },
+        ]
+      `);
+    });
+
+    it('should "active" component versions in the set when selected so', async () => {
+      const result = await service.getComponentSetComponentVersionByWebPath(
+        componentSetWebPath,
+        ComponentSetComponentVersionStatus.active,
+      );
+      expect(result.sort()).toMatchInlineSnapshot(`
+        [
+          {
+            "componentName": "get-component-set-component-version-by-webpath-test-comp",
+            "description": "v1",
+            "displayName": "get-component-set-component-version-by-webpath-test-comp",
+            "environmentVariables": {},
+            "icon": undefined,
+            "version": "1.0.0",
+          },
+        ]
+      `);
+    });
+
+    it('should "excluded" component versions in the set when selected so', async () => {
+      const result = await service.getComponentSetComponentVersionByWebPath(
+        componentSetWebPath,
+        ComponentSetComponentVersionStatus.excluded,
+      );
+      expect(result.sort()).toMatchInlineSnapshot(`
+        [
+          {
+            "componentName": "get-component-set-component-version-by-webpath-test-comp",
+            "description": "v2",
+            "displayName": "get-component-set-component-version-by-webpath-test-comp",
+            "environmentVariables": {},
+            "icon": undefined,
+            "version": "2.0.0",
+          },
+        ]
+      `);
+    });
+  });
+});