@squiz/job-runner-lib 1.66.1

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,199 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,34 @@
+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 };