@squiz/job-runner-lib 1.66.2 → 2.1.0

package/src/domains/component-set/repositories/ComponentSetComponentVersionRepository.ts

@@ -1,37 +0,0 @@
-import {
-  ComponentSetComponentVersionInterface,
-  ComponentSetComponentVersion,
-} from '../models/ComponentSetComponentVersion';
-import { ComponentRepositories } from '../../db/ComponentRepositories';
-import { AbstractRepository, Pool } from '@squiz/db-lib';
-
-export class ComponentSetComponentVersionRepository extends AbstractRepository<
-  ComponentSetComponentVersionInterface,
-  ComponentSetComponentVersion
-> {
-  constructor(options: { repositories: ComponentRepositories; pool: Pool }) {
-    super(
-      options.repositories,
-      options.pool,
-      'component_set_component_version',
-      {
-        componentSetWebPath: 'component_set_web_path',
-        componentName: 'component_name',
-        componentVersion: 'component_version',
-        environmentVariables: 'env_vars',
-        status: 'status',
-      },
-      ComponentSetComponentVersion,
-    );
-  }
-
-  async componentSetComponentVersionExists(
-    componentSetWebPath: string,
-    componentName: string,
-    componentVersion: string,
-  ): Promise<boolean> {
-    const row = await this.findOne({ componentSetWebPath, componentName, componentVersion });
-
-    return row != null;
-  }
-}

package/src/domains/component-set/repositories/ComponentSetRepository.integration.spec.ts

