@adobe/spacecat-shared-data-access 2.88.9 → 2.90.0

package/src/models/base/entity.registry.js

@@ -16,6 +16,7 @@ import { collectionNameToEntityName, decapitalize } from '../../util/util.js';
 import ApiKeyCollection from '../api-key/api-key.collection.js';
 import AsyncJobCollection from '../async-job/async-job.collection.js';
 import AuditCollection from '../audit/audit.collection.js';
+import AuditUrlCollection from '../audit-url/audit-url.collection.js';
 import ConfigurationCollection from '../configuration/configuration.collection.js';
 import ExperimentCollection from '../experiment/experiment.collection.js';
 import EntitlementCollection from '../entitlement/entitlement.collection.js';
@@ -45,7 +46,7 @@ import PageCitabilityCollection from '../page-citability/page-citability.collect
 import ApiKeySchema from '../api-key/api-key.schema.js';
 import AsyncJobSchema from '../async-job/async-job.schema.js';
 import AuditSchema from '../audit/audit.schema.js';
-import ConfigurationSchema from '../configuration/configuration.schema.js';
+import AuditUrlSchema from '../audit-url/audit-url.schema.js';
 import EntitlementSchema from '../entitlement/entitlement.schema.js';
 import FixEntitySchema from '../fix-entity/fix-entity.schema.js';
 import FixEntitySuggestionSchema from '../fix-entity-suggestion/fix-entity-suggestion.schema.js';
