@squiz/job-runner-lib 1.66.1 → 2.1.0

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

@@ -1,839 +0,0 @@
-import { BadRequestError, ResourceNotFoundError, getPageInfo, PageQueryResult } from '@squiz/dx-common-lib';
-import { TransactionClient } from '@squiz/db-lib';
-import { Logger } from '@squiz/dx-logger-lib';
-import { ComponentConnectionManager } from '../../db/ComponentConnectionManager';
-import { ComponentSet } from '../models/ComponentSet';
-import type {
-  ComponentSetWebModel,
-  ComponentSetWebModelForUpdate,
-  EnvironmentVariablesWebModel,
-  ComponentSetWebModelForCreate,
-  ComponentVersionRulesWebModel,
-} from '../web-models/ComponentSetForWeb';
-import { EditableComponentVersionTypes } from '../web-models/ComponentSetForWeb';
-import { AbstractComponentSetService } from './ComponentSetService';
-import {
-  ComponentSetComponentVersion,
-  ComponentSetComponentVersionStatus,
-} from '../models/ComponentSetComponentVersion';
-import { ComponentSetRule, assertIsCompenentSetRule } from '../models/ComponentSetRule';
-import { satisfies } from 'semver';
-import { ComponentSetInterface } from '../models/ComponentSet';
-import { SortDirection } from '@squiz/db-lib';
-import { Manifest, ManifestService } from '../../manifest';
-import { RuntimeComponentSet } from './RuntimeComponentSet';
-import { EnvironmentVariables } from './EnvironmentVariables';
-import { ComponentVersion } from '../../component/models/ComponentVersion';
-import * as semver from 'semver';
-import { PoolClient } from 'pg';
-import {
-  ComponentSetComponentVersionEditable,
-  assertIsComponentVersionEditable,
-} from '../models/ComponentSetComponentVersionEditable';
-import { ComponentSetComponentVersionExcluded } from '../models/ComponentSetComponentVersionExcluded';
-import { ComponentLogger } from '@squiz/component-logger-lib';
-
-type ComponentSetComponents = ComponentSetWebModel['components'];
-
-type PropertyToValidate = 'environment variable' | 'header';
-
-export type PQR<T> = PageQueryResult<T>;
-
-export class ComponentSetServiceForProduction extends AbstractComponentSetService {
-  constructor(
-    protected db: ComponentConnectionManager,
-    protected logger: Logger,
-    protected manifestService: ManifestService,
-    protected componentLoggingService: ComponentLogger,
-  ) {
-    super();
-  }
-
-  public async getComponentSet(webPath: string): Promise<ComponentSet> {
-    const set = await this.db.repositories.componentSet.getComponentSetByWebPath(webPath);
-
-    if (!set) throw new ResourceNotFoundError(`component set ${webPath} could not be found`);
-
-    return set;
-  }
-
-  public async addComponentSet(
-    componentSet: ComponentSetWebModelForCreate,
-    userId?: string,
-  ): Promise<ComponentSetWebModel> {
-    await this.assertValidCreateComponentSet(componentSet);
-
-    try {
-      const createdSet = await this.db.executeInTransaction(async (client) => {
-        const set = await this.db.repositories.componentSet.create(
-          new ComponentSet({
-            webPath: componentSet.webPath,
-            displayName: componentSet.displayName,
-            description: componentSet.description,
-            environmentVariables: componentSet.environmentVariables,
-            headers: componentSet.headers,
-          }),
-          client,
-        );
-
-        const componentSetRules = componentSet.componentVersionRules ?? {};
-        await this.setComponentVersionRules(componentSet.webPath, componentSetRules, client);
-        await this.saveComponentSetComponents(componentSet.webPath, componentSetRules, componentSet.components, client);
-
-        return set;
-      });
-      const savedSet = await this.getComponentSetWebModel(createdSet.webPath);
-
-      const logMessage = `Component set added: ${savedSet.webPath}.`;
-
-      const tags = `componentSetId:${savedSet.webPath}`;
-
-      await this.componentLoggingService.info(logMessage, undefined, userId, tags);
-      await this.componentLoggingService.flush();
-
-      return savedSet;
-    } catch (e) {
-      this.logger.error(`Error occurred when creating component set ${componentSet.webPath}: ${e}`);
-      throw e;
-    }
-  }
-
-  public async removeEnvironmentVariablesFromComponents(componentModel: ComponentSetWebModel) {
-    if (!componentModel.components) {
-      componentModel.components = {};
-    }
-    Object.keys(componentModel.components).forEach((componentKey) => {
-      componentModel.components[componentKey].forEach((c) => delete c.environmentVariables);
-    });
-  }
-
-  public getChangedComponentsInSet(oldComponentSet: ComponentSetWebModel, newComponentSet: ComponentSetWebModel) {
-    const oldComponentIds = oldComponentSet.components ? Object.keys(oldComponentSet.components) : [];
-    const newComponentIds = newComponentSet.components ? Object.keys(newComponentSet.components) : [];
-
-    const addedComponentIds: Array<string> = [];
-    const removedComponentIds: Array<string> = [];
-
-    for (const newId of newComponentIds) {
-      if (!oldComponentIds.includes(newId)) {
-        addedComponentIds.push(newId);
-      }
-    }
-    for (const oldId of oldComponentIds) {
-      if (!newComponentIds.includes(oldId)) {
-        removedComponentIds.push(oldId);
-      }
-    }
-    return addedComponentIds.concat(removedComponentIds);
-  }
-
-  public async updateComponentSet(
-    webPath: string,
-    data: ComponentSetWebModelForUpdate,
-    userId?: string,
-  ): Promise<ComponentSetWebModel> {
-    const existing = await this.db.repositories.componentSet.getComponentSetByWebPath(webPath);
-
-    if (!existing) {
-      throw new ResourceNotFoundError(`Component set with web path ${webPath} does not exist`);
-    }
-    const oldComponent = structuredClone(await this.getComponentSetWebModel(webPath));
-
-    const existingComponentVersionRules = await this.getExistingComponentSetRules(webPath);
-    await this.assertValidComponentSet(
-      data,
-      this.normalise(existing, {
-        components: await this.getExistingComponentsForWeb(webPath),
-        componentVersionRules: existingComponentVersionRules,
-      }),
-    );
-    this.assertValidComponentVersionRules(webPath, data.componentVersionRules);
-    this.assertComponentVersionsMatchRules(
-      data.components,
-      data.componentVersionRules ?? existingComponentVersionRules,
-    );
-
-    const values: ComponentSetWebModelForUpdate = {};
-    if (data.displayName !== undefined) {
-      values.displayName = data.displayName;
-    }
-    if (data.description !== undefined) {
-      values.description = data.description;
-    }
-    if (data.headers !== undefined) {
-      values.headers = data.headers;
-    }
-    if (data.environmentVariables !== undefined) {
-      values.environmentVariables = data.environmentVariables;
-    }
-
-    try {
-      await this.db.executeInTransaction(async (client: TransactionClient) => {
-        if (Object.keys(values).length > 0) {
-          await this.db.repositories.componentSet.update({ webPath }, values, client);
-        }
-
-        if (data.componentVersionRules) {
-          await this.setComponentVersionRules(webPath, data.componentVersionRules, client, true);
-        }
-        await this.saveComponentSetComponents(
-          webPath,
-          data.componentVersionRules ?? existingComponentVersionRules,
-          data.components,
-          client,
-        );
-      });
-      let logMessage = `Component set updated: "${webPath}".`;
-      const newComponents = structuredClone(await this.getComponentSetWebModel(webPath));
-
-      this.removeEnvironmentVariablesFromComponents(oldComponent);
-      this.removeEnvironmentVariablesFromComponents(newComponents);
-      logMessage += ` Changed from ${JSON.stringify(oldComponent.components)} to ${JSON.stringify(
-        newComponents.components,
-      )}.`;
-
-      const modifiedComponentIds = this.getChangedComponentsInSet(oldComponent, newComponents);
-
-      let tags = `componentSetId:${newComponents.webPath}`;
-      tags += ` ${modifiedComponentIds.map((id) => `componentId:${id}`).join(' ')}`;
-
-      await this.componentLoggingService.info(logMessage, undefined, userId, tags); // temp
-      await this.componentLoggingService.flush();
-
-      return this.getComponentSetWebModel(webPath);
-    } catch (e) {
-      this.logger.error(`Error occurred when updating component set ${webPath}: ${e}`);
-      throw e;
-    }
-  }
-
-  private async getExistingComponentSetRules(webPath: string): Promise<ComponentSetWebModel['componentVersionRules']> {
-    const existingRenderableComponentVersionsRules =
-      await this.db.repositories.componentSetRule.getComponentSetRulesForSet(webPath);
-    const existingEditableComponentVersions =
-      await this.db.repositories.componentSetComponentVersionEditable.getComponentSetEditableVersions(webPath);
-    const existingExcludedComponentVersions =
-      await this.db.repositories.componentSetComponentVersionExcluded.getComponentSetExcludedVersions(webPath);
-
-    const existingComponentVersionRules: ComponentSetWebModel['componentVersionRules'] = {};
-    for (const [c, rule] of Object.entries(existingRenderableComponentVersionsRules)) {
-      if (existingComponentVersionRules[c] === undefined) {
-        existingComponentVersionRules[c] = {
-          renderableVersionPattern: rule,
-          editableVersions: [],
-          excludedVersions: [],
-        };
-      }
-    }
-    for (const [c, versions] of Object.entries(existingEditableComponentVersions)) {
-      if (existingComponentVersionRules[c] === undefined) {
-        existingComponentVersionRules[c] = {
-          renderableVersionPattern: '',
-          editableVersions: [],
-          excludedVersions: [],
-        };
-      }
-      existingComponentVersionRules[c].editableVersions = versions;
-    }
-    for (const [c, versions] of Object.entries(existingExcludedComponentVersions)) {
-      if (existingComponentVersionRules[c] === undefined) {
-        existingComponentVersionRules[c] = {
-          renderableVersionPattern: '',
-          editableVersions: [],
-          excludedVersions: [],
-        };
-      }
-      existingComponentVersionRules[c].excludedVersions = versions;
-    }
-    return existingComponentVersionRules;
-  }
-
-  private async saveComponentSetComponents(
-    webPath: string,
-    componentVersionRules: ComponentSetWebModelForUpdate['componentVersionRules'],
-    components: ComponentSetWebModelForUpdate['components'] | undefined,
-    client: PoolClient,
-  ) {
-    const existingComponentVersionsInSet = await this.db.repositories.componentSetComponentVersion.find({
-      componentSetWebPath: webPath,
-    });
-
-    const renderableComponentVersions = await this.getRenderableComponentVersions(componentVersionRules);
-
-    await this.addComponentEntriesInSet(
-      webPath,
-      renderableComponentVersions,
-      existingComponentVersionsInSet,
-      components,
-      client,
-    );
-    await this.updateComponentEntriesInSet(
-      webPath,
-      renderableComponentVersions,
-      existingComponentVersionsInSet,
-      components,
-      client,
-    );
-  }
-
-  private async getRenderableComponentVersions(
-    componentVersionRules: ComponentSetWebModelForUpdate['componentVersionRules'],
-  ): Promise<ComponentVersion[]> {
-    const renderableComponentVersions: ComponentVersion[] = [];
-    if (componentVersionRules) {
-      for (const [componentName, rule] of Object.entries(componentVersionRules)) {
-        const componentVersionsMatchingRules = (
-          await this.getComponentVersionMatchingComponentSetRule(componentName, rule.renderableVersionPattern)
-        )
-          // filter out excluded component versions
-          .filter((c) => !rule.excludedVersions.includes(c.version));
-        renderableComponentVersions.push(...componentVersionsMatchingRules);
-      }
-    }
-    return renderableComponentVersions;
-  }
-
-  private async addComponentEntriesInSet(
-    webPath: string,
-    renderableComponentVersions: ComponentVersion[],
-    existingComponentVersionsInSet: ComponentSetComponentVersion[],
-    components: ComponentSetWebModelForUpdate['components'] | undefined,
-    client: PoolClient,
-  ) {
-    const rows = renderableComponentVersions
-      .filter(
-        (cv) =>
-          undefined ===
-          existingComponentVersionsInSet.find(
-            (cvs) => cvs.componentName === cv.componentName && cvs.componentVersion === cv.version,
-          ),
-      )
-      .map((cv) => {
-        let envVars: EnvironmentVariablesWebModel | undefined = {};
-        if (components !== undefined && components[cv.componentName] !== undefined) {
-          envVars = components[cv.componentName].find((c) => c.version === cv.version)?.environmentVariables;
-        }
-        return new ComponentSetComponentVersion({
-          componentSetWebPath: webPath,
-          componentName: cv.componentName,
-          componentVersion: cv.version,
-          environmentVariables: envVars ?? {},
-        });
-      });
-
-    for (const row of rows) {
-      await this.db.repositories.componentSetComponentVersion.create(row, client);
-    }
-  }
-
-  private async updateComponentEntriesInSet(
-    webPath: string,
-    renderableComponentVersions: ComponentVersion[],
-    existingComponentVersionsInSet: ComponentSetComponentVersion[],
-    components: ComponentSetWebModelForUpdate['components'] | undefined,
-    client: PoolClient,
-  ) {
-    for (const cvs of existingComponentVersionsInSet) {
-      const updateData: Partial<ComponentSetComponentVersion> = {};
-      const belongsInSet =
-        undefined !==
-        renderableComponentVersions.find(
-          (cv) => cvs.componentName === cv.componentName && cvs.componentVersion === cv.version,
-        );
-
-      let status = cvs.status;
-      if (belongsInSet && cvs.status === ComponentSetComponentVersionStatus.excluded) {
-        updateData.status = ComponentSetComponentVersionStatus.active;
-        status = updateData.status;
-      } else if (!belongsInSet && cvs.status === ComponentSetComponentVersionStatus.active) {
-        updateData.status = ComponentSetComponentVersionStatus.excluded;
-        status = updateData.status;
-      }
-
-      // update the env vars only if component belongs to the set
-      if (
-        belongsInSet &&
-        status === ComponentSetComponentVersionStatus.active &&
-        components !== undefined &&
-        components[cvs.componentName] !== undefined
-      ) {
-        const envVars = components[cvs.componentName].find(
-          (c) => c.version === cvs.componentVersion,
-        )?.environmentVariables;
-        if (envVars !== undefined && JSON.stringify(envVars) !== JSON.stringify(cvs.environmentVariables)) {
-          updateData.environmentVariables = envVars;
-        }
-      }
-
-      if (Object.keys(updateData).length > 0) {
-        await this.db.repositories.componentSetComponentVersion.update(
-          {
-            componentSetWebPath: webPath,
-            componentName: cvs.componentName,
-            componentVersion: cvs.componentVersion,
-          },
-          updateData,
-          client,
-        );
-      }
-    }
-  }
-
-  private async getComponentVersionMatchingComponentSetRule(
-    componentName: string,
-    componentRule: string,
-  ): Promise<ComponentVersion[]> {
-    const componentVersions = (
-      await this.db.repositories.componentVersion.find({
-        componentName,
-      })
-    ).filter((cv: ComponentVersion) => componentRule.trim().length && semver.satisfies(cv.version, componentRule));
-
-    return componentVersions;
-  }
-
-  public async getComponentsRuntimeSetData(manifest: Manifest, set: ComponentSet): Promise<RuntimeComponentSet> {
-    const envVars: EnvironmentVariables = {};
-
-    const requestEnvVars = manifest.getModel().environment || [];
-
-    const componentSetMembership = await this.db.repositories.componentSetComponentVersion.findOne({
-      componentName: manifest.getName(),
-      componentVersion: manifest.getVersion(),
-      componentSetWebPath: set.webPath,
-    });
-
-    if (!componentSetMembership) {
-      throw new ResourceNotFoundError(
-        `component ${manifest.getName()} ${manifest.getVersion} couldn't not be found in set ${set.webPath}`,
-      );
-    }
-    const missingVariables: string[] = [];
-    for (const envVar of requestEnvVars) {
-      if (set.environmentVariables[envVar.name] === undefined) {
-        if (envVar.required !== false) {
-          missingVariables.push(envVar.name);
-        }
-      } else {
-        envVars[envVar.name] =
-          componentSetMembership.environmentVariables[envVar.name] ?? set.environmentVariables[envVar.name];
-      }
-    }
-    if (missingVariables.length > 0) {
-      throw new BadRequestError(`Missing required environment variables: "${missingVariables.join('","')}"`);
-    }
-
-    return {
-      environment: envVars,
-      displayName: set.displayName,
-      webPath: set.webPath,
-    };
-  }
-
-  private async setComponentVersionRules(
-    webPath: string,
-    componentVersionRules: Required<ComponentSetWebModelForUpdate>['componentVersionRules'],
-    client: TransactionClient,
-    updating: boolean = false,
-  ) {
-    if (updating) {
-      await this.db.repositories.componentSetRule.removeExistingRulesForComponentSet(webPath, client);
-      await this.db.repositories.componentSetComponentVersionEditable.delete({ componentSetWebPath: webPath }, client);
-      await this.db.repositories.componentSetComponentVersionExcluded.delete({ componentSetWebPath: webPath }, client);
-    }
-
-    for (const [componentName, rule] of Object.entries(componentVersionRules)) {
-      await this.db.repositories.componentSetRule.create(
-        new ComponentSetRule({
-          componentSet: webPath,
-          componentName,
-          versionPattern: rule.renderableVersionPattern,
-        }),
-        client,
-      );
-      const editableVersions =
-        typeof rule.editableVersions === 'string' ? [rule.editableVersions] : rule.editableVersions;
-      for (const componentVersion of editableVersions) {
-        await this.db.repositories.componentSetComponentVersionEditable.create(
-          new ComponentSetComponentVersionEditable({
-            componentSetWebPath: webPath,
-            componentName,
-            componentVersion,
-          }),
-          client,
-        );
-      }
-      for (const componentVersion of rule.excludedVersions) {
-        await this.db.repositories.componentSetComponentVersionExcluded.create(
-          new ComponentSetComponentVersionExcluded({
-            componentSetWebPath: webPath,
-            componentName,
-            componentVersion,
-          }),
-          client,
-        );
-      }
-    }
-  }
-
-  public async getComponentSetWebModel(webPath: string): Promise<ComponentSetWebModel> {
-    const set = await this.db.repositories.componentSet.getComponentSetByWebPath(webPath);
-
-    if (set === undefined) {
-      throw new ResourceNotFoundError(`Component set with web path ${webPath} does not exist`);
-    }
-
-    return this.normalise(set, {
-      components: await this.getExistingComponentsForWeb(webPath),
-      componentVersionRules: await this.getExistingComponentSetRules(webPath),
-    });
-  }
-
-  public async deleteComponentSet(webPath: string, userId?: string): Promise<number> {
-    if (!(await this.db.repositories.componentSet.componentSetExists(webPath))) {
-      throw new ResourceNotFoundError(`Component set with web path ${webPath} does not exist`);
-    }
-    const logMessage = `Component set deleted: ${webPath}.`;
-    const tags = `componentSetId:${webPath}`;
-    await this.componentLoggingService.info(logMessage, undefined, userId, tags);
-    await this.componentLoggingService.flush();
-    return await this.db.repositories.componentSet.delete({ webPath });
-  }
-
-  private normalise(
-    set: any,
-    {
-      components,
-      componentVersionRules,
-    }: { components: ComponentSetComponents; componentVersionRules: ComponentSetWebModel['componentVersionRules'] },
-  ): ComponentSetWebModel {
-    return {
-      webPath: set.webPath ?? '',
-      displayName: set.displayName ?? '',
-      description: set.description ?? '',
-      environmentVariables: set.environmentVariables ?? {},
-      headers: set.headers ?? {},
-      components: components ?? {},
-      componentVersionRules: componentVersionRules ?? {},
-    };
-  }
-
-  private async getExistingComponentsForWeb(webPath: string): Promise<ComponentSetComponents> {
-    const dbEntries = await this.db.repositories.componentVersion.getComponentSetComponentVersionByWebPath(
-      webPath,
-      ComponentSetComponentVersionStatus.active,
-    );
-
-    const componentLatestVersion: { [key: string]: string } = {};
-    for (const row of dbEntries) {
-      if (
-        componentLatestVersion[row.componentName] === undefined ||
-        semver.compare(row.version, componentLatestVersion[row.componentName]) > 0
-      ) {
-        componentLatestVersion[row.componentName] = row.version;
-      }
-    }
-
-    const editableVersions =
-      await this.db.repositories.componentSetComponentVersionEditable.getComponentSetEditableVersions(webPath);
-
-    const components: ComponentSetComponents = {};
-
-    for (const row of dbEntries) {
-      if (components[row.componentName] === undefined) {
-        components[row.componentName] = [];
-      }
-
-      components[row.componentName].push({
-        version: row.version,
-        environmentVariables: row.environmentVariables ?? {},
-
-        description: row.description,
-        displayName: row.displayName,
-        icon: row.icon,
-        editable: this.isComponentVersionEditable(
-          row.version,
-          editableVersions[row.componentName],
-          componentLatestVersion[row.componentName],
-        ),
-      });
-    }
-
-    // sort the entries by version, latest at the top
-    Object.entries(components).forEach(([key, versions]) => {
-      components[key] = versions.sort((a, b) => {
-        if (a.version < b.version) return 1;
-        if (a.version > b.version) return -1;
-        return 0;
-      });
-    });
-
-    return components;
-  }
-
-  private isComponentVersionEditable(
-    version: string,
-    editableVersions: string[] | undefined,
-    componentLatestVersion: string,
-  ): boolean {
-    if (editableVersions === undefined || editableVersions.length < 1) {
-      return false;
-    }
-    if (editableVersions.includes(EditableComponentVersionTypes.Latest) && version === componentLatestVersion) {
-      return true;
-    }
-    return editableVersions.includes(version);
-  }
-
-  private async assertValidCreateComponentSet(componentSet: ComponentSetWebModelForCreate): Promise<void> {
-    if (!componentSet.webPath) {
-      throw new BadRequestError("Component set 'webPath' must be specificed and non-empty");
-    }
-    if (!componentSet.displayName) {
-      throw new BadRequestError("Component set 'displayName' must be specificed and non-empty");
-    }
-    this.assertValidWebPath(componentSet.webPath);
-    if (await this.db.repositories.componentSet.componentSetExists(componentSet.webPath)) {
-      throw new BadRequestError(`Component set with web path ${componentSet.webPath} already exists`);
-    }
-    await this.assertValidComponentSet(componentSet);
-    this.assertValidComponentVersionRules(componentSet.webPath, componentSet.componentVersionRules);
-    this.assertComponentVersionsMatchRules(componentSet.components, componentSet.componentVersionRules);
-  }
-
-  private assertComponentVersionsMatchRules(
-    components: ComponentSetWebModelForCreate['components'] = {},
-    componentVersionRules: ComponentSetWebModel['componentVersionRules'] = {},
-  ) {
-    for (const [componentName, componentVersions] of Object.entries(components)) {
-      const allVersionsSatisfyVersionRules =
-        componentVersionRules[componentName] !== undefined &&
-        componentVersions.every(({ version }) =>
-          satisfies(version, componentVersionRules[componentName].renderableVersionPattern),
-        );
-      if (!allVersionsSatisfyVersionRules) {
-        throw new BadRequestError(`Component versions must satisfy version rule`);
-      }
-    }
-  }
-
-  private async assertValidComponentSet(
-    componentSet: ComponentSetWebModelForUpdate,
-    currentComponentSet: ComponentSetWebModel | undefined = undefined,
-  ): Promise<void> {
-    if (componentSet.environmentVariables !== undefined) {
-      this.assertValidEnvVars(componentSet.environmentVariables);
-    }
-    if (componentSet.headers !== undefined) {
-      this.assertValidHeaders(componentSet.headers);
-    }
-
-    if (componentSet.components !== undefined) {
-      const csEnvVars = componentSet.environmentVariables ?? currentComponentSet?.environmentVariables ?? {};
-      await this.assertValidComponents(componentSet.components, csEnvVars);
-    }
-  }
-
-  private assertValidWebPath(webPath: string) {
-    if (webPath.replace(/[^a-z0-9\-_.]/i, '') !== webPath) {
-      throw new BadRequestError('Invalid Component Set web path. Only [A-Za-z0-9_-.] chars are allowed');
-    }
-  }
-
-  private assertValidEnvVars(environmentVariables: ComponentSetWebModel['environmentVariables'] = {}) {
-    Object.entries(environmentVariables).forEach(([name, value]) => {
-      this.assertValidProperty({ name, value, type: 'environment variable' });
-    });
-  }
-
-  private assertValidHeaders(headers: ComponentSetWebModel['headers']): void {
-    Object.entries(headers).forEach(([name, value]) => {
-      this.assertValidProperty({ name, value, type: 'header' });
-    });
-  }
-
-  private assertValidProperty(componentSetProperty: { name: string; value: string; type: PropertyToValidate }): void {
-    const validCharSet = /^[a-z0-9\-_.]+$/i;
-
-    if (!validCharSet.test(componentSetProperty.name)) {
-      throw new BadRequestError(
-        `Invalid '${componentSetProperty.type}' name for '${componentSetProperty.name}'. Only [A-Za-z0-9_-.] chars are allowed`,
-      );
-    }
-
-    if (typeof componentSetProperty.value !== 'string') {
-      throw new BadRequestError(
-        `Invalid '${componentSetProperty.type}' value for  '${componentSetProperty.name}'. Value must be a string`,
-      );
-    }
-  }
-
-  private async assertValidComponents(
-    components:
-      | ComponentSetComponents
-      | ComponentSetWebModelForUpdate['components']
-      | ComponentSetWebModelForCreate['components'],
-    componentSetEnvironmentVariables: EnvironmentVariablesWebModel,
-  ): Promise<void> {
-    const repo = this.db.repositories.componentVersion;
-
-    if (components) {
-      for (const [componentName, versions] of Object.entries(components)) {
-        if (!componentName) {
-          throw new BadRequestError(`Component name must be non-empty`);
-        }
-        const setVersions: string[] = [];
-
-        for (const v of versions) {
-          if (!v.version) {
-            throw new BadRequestError(`Component version must set and be non-empty`);
-          }
-
-          if (setVersions.includes(v.version)) {
-            throw new BadRequestError(
-              `Multiple componet version entries for component ${componentName} with version ${v.version}`,
-            );
-          }
-
-          setVersions.push(v.version);
-
-          if (v.environmentVariables !== undefined) {
-            this.assertValidEnvVars(v.environmentVariables);
-
-            const unknownEnvVars = Object.keys(v.environmentVariables).filter(
-              (ev) => !Object.keys(componentSetEnvironmentVariables).includes(ev),
-            );
-            if (unknownEnvVars.length) {
-              throw new BadRequestError(
-                `Env var(s) '${unknownEnvVars.join("', '")}' defined on component ${componentName} with version ${
-                  v.version
-                } is/are not defined on the component set`,
-              );
-            }
-          }
-          if (!(await repo.componentVersionExists(componentName, v.version))) {
-            throw new BadRequestError(`Component ${componentName} with version ${v.version} does not exists`);
-          }
-        }
-      }
-    }
-  }
-
-  private assertValidComponentVersionRules(
-    webPath: string,
-    componentVersionRules: Record<string, ComponentVersionRulesWebModel> = {},
-  ) {
-    for (const [cName, vRule] of Object.entries(componentVersionRules)) {
-      try {
-        this.assertValidVersionRule(vRule.renderableVersionPattern);
-        assertIsCompenentSetRule({
-          componentSet: webPath,
-          componentName: cName,
-          versionPattern: vRule.renderableVersionPattern,
-        });
-
-        const editableVersions =
-          typeof vRule.editableVersions === 'string' ? [vRule.editableVersions] : vRule.editableVersions;
-        this.assertValidEditableVersions(editableVersions);
-        for (const version of editableVersions) {
-          assertIsComponentVersionEditable({
-            componentSetWebPath: webPath,
-            componentName: cName,
-            componentVersion: version,
-          });
-        }
-      } catch (e: any) {
-        throw new BadRequestError(e.message);
-      }
-    }
-  }
-
-  private assertValidVersionRule(version: string) {
-    if (!semver.validRange(version)) {
-      throw new Error(`Invalid renderable component version semver value: ${version}`);
-    }
-  }
-
-  private assertValidEditableVersions(versions: string[]) {
-    const duplicates = versions.filter((item, index) => versions.indexOf(item) != index);
-    if (duplicates.length) {
-      throw new Error(`Duplicate editable versions: ${[...new Set(duplicates)].join(', ')}`);
-    }
-  }
-
-  public async getAllComponentSets(): Promise<ComponentSetWebModel[]> {
-    const rows = await this.db.repositories.componentSet.findAll();
-    const componentSets: ComponentSetWebModel[] = [];
-
-    for (const row of rows) {
-      const components = await this.getExistingComponentsForWeb(row.webPath);
-      componentSets.push(
-        this.normalise(row, {
-          components,
-          componentVersionRules: await this.getExistingComponentSetRules(row.webPath),
-        }),
-      );
-    }
-    return componentSets;
-  }
-
-  public async getPaginatedComponentSets(
-    pageNumber: number = 1,
-    sortBy: (keyof ComponentSetInterface)[] = [],
-    sortDirection: SortDirection = 'asc',
-  ): Promise<PageQueryResult<ComponentSetWebModel>> {
-    const pageResult = await this.db.repositories.componentSet.getPage(pageNumber, sortBy, sortDirection);
-    const componentSets: ComponentSetWebModel[] = [];
-    for (const row of pageResult.items) {
-      const components = await this.getExistingComponentsForWeb(row.webPath);
-      componentSets.push(
-        this.normalise(row, {
-          components,
-          componentVersionRules: await this.getExistingComponentSetRules(row.webPath),
-        }),
-      );
-    }
-    return {
-      items: componentSets,
-      pageInfo: getPageInfo(pageNumber, pageResult.pageSize, pageResult.totalCount),
-    };
-  }
-
-  public async componentVersionInSet(manifest: Manifest, webPath: string): Promise<boolean> {
-    const componentSetMembership = await this.db.repositories.componentSetComponentVersion.findOne({
-      componentName: manifest.getName(),
-      componentVersion: manifest.getVersion(),
-      componentSetWebPath: webPath,
-      status: ComponentSetComponentVersionStatus.active,
-    });
-    return componentSetMembership !== undefined;
-  }
-
-  public async addComponentToSet(webPath: string, componentName: string, componentVersion: string, userId?: string) {
-    const componentSetComponentVersionInterface = await this.db.repositories.componentSetComponentVersion.create(
-      new ComponentSetComponentVersion({
-        componentSetWebPath: webPath,
-        componentName,
-        componentVersion,
-      }),
-    );
-    const logMessage = `Component: ${componentName} added to ${webPath}.`;
-    const tags = `componentSetId:${webPath} componentId:${componentName}`;
-    await this.componentLoggingService.info(logMessage, undefined, userId, tags);
-    await this.componentLoggingService.flush();
-    return componentSetComponentVersionInterface;
-  }
-
-  public async componentVersionExcludedFromSet(
-    webPath: string,
-    componentName: string,
-    componentVersion: string,
-  ): Promise<boolean> {
-    const excluded = await this.db.repositories.componentSetComponentVersionExcluded.find({
-      componentSetWebPath: webPath,
-      componentName,
-      componentVersion,
-    });
-    return excluded.length > 0;
-  }
-}