@@ -1,199 +0,0 @@
-import { ComponentSetRepository } from './ComponentSetRepository';
-import { randomUUID } from 'crypto';
-import { createConnectionManager } from '../../db/createConnectionManager';
-import { ComponentConnectionManager } from '../../db/ComponentConnectionManager';
-import path from 'path';
-import { ComponentSet } from '../models/ComponentSet';
-
-describe('ComponentSetRepository', () => {
-  let manager: ComponentConnectionManager;
-  let repository: ComponentSetRepository;
-
-  beforeAll(async () => {
-    manager = await createConnectionManager(
-      'component-lib-test',
-      {
-        databaseConnectionString: process.env.COMPONENT_DB_CONNECTION_STRING!,
-      },
-      path.join(__dirname, '../../../../migrations'),
-    );
-    repository = new ComponentSetRepository(manager);
-
-    await manager.applyMigrations();
-  });
-
-  afterAll(async () => {
-    await manager.close();
-  });
-
-  describe('CRUD', () => {
-    const webPath = randomUUID().substring(0, 5);
-
-    afterAll(async () => {
-      await repository.delete({ webPath: webPath });
-    });
-
-    it('should insert', async () => {
-      const createdComponentSet = await repository.create({
-        webPath: webPath,
-        displayName: 'some name',
-        description: 'some description',
-        environmentVariables: { var: 'val', var2: 'val2' },
-        headers: { 'header-name': 'header-val' },
-      });
-
-      expect(createdComponentSet).toEqual({
-        webPath: webPath,
-        displayName: 'some name',
-        description: 'some description',
-        environmentVariables: { var: 'val', var2: 'val2' },
-        headers: { 'header-name': 'header-val' },
-      });
-    });
-
-    it('should be able to find one', async () => {
-      const result = await repository.findOne({
-        webPath: webPath,
-      });
-
-      expect(result).toEqual({
-        webPath: webPath,
-        displayName: 'some name',
-        description: 'some description',
-        environmentVariables: { var: 'val', var2: 'val2' },
-        headers: { 'header-name': 'header-val' },
-      });
-    });
-
-    it('should throw an error if no properties passed to findOne', async () => {
-      await expect(repository.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 result = await repository.update({ webPath: webPath }, { description: 'some description - updated' });
-
-      expect(result).toEqual([
-        {
-          webPath: webPath,
-          displayName: 'some name',
-          description: 'some description - updated',
-          environmentVariables: { var: 'val', var2: 'val2' },
-          headers: { 'header-name': 'header-val' },
-        },
-      ]);
-
-      const updated = await repository.findOne({ webPath: webPath });
-      expect(updated).toEqual({
-        webPath: webPath,
-        displayName: 'some name',
-        description: 'some description - updated',
-        environmentVariables: { var: 'val', var2: 'val2' },
-        headers: { 'header-name': 'header-val' },
-      });
-    });
-
-    it('should be able to delete cerated component', async () => {
-      const webPath2 = webPath + '-2';
-
-      await repository.create(
-        new ComponentSet({
-          webPath: webPath2,
-          displayName: 'some name',
-        }),
-      );
-
-      const result = await repository.delete({
-        webPath: webPath2,
-      });
-      expect(result).toEqual(1);
-    });
-
-    it('should be able to find many rows', async () => {
-      const webPath2 = webPath + '-2';
-      const webPath3 = webPath + '-3';
-
-      const unique = randomUUID().substring(0, 5);
-
-      await repository.create(
-        new ComponentSet({
-          webPath: webPath2,
-          displayName: 'foo' + unique,
-        }),
-      );
-      await repository.create(
-        new ComponentSet({
-          webPath: webPath3,
-          displayName: 'foo' + unique,
-        }),
-      );
-      const result = await repository.find({
-        displayName: 'foo' + unique,
-      });
-
-      expect(result).toHaveLength(2);
-      await repository.delete({
-        displayName: 'foo' + unique,
-      });
-    });
-  });
-
-  describe('getComponentSetByWebPath', () => {
-    const webPath = randomUUID().substring(0, 5);
-
-    beforeAll(async () => {
-      await repository.create({
-        webPath: webPath,
-        displayName: 'some name',
-        description: 'some description',
-        environmentVariables: { var: 'val', var2: 'val2' },
-        headers: { 'header-name': 'header-val' },
-      });
-    });
-
-    afterAll(async () => {
-      await repository.delete({ webPath });
-    });
-
-    it('should find a component by name', async () => {
-      expect(await repository.getComponentSetByWebPath(webPath)).toEqual({
-        webPath: webPath,
-        displayName: 'some name',
-        description: 'some description',
-        environmentVariables: { var: 'val', var2: 'val2' },
-        headers: { 'header-name': 'header-val' },
-      });
-    });
-
-    it('should return undefined if no component found', async () => {
-      expect(await repository.getComponentSetByWebPath('not-real')).toEqual(undefined);
-    });
-  });
-
-  describe('componentExists', () => {
-    const webPath = randomUUID().substring(0, 5);
-
-    beforeAll(async () => {
-      await repository.create({
-        webPath: webPath,
-        displayName: 'some name',
-        description: 'some description',
-        environmentVariables: { var: 'val', var2: 'val2' },
-        headers: { 'header-name': 'header-val' },
-      });
-    });
-
-    afterAll(async () => {
-      await repository.delete({ webPath });
-    });
-
-    it('should return true if component exists', async () => {
-      expect(await repository.componentSetExists(webPath)).toEqual(true);
-    });
-
-    it("should return false if component doesn't exist", async () => {
-      expect(await repository.componentSetExists('not-real')).toEqual(false);
-    });
-  });
-});

package/src/domains/component-set/repositories/ComponentSetRepository.ts

@@ -1,68 +0,0 @@
-import { ComponentSetInterface, ComponentSet } from '../models/ComponentSet';
-import { AbstractRepository, Pool } from '@squiz/db-lib';
-import { ComponentRepositories } from '../../db/ComponentRepositories';
-import { ComponentSetComponentVersionStatus } from '../../component-set';
-
-export class ComponentSetRepository extends AbstractRepository<ComponentSetInterface, ComponentSet> {
-  constructor(options: { repositories: ComponentRepositories; pool: Pool }) {
-    super(
-      options.repositories,
-      options.pool,
-      'component_set',
-      {
-        webPath: 'web_path',
-        displayName: 'display_name',
-        description: 'description',
-        environmentVariables: 'env_vars',
-        headers: 'headers',
-      },
-      ComponentSet,
-    );
-  }
-
-  async getComponentSetByWebPath(webPath: string): Promise<ComponentSetInterface | undefined> {
-    return this.findOne({ webPath: webPath.toLowerCase() });
-  }
-
-  async componentSetExists(webPath: string): Promise<boolean> {
-    const comp = await this.getComponentSetByWebPath(webPath);
-
-    return comp != null;
-  }
-
-  async findAllSetsComponentIsIn(componentName: string): Promise<ComponentSetInterface[]> {
-    const result = await this.executeQuery(
-      `
-      SELECT *
-      FROM component_set
-      WHERE component_set.web_path IN (
-        SELECT component_set_web_path 
-        FROM component_set_component_version 
-        WHERE component_name=$1 AND status=$2
-      )
-    `,
-      [componentName, ComponentSetComponentVersionStatus.active],
-    );
-
-    return result;
-  }
-
-  async findAllSetsComponentVersionIsIn(
-    namespace: string,
-    componentName: string,
-    version: string,
-  ): Promise<ComponentSetInterface[]> {
-    const result = await this.executeQuery(
-      `select *
-      from component_set 
-      where component_set.web_path in (
-        select component_set_web_path 
-        from component_set_component_version 
-        where component_name=$1 and component_version=$2 and status=$3
-      )`,
-      [`${namespace}/${componentName}`, version, ComponentSetComponentVersionStatus.active],
-    );
-
-    return result;
-  }
-}

package/src/domains/component-set/repositories/ComponentSetRuleRepository.integration.spec.ts

@@ -1,107 +0,0 @@
-import { randomUUID } from 'crypto';
-import { createConnectionManager } from '../../db/createConnectionManager';
-import { ComponentConnectionManager } from '../../db/ComponentConnectionManager';
-import path from 'path';
-import { ComponentSetRuleRepository } from './ComponentSetRuleRepository';
-
-describe('ComponentSetRuleRepository', () => {
-  let manager: ComponentConnectionManager;
-  let repository: ComponentSetRuleRepository;
-
-  beforeAll(async () => {
-    manager = await createConnectionManager(
-      'component-lib-test',
-      {
-        databaseConnectionString: process.env.COMPONENT_DB_CONNECTION_STRING!,
-      },
-      path.join(__dirname, '../../../../migrations'),
-    );
-    repository = new ComponentSetRuleRepository(manager);
-
-    await manager.applyMigrations();
-  });
-
-  afterAll(async () => {
-    await manager.close();
-  });
-
-  describe('CRUD', () => {
-    const validAttributes = {
-      componentName: 'some-component-name',
-      componentSet: 'some-component-set',
-      versionPattern: '^1.0.0',
-    };
-
-    beforeAll(async () => {
-      await manager.repositories.componentSet.delete({ webPath: validAttributes.componentSet });
-      await manager.repositories.component.delete({ name: validAttributes.componentName });
-      await manager.repositories.componentSet.create({
-        webPath: validAttributes.componentSet,
-        displayName: 'some displayName',
-        description: 'some description',
-        environmentVariables: {},
-        headers: {},
-      });
-
-      await manager.repositories.component.create({
-        name: validAttributes.componentName,
-      });
-    });
-
-    afterAll(async () => {
-      await manager.repositories.componentSet.delete({ webPath: validAttributes.componentSet });
-      await manager.repositories.component.delete({ name: validAttributes.componentName });
-    });
-
-    afterEach(async () => {
-      await repository.delete({ componentName: validAttributes.componentName });
-      await repository.delete({ componentSet: validAttributes.componentSet });
-    });
-
-    it('should insert with valid attributes and references', async () => {
-      await expect(repository.create(validAttributes)).resolves.toEqual(validAttributes);
-    });
-
-    it('should not insert a duplicate [componentSet, componentName] rule', async () => {
-      await repository.create(validAttributes);
-      await expect(repository.create(validAttributes)).rejects.toThrowError();
-    });
-
-    it('should not insert with missing references', async () => {
-      await expect(
-        repository.create({ ...validAttributes, componentSet: 'not-a-component-set' }),
-      ).rejects.toThrowError();
-    });
-
-    it('should find the rules for a component', async () => {
-      await repository.create(validAttributes);
-      await expect(repository.getComponentSetRulesByComponent(validAttributes.componentName)).resolves.toEqual([
-        validAttributes,
-      ]);
-    });
-
-    it('should find the rules for a component set', async () => {
-      await repository.create(validAttributes);
-      await expect(repository.getComponentSetRulesForSet(validAttributes.componentSet)).resolves.toEqual({
-        [validAttributes.componentName]: validAttributes.versionPattern,
-      });
-    });
-
-    it('should find the component sets with matching component versions', async () => {
-      const otherComponentSet = randomUUID();
-      await manager.repositories.componentSet.create({
-        webPath: otherComponentSet,
-        displayName: 'another-component-set',
-        description: '',
-        environmentVariables: {},
-        headers: {},
-      });
-      await repository.create({ ...validAttributes, versionPattern: '^1.0.0' });
-      await repository.create({ ...validAttributes, componentSet: otherComponentSet, versionPattern: '5.0.0' });
-
-      await expect(
-        repository.getComponentSetsMatchingComponentVersion(validAttributes.componentName, '1.5.0'),
-      ).resolves.toMatchObject([{ componentSet: validAttributes.componentSet }]);
-    });
-  });
-});

package/src/domains/component-set/repositories/ComponentSetRuleRepository.ts

@@ -1,40 +0,0 @@
-import { AbstractRepository, Pool, TransactionClient } from '@squiz/db-lib';
-import { ComponentRepositories } from '../../db';
-import { ComponentSetRule, ComponentSetRuleInterface } from '../models/ComponentSetRule';
-import * as semver from 'semver';
-
-export class ComponentSetRuleRepository extends AbstractRepository<ComponentSetRuleInterface, ComponentSetRule> {
-  constructor(options: { repositories: ComponentRepositories; pool: Pool }) {
-    super(
-      options.repositories,
-      options.pool,
-      'component_set_rule',
-      {
-        componentName: 'component_name',
-        componentSet: 'component_set_web_path',
-        versionPattern: 'version_pattern',
-      },
-      ComponentSetRule,
-    );
-  }
-
-  async getComponentSetRulesByComponent(componentName: string) {
-    return this.find({ componentName });
-  }
-
-  async getComponentSetRulesForSet(componentSet: string): Promise<Record<string, string>> {
-    const rules = await this.find({ componentSet });
-    return Object.fromEntries(rules.map(({ componentName, versionPattern }) => [componentName, versionPattern]));
-  }
-
-  async getComponentSetsMatchingComponentVersion(componentName: string, version: string) {
-    // TODO: think about pagination
-    const sets = await this.getComponentSetRulesByComponent(componentName);
-
-    return sets.filter(({ versionPattern }) => semver.satisfies(version, versionPattern));
-  }
-
-  async removeExistingRulesForComponentSet(componentSet: string, client?: TransactionClient) {
-    return this.delete({ componentSet }, client);
-  }
-}

package/src/domains/component-set/services/ComponentSetRuleService.integration.spec.ts

@@ -1,137 +0,0 @@
-import { randomUUID } from 'crypto';
-import { getLogger, Logger } from '@squiz/dx-logger-lib';
-import { ComponentConnectionManager, createConnectionManager } from '../../db';
-import { ComponentSetRuleService } from './ComponentSetRuleService';
-import { ComponentSetService } from './ComponentSetService';
-import { ComponentSetServiceForProduction } from './ComponentSetServiceForProduction';
-import { ManifestServiceForProduction } from '../../manifest';
-import { ComponentLogger } from '@squiz/component-logger-lib';
-
-const logger: Logger = getLogger({
-  name: 'component-lib',
-});
-
-describe('ComponentSetRuleService', () => {
-  let db: ComponentConnectionManager;
-  let componentSetService: ComponentSetService;
-  const componentLoggingService = { info: () => ({}), flush: () => ({}) } as unknown as ComponentLogger;
-  const componentName = randomUUID();
-  const testComponentSets: string[] = [];
-  beforeAll(async () => {
-    db = await createConnectionManager(
-      'management-api-test',
-      {
-        databaseConnectionString: process.env.COMPONENT_DB_CONNECTION_STRING!,
-      },
-      '',
-    );
-    await db.applyMigrations();
-
-    const manifestService = new ManifestServiceForProduction(process.env.DATA_MOUNT_POINT!, logger);
-
-    componentSetService = new ComponentSetServiceForProduction(db, logger, manifestService, componentLoggingService);
-
-    // create a dummy component for testing
-    db.repositories.component.create({ name: componentName });
-  });
-
-  afterAll(async () => {
-    for (const componentSet of testComponentSets) {
-      await db.repositories.componentSet.delete({ webPath: componentSet });
-    }
-    db.repositories.component.delete({ name: componentName });
-
-    await db.close();
-  });
-
-  describe('addComponentVersionToRequiredSets', () => {
-    it('adds a matching component to a set with its rule', async () => {
-      const matchingComponentVersion = '1.0.0';
-
-      const set1 = await componentSetService.addComponentSet({
-        webPath: randomUUID(),
-        displayName: 'display',
-        description: '',
-        componentVersionRules: {
-          [componentName]: {
-            renderableVersionPattern: '^1.0.0',
-            editableVersions: [],
-            excludedVersions: [],
-          },
-        },
-      });
-      testComponentSets.push(set1.webPath);
-
-      const set2 = await componentSetService.addComponentSet({
-        webPath: randomUUID(),
-        displayName: 'display',
-        description: '',
-        componentVersionRules: {
-          [componentName]: {
-            renderableVersionPattern: '^2.0.0',
-            editableVersions: [],
-            excludedVersions: [],
-          },
-        },
-      });
-      testComponentSets.push(set2.webPath);
-
-      // this matches the rule but excludes the test component version
-      const set3 = await componentSetService.addComponentSet({
-        webPath: randomUUID(),
-        displayName: 'display',
-        description: '',
-        componentVersionRules: {
-          [componentName]: {
-            renderableVersionPattern: '^1.0.0',
-            editableVersions: [],
-            excludedVersions: [matchingComponentVersion],
-          },
-        },
-      });
-      testComponentSets.push(set3.webPath);
-
-      // create a dummy component version
-      await db.repositories.componentVersion.create({
-        componentName,
-        version: matchingComponentVersion,
-        displayName: 'some-display-name',
-        description: 'some-desc-name',
-        icon: undefined,
-      });
-
-      const ruleService = new ComponentSetRuleService(db, componentSetService);
-
-      const promiseResults = await ruleService.addComponentVersionToRequiredSets(
-        componentName,
-        matchingComponentVersion,
-      );
-      promiseResults.forEach((result) => {
-        if (result.status !== 'fulfilled') {
-          throw new Error(`Unexpected promise failure - ${JSON.stringify(result, undefined, 2)}`);
-        }
-      });
-      expect(promiseResults).toHaveLength(1);
-
-      const set1ComponentVersions = (await componentSetService.getComponentSetWebModel(set1.webPath)).components[
-        componentName
-      ];
-      const set2ComponentVersions = (await componentSetService.getComponentSetWebModel(set2.webPath)).components[
-        componentName
-      ];
-      const set3ComponentVersions = (await componentSetService.getComponentSetWebModel(set3.webPath)).components[
-        componentName
-      ];
-
-      expect(set1ComponentVersions).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            version: matchingComponentVersion,
-          }),
-        ]),
-      );
-      expect(set2ComponentVersions).toEqual(undefined);
-      expect(set3ComponentVersions).toEqual(undefined);
-    });
-  });
-});