@@ -82,11 +83,13 @@ class EntityRegistry {
   /**
    * Constructs an instance of EntityRegistry.
    * @constructor
-   * @param {Object} service - The ElectroDB service instance used to manage entities.
+   * @param {Object} services - Dictionary of services keyed by datastore type.
+   * @param {Object} services.dynamo - The ElectroDB service instance for DynamoDB operations.
+   * @param {{s3Client: S3Client, s3Bucket: string}|null} [services.s3] - S3 service configuration.
    * @param {Object} log - A logger for capturing and logging information.
    */
-  constructor(service, log) {
-    this.service = service;
+  constructor(services, log) {
+    this.services = services;
     this.log = log;
     this.collections = new Map();
 
@@ -96,13 +99,20 @@ class EntityRegistry {
   /**
    * Initializes the collections managed by the EntityRegistry.
    * This method creates instances of each collection and stores them in an internal map.
+   * ElectroDB-based collections are initialized with the dynamo service.
+   * Configuration is handled specially as it's a standalone S3-based collection.
    * @private
    */
   #initialize() {
+    // Initialize ElectroDB-based collections
     Object.values(EntityRegistry.entities).forEach(({ collection: Collection, schema }) => {
-      const collection = new Collection(this.service, this, schema, this.log);
+      const collection = new Collection(this.services.dynamo, this, schema, this.log);
       this.collections.set(Collection.COLLECTION_NAME, collection);
     });
+
+    // Initialize Configuration collection separately (standalone S3-based)
+    const configCollection = new ConfigurationCollection(this.services.s3, this.log);
+    this.collections.set(ConfigurationCollection.COLLECTION_NAME, configCollection);
   }
 
   /**
@@ -140,10 +150,11 @@ class EntityRegistry {
   }
 }
 
+// Register ElectroDB-based entities only (Configuration is handled separately)
 EntityRegistry.registerEntity(ApiKeySchema, ApiKeyCollection);
 EntityRegistry.registerEntity(AsyncJobSchema, AsyncJobCollection);
 EntityRegistry.registerEntity(AuditSchema, AuditCollection);
-EntityRegistry.registerEntity(ConfigurationSchema, ConfigurationCollection);
+EntityRegistry.registerEntity(AuditUrlSchema, AuditUrlCollection);
 EntityRegistry.registerEntity(EntitlementSchema, EntitlementCollection);
 EntityRegistry.registerEntity(FixEntitySchema, FixEntityCollection);
 EntityRegistry.registerEntity(FixEntitySuggestionSchema, FixEntitySuggestionCollection);

package/src/models/configuration/configuration.collection.js

@@ -10,36 +10,196 @@
  * governing permissions and limitations under the License.
  */
 
-import { incrementVersion, sanitizeIdAndAuditFields, zeroPad } from '../../util/util.js';
-import BaseCollection from '../base/base.collection.js';
+import {
+  GetObjectCommand,
+  PutObjectCommand,
+} from '@aws-sdk/client-s3';
+
+import DataAccessError from '../../errors/data-access.error.js';
+import { sanitizeIdAndAuditFields } from '../../util/util.js';
+import Configuration from './configuration.model.js';
+import { checkConfiguration } from './configuration.schema.js';
+
+const S3_CONFIG_KEY = 'config/spacecat/global-config.json';
 
 /**
- * ConfigurationCollection - A collection class responsible for managing Configuration entities.
- * Extends the BaseCollection to provide specific methods for interacting with
- * Configuration records.
+ * ConfigurationCollection - A standalone collection class for managing Configuration entities.
+ * Unlike other collections, this does not use ElectroDB or DynamoDB.
+ * Configuration is stored as a versioned JSON object in S3.
  *
  * @class ConfigurationCollection
- * @extends BaseCollection
  */
-class ConfigurationCollection extends BaseCollection {
+class ConfigurationCollection {
   static COLLECTION_NAME = 'ConfigurationCollection';
 
+  /**
+   * Constructs an instance of ConfigurationCollection.
+   * @constructor
+   * @param {{s3Client: S3Client, s3Bucket: string}|null} s3Config - S3 configuration.
+   * @param {Object} log - A logger for capturing logging information.
+   */
+  constructor(s3Config, log) {
+    this.log = log;
+
+    if (s3Config) {
+      this.s3Client = s3Config.s3Client;
+      this.s3Bucket = s3Config.s3Bucket;
+    }
+  }
+
+  /**
+   * Validates that S3 is configured. Throws an error if not.
+   * @private
+   * @throws {DataAccessError} If S3 is not configured.
+   */
+  #requireS3() {
+    if (!this.s3Client || !this.s3Bucket) {
+      throw new DataAccessError(
+        'S3 configuration is required for Configuration storage. '
+        + 'Ensure S3_CONFIG_BUCKET environment variable is set.',
+        this,
+      );
+    }
+  }
+
+  /**
+   * Creates an instance of the Configuration model from data and versionId.
+   * @private
+   * @param {Object} data - The configuration data.
+   * @param {string} versionId - The S3 VersionId.
+   * @returns {Configuration} - The Configuration model instance.
+   */
+  #createInstance(data, versionId) {
+    return new Configuration(data, versionId, this, this.log);
+  }
+
+  /**
+   * Creates a new configuration version and stores it in S3.
+   * S3 versioning handles the version history automatically.
+   * The S3 VersionId is used as the configurationId.
+   *
+   * @param {Object} data - The configuration data to store.
+   * @returns {Promise<Configuration>} - The created Configuration instance.
+   * @throws {DataAccessError} If S3 is not configured or the operation fails.
+   */
   async create(data) {
-    const latestConfiguration = await this.findLatest();
-    const version = latestConfiguration ? incrementVersion(latestConfiguration.getVersion()) : 1;
-    const sanitizedData = sanitizeIdAndAuditFields('Configuration', data);
+    this.#requireS3();
+
+    try {
+      const sanitizedData = sanitizeIdAndAuditFields('Configuration', data);
+
+      const now = new Date().toISOString();
+      const configData = {
+        ...sanitizedData,
+        createdAt: now,
+        updatedAt: now,
+        updatedBy: sanitizedData.updatedBy || 'system',
+      };
+
+      // Validate the configuration against the schema
+      checkConfiguration(configData);
+
+      const command = new PutObjectCommand({
+        Bucket: this.s3Bucket,
+        Key: S3_CONFIG_KEY,
+        Body: JSON.stringify(configData),
+        ContentType: 'application/json',
+      });
 
-    sanitizedData.version = version;
+      const response = await this.s3Client.send(command);
+      const { VersionId: versionId } = response;
 
-    return super.create(sanitizedData);
+      this.log.info(`Configuration stored in S3 with VersionId ${versionId}`);
+
+      return this.#createInstance(configData, versionId);
+    } catch (error) {
+      if (error instanceof DataAccessError) {
+        throw error;
+      }
+      const message = `Failed to create configuration in S3: ${error.message}`;
+      this.log.error(message, error);
+      throw new DataAccessError(message, this, error);
+    }
   }
 
+  /**
+   * Finds a configuration by S3 VersionId.
+   *
+   * @param {string} version - The S3 VersionId.
+   * @returns {Promise<Configuration|null>} - The Configuration instance or null if not found.
+   * @throws {DataAccessError} If S3 is not configured or the operation fails.
+   */
   async findByVersion(version) {
-    return this.findByAll({ versionString: zeroPad(version, 10) });
+    this.#requireS3();
+
+    const versionId = String(version);
+
+    try {
+      const command = new GetObjectCommand({
+        Bucket: this.s3Bucket,
+        Key: S3_CONFIG_KEY,
+        VersionId: versionId,
+      });
+
+      const response = await this.s3Client.send(command);
+      const bodyString = await response.Body.transformToString();
+      const configData = JSON.parse(bodyString);
+
+      return this.#createInstance(configData, versionId);
+    } catch (error) {
+      if (error.name === 'NoSuchKey' || error.name === 'NoSuchVersion') {
+        this.log.info(`Configuration with version ${versionId} not found in S3`);
+        return null;
+      }
+
+      if (error instanceof DataAccessError) {
+        throw error;
+      }
+
+      const message = `Failed to retrieve configuration with version ${versionId} from S3: ${error.message}`;
+      this.log.error(message, error);
+      throw new DataAccessError(message, this, error);
+    }
   }
 
+  /**
+   * Retrieves the latest configuration from S3.
+   * S3 automatically returns the latest version when versioning is enabled.
+   *
+   * @returns {Promise<Configuration|null>} - The latest Configuration instance
+   * or null if not found.
+   * @throws {DataAccessError} If S3 is not configured or the operation fails.
+   */
   async findLatest() {
-    return this.findByAll({}, { order: 'desc' });
+    this.#requireS3();
+
+    try {
+      const command = new GetObjectCommand({
+        Bucket: this.s3Bucket,
+        Key: S3_CONFIG_KEY,
+      });
+
+      const response = await this.s3Client.send(command);
+      const bodyString = await response.Body.transformToString();
+      const configData = JSON.parse(bodyString);
+      const { VersionId: versionId } = response;
+
+      return this.#createInstance(configData, versionId);
+    } catch (error) {
+      // If the object doesn't exist, return null (first-time setup)
+      if (error.name === 'NoSuchKey') {
+        this.log.info('No configuration found in S3, returning null');
+        return null;
+      }
+
+      if (error instanceof DataAccessError) {
+        throw error;
+      }
+
+      const message = `Failed to retrieve configuration from S3: ${error.message}`;
+      this.log.error(message, error);
+      throw new DataAccessError(message, this, error);
+    }
   }
 }
 

package/src/models/configuration/configuration.model.js

@@ -13,17 +13,16 @@
 import { isNonEmptyObject, isNonEmptyArray } from '@adobe/spacecat-shared-utils';
 
 import { sanitizeIdAndAuditFields } from '../../util/util.js';
-import BaseModel from '../base/base.model.js';
 import { Entitlement } from '../entitlement/index.js';
 
 /**
- * Configuration - A class representing an Configuration entity.
- * Provides methods to access and manipulate Configuration-specific data.
+ * Configuration - A standalone class representing the global Configuration entity.
+ * This is a singleton entity stored in S3 with versioning.
+ * Unlike other entities, Configuration does not use ElectroDB or DynamoDB.
  *
  * @class Configuration
- * @extends BaseModel
  */
-class Configuration extends BaseModel {
+class Configuration {
   static ENTITY_NAME = 'Configuration';
 
   static JOB_GROUPS = {
@@ -53,7 +52,78 @@ class Configuration extends BaseModel {
 
   static AUDIT_NAME_MAX_LENGTH = 37;
 
-  // add your custom methods or overrides here
+  constructor(data, versionId, collection, log) {
+    this.handlers = data.handlers;
+    this.jobs = data.jobs;
+    this.queues = data.queues;
+    this.slackRoles = data.slackRoles;
+    this.createdAt = data.createdAt;
+    this.updatedAt = data.updatedAt;
+    this.updatedBy = data.updatedBy;
+    this.versionId = versionId;
+    this.collection = collection;
+    this.log = log;
+  }
+
+  getId() {
+    return this.versionId;
+  }
+
+  getConfigurationId() {
+    return this.versionId;
+  }
+
+  getVersion() {
+    return this.versionId;
+  }
+
+  getCreatedAt() {
+    return this.createdAt;
+  }
+
+  getUpdatedAt() {
+    return this.updatedAt;
+  }
+
+  getUpdatedBy() {
+    return this.updatedBy;
+  }
+
+  setUpdatedBy(updatedBy) {
+    this.updatedBy = updatedBy;
+  }
+
+  getHandlers() {
+    return this.handlers;
+  }
+
+  setHandlers(handlers) {
+    this.handlers = handlers;
+  }
+
+  getJobs() {
+    return this.jobs;
+  }
+
+  setJobs(jobs) {
+    this.jobs = jobs;
+  }
+
+  getQueues() {
+    return this.queues;
+  }
+
+  setQueues(queues) {
+    this.queues = queues;
+  }
+
+  getSlackRoles() {
+    return this.slackRoles;
+  }
+
+  setSlackRoles(slackRoles) {
+    this.slackRoles = slackRoles;
+  }
 
   getHandler(type) {
     return this.getHandlers()?.[type];
@@ -161,6 +231,7 @@ class Configuration extends BaseModel {
     if (enabled) {
       if (handler.enabledByDefault) {
         handler.disabled[entityKey] = handler.disabled[entityKey]
+          /* c8 ignore next */
           .filter((id) => id !== entityId) || [];
       } else {
         handler.enabled[entityKey] = Array
@@ -170,6 +241,7 @@ class Configuration extends BaseModel {
       handler.disabled[entityKey] = Array
         .from(new Set([...(handler.disabled[entityKey] || []), entityId]));
     } else {
+      /* c8 ignore next */
       handler.enabled[entityKey] = handler.enabled[entityKey].filter((id) => id !== entityId) || [];
     }
 
@@ -270,6 +342,7 @@ class Configuration extends BaseModel {
     if (!isNonEmptyObject(queues)) {
       throw new Error('Queues configuration cannot be empty');
     }
+    /* c8 ignore next */
     const existingQueues = this.getQueues() || {};
     const mergedQueues = { ...existingQueues, ...queues };
     this.setQueues(mergedQueues);
@@ -496,7 +569,19 @@ class Configuration extends BaseModel {
   }
 
   async save() {
-    return this.collection.create(sanitizeIdAndAuditFields(this.constructor.name, this.toJSON()));
+    return this.collection.create(sanitizeIdAndAuditFields('Configuration', this.toJSON()));
+  }
+
+  toJSON() {
+    return {
+      handlers: this.handlers,
+      jobs: this.jobs,
+      queues: this.queues,
+      slackRoles: this.slackRoles,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      updatedBy: this.updatedBy,
+    };
   }
 }
 

package/src/models/configuration/configuration.schema.js

@@ -10,18 +10,21 @@
  * governing permissions and limitations under the License.
  */
 
-/* c8 ignore start */
-
-import { isNonEmptyObject } from '@adobe/spacecat-shared-utils';
+/**
+ * Configuration Schema
+ *
+ * Unlike other entities, Configuration does not use ElectroDB and is stored in S3.
+ * Validation is handled by Joi schemas defined below.
+ */
 
 import Joi from 'joi';
 
-import SchemaBuilder from '../base/schema.builder.js';
 import Configuration from './configuration.model.js';
-import ConfigurationCollection from './configuration.collection.js';
-import { zeroPad } from '../../util/util.js';
 
-const handlerSchema = Joi.object().pattern(Joi.string(), Joi.object(
+const validJobGroups = Object.values(Configuration.JOB_GROUPS);
+const validJobIntervals = Object.values(Configuration.JOB_INTERVALS);
+
+export const handlerSchema = Joi.object().pattern(Joi.string(), Joi.object(
   {
     enabled: Joi.object({
       sites: Joi.array().items(Joi.string()),
@@ -44,17 +47,32 @@ const handlerSchema = Joi.object().pattern(Joi.string(), Joi.object(
   },
 )).unknown(true);
 
-const jobsSchema = Joi.array().required();
+export const jobSchema = Joi.object({
+  group: Joi.string().valid(...validJobGroups).required(),
+  type: Joi.string().required(),
+  interval: Joi.string().valid(...validJobIntervals).required(),
+}).unknown(true);
+
+export const jobsSchema = Joi.array().items(jobSchema).required();
+
+export const queueSchema = Joi.object().min(1).required();
 
-const queueSchema = Joi.object().required();
+export const slackRolesSchema = Joi.object().min(1);
 
-const configurationSchema = Joi.object({
-  version: Joi.number().required(),
+export const configurationSchema = Joi.object({
   queues: queueSchema,
   handlers: handlerSchema,
   jobs: jobsSchema,
+  slackRoles: slackRolesSchema,
 }).unknown(true);
 
+/**
+ * Validates a configuration object against the schema.
+ * @param {object} data - The configuration data to validate.
+ * @param {object} [schema=configurationSchema] - The Joi schema to validate against.
+ * @returns {object} The validated configuration data.
+ * @throws {Error} If validation fails.
+ */
 export const checkConfiguration = (data, schema = configurationSchema) => {
   const { error, value } = schema.validate(data);
 
@@ -64,50 +82,3 @@ export const checkConfiguration = (data, schema = configurationSchema) => {
 
   return value;
 };
-
-/*
-Schema Doc: https://electrodb.dev/en/modeling/schema/
-Attribute Doc: https://electrodb.dev/en/modeling/attributes/
-Indexes Doc: https://electrodb.dev/en/modeling/indexes/
- */
-
-const schema = new SchemaBuilder(Configuration, ConfigurationCollection)
-  .addAttribute('handlers', {
-    type: 'any',
-    validate: (value) => !value || checkConfiguration(value, handlerSchema),
-  })
-  .addAttribute('jobs', {
-    type: 'list',
-    items: {
-      type: 'map',
-      properties: {
-        group: { type: Object.values(Configuration.JOB_GROUPS), required: true },
-        type: { type: 'string', required: true },
-        interval: { type: Object.values(Configuration.JOB_INTERVALS), required: true },
-      },
-    },
-  })
-  .addAttribute('queues', {
-    type: 'any',
-    required: true,
-    validate: (value) => isNonEmptyObject(value),
-  })
-  .addAttribute('slackRoles', {
-    type: 'any',
-    validate: (value) => !value || isNonEmptyObject(value),
-  })
-  .addAttribute('version', {
-    type: 'number',
-    required: true,
-    readOnly: true,
-  })
-  .addAttribute('versionString', { // used for indexing/sorting
-    type: 'string',
-    required: true,
-    readOnly: true,
-    default: '0', // setting the default forces set() to run, to transform the version number to a string
-    set: (value, all) => zeroPad(all.version, 10),
-  })
-  .addAllIndex(['versionString']);
-
-export default schema.build();

package/src/models/configuration/index.d.ts

@@ -10,40 +10,52 @@
  * governing permissions and limitations under the License.
  */
 
-import type {
-  BaseCollection, BaseModel, Organization, Site,
-} from '../index';
+import type { Organization, Site } from '../index';
 
-export interface Configuration extends BaseModel {
+export interface Configuration {
   addHandler(type: string, handler: object): void;
-  disableHandlerForOrganization(type: string, organization: Organization): void;
+  disableHandlerForOrg(type: string, org: Organization): void;
   disableHandlerForSite(type: string, site: Site): void;
-  enableHandlerForOrganization(type: string, organization: Organization): void;
+  enableHandlerForOrg(type: string, org: Organization): void;
   enableHandlerForSite(type: string, site: Site): void;
   getConfigurationId(): string;
-  getEnabledSiteIdsForHandler(type: string): string[];
-  getEnabledAuditsForSite(site: Site): string[];
+  getCreatedAt(): string;
   getDisabledAuditsForSite(site: Site): string[];
+  getEnabledAuditsForSite(site: Site): string[];
+  getEnabledSiteIdsForHandler(type: string): string[];
   getHandler(type: string): object | undefined;
   getHandlers(): object;
-  getJobs(): object;
+  getId(): string;
+  getJobs(): object[];
   getQueues(): object;
   getSlackRoleMembersByRole(role: string): string[];
   getSlackRoles(): object;
-  getVersion(): number;
-  isHandlerEnabledForOrg(type: string, organization: Organization): boolean;
+  getUpdatedAt(): string;
+  getUpdatedBy(): string;
+  getVersion(): string;
+  isHandlerDependencyMetForOrg(type: string, org: Organization): true | string[];
+  isHandlerDependencyMetForSite(type: string, site: Site): true | string[];
+  isHandlerEnabledForOrg(type: string, org: Organization): boolean;
   isHandlerEnabledForSite(type: string, site: Site): boolean;
+  registerAudit(type: string, enabledByDefault?: boolean, interval?: string, productCodes?: string[]): void;
+  save(): Promise<Configuration>;
   setHandlers(handlers: object): void;
-  setJobs(jobs: object): void;
+  setJobs(jobs: object[]): void;
   setQueues(queues: object): void;
   setSlackRoles(slackRoles: object): void;
+  setUpdatedBy(updatedBy: string): void;
+  toJSON(): object;
+  unregisterAudit(type: string): void;
+  updateConfiguration(data: object): void;
   updateHandlerOrgs(type: string, orgId: string, enabled: boolean): void;
+  updateHandlerProperties(type: string, properties: object): void;
   updateHandlerSites(type: string, siteId: string, enabled: boolean): void;
-  registerAudit(type: string, enabledByDefault?: boolean, interval?: string, productCodes?: string[]): void;
-  unregisterAudit(type: string): void;
+  updateJob(type: string, properties: { interval?: string; group?: string }): void;
+  updateQueues(queues: object): void;
 }
 
-export interface ConfigurationCollection extends BaseCollection<Configuration> {
-  findByVersion(version: number): Promise<Configuration | null>;
+export interface ConfigurationCollection {
+  create(data: object): Promise<Configuration>;
+  findByVersion(version: string): Promise<Configuration | null>;
   findLatest(): Promise<Configuration | null>;
 }

package/src/models/index.js

@@ -13,6 +13,7 @@
 export * from './api-key/index.js';
 export * from './async-job/index.js';
 export * from './audit/index.js';
+export * from './audit-url/index.js';
 export * from './base/index.js';
 export * from './configuration/index.js';
 export * from './entitlement/index.js';

package/src/service/index.js

@@ -12,6 +12,7 @@
 
 import { DynamoDB } from '@aws-sdk/client-dynamodb';
 import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+import { S3Client } from '@aws-sdk/client-s3';
 import { Service } from 'electrodb';
 
 import { instrumentAWSClient } from '@adobe/spacecat-shared-utils';
@@ -65,10 +66,45 @@ const createElectroService = (client, config, log) => {
   );
 };
 
+/**
+ * Creates an S3 service configuration if bucket configuration is provided.
+ *
+ * @param {object} config - Configuration object
+ * @param {string} [config.s3Bucket] - S3 bucket name
+ * @param {string} [config.region] - AWS region
+ * @returns {{s3Client: S3Client, s3Bucket: string}|null} - S3 client and bucket or null
+ */
+const createS3Service = (config) => {
+  const { s3Bucket, region } = config;
+
+  if (!s3Bucket) {
+    return null;
+  }
+
+  const options = region ? { region } : {};
+  const s3Client = instrumentAWSClient(new S3Client(options));
+
+  return { s3Client, s3Bucket };
+};
+
+/**
+ * Creates a services dictionary containing all datastore services.
+ * Each collection can declare which service it needs via its DATASTORE_TYPE.
+ *
+ * @param {object} electroService - The ElectroDB service for DynamoDB operations
+ * @param {object} config - Configuration object
+ * @returns {object} Services dictionary with dynamo and s3 services
+ */
+const createServices = (electroService, config) => ({
+  dynamo: electroService,
+  s3: createS3Service(config),
+});
+
 /**
  * Creates a data access layer for interacting with DynamoDB using ElectroDB.
  *
- * @param {{tableNameData: string}} config - Configuration object containing table name
+ * @param {{tableNameData: string, s3Bucket?: string, region?: string}} config - Configuration
+ *   object containing table name and optional S3 configuration
  * @param {object} log - Logger instance, defaults to console
  * @param {DynamoDB} [client] - Optional custom DynamoDB client instance
  * @returns {object} Data access collections for interacting with entities
@@ -78,7 +114,8 @@ export const createDataAccess = (config, log = console, client = undefined) => {
 
   const rawClient = createRawClient(client);
   const electroService = createElectroService(rawClient, config, log);
-  const entityRegistry = new EntityRegistry(electroService, log);
+  const services = createServices(electroService, config);
+  const entityRegistry = new EntityRegistry(services, log);
 
   return entityRegistry.getCollections();
 };