@squiz/job-runner-lib 1.66.1

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

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