package/src/domains/component-set/services/ComponentSetRuleService.ts

@@ -1,34 +0,0 @@
-import { ComponentConnectionManager } from '../../db';
-import { ComponentSetRuleInterface } from '../models/ComponentSetRule';
-import { ComponentSetService } from './ComponentSetService';
-
-export class ComponentSetRuleService {
-  constructor(private db: ComponentConnectionManager, private componentSetService: ComponentSetService) {}
-  public async addComponentVersionToRequiredSets(componentName: string, componentVersion: string) {
-    const componentSets = await this.db.repositories.componentSetRule.getComponentSetsMatchingComponentVersion(
-      componentName,
-      componentVersion,
-    );
-
-    // exclude the set that excludes this component version
-    const filteredComponentSetsRule: ComponentSetRuleInterface[] = [];
-    for (const csr of componentSets) {
-      if (
-        !(await this.componentSetService.componentVersionExcludedFromSet(
-          csr.componentSet,
-          componentName,
-          componentVersion,
-        ))
-      ) {
-        filteredComponentSetsRule.push(csr);
-      }
-    }
-
-    const addComponentToSet = ({ componentSet }: ComponentSetRuleInterface) =>
-      this.componentSetService.addComponentToSet(componentSet, componentName, componentVersion);
-
-    return Promise.allSettled(filteredComponentSetsRule.map(addComponentToSet));
-  }
-}
-
-export { ComponentSetRuleInterface };