@adobe/spacecat-shared-data-access 2.108.0 → 3.0.0

package/src/models/base/base.model.js

@@ -50,15 +50,15 @@ class BaseModel {
   /**
    * Constructs an instance of BaseModel.
    * @constructor
-   * @param {Object} electroService - The ElectroDB service used for managing entities.
+   * @param {Object} postgrestService - The PostgREST client used for managing entities.
    * @param {EntityRegistry} entityRegistry - The registry holding entities, their schema
    * and collection.
    * @param {Schema} schema - The schema for the entity.
    * @param {Object} record - The initial data for the entity instance.
    * @param {Object} log - A log for capturing logging information.
    */
-  constructor(electroService, entityRegistry, schema, record, log) {
-    this.electroService = electroService;
+  constructor(postgrestService, entityRegistry, schema, record, log) {
+    this.postgrestService = postgrestService;
     this.entityRegistry = entityRegistry;
     this.schema = schema;
     this.record = record;
@@ -68,9 +68,8 @@ class BaseModel {
     this.idName = entityNameToIdName(this.entityName);
 
     this.collection = entityRegistry.getCollection(schema.getCollectionName());
-    this.entity = electroService.entities[this.entityName];
 
-    this.patcher = new Patcher(this.entity, this.schema, this.record);
+    this.patcher = new Patcher(this.collection, this.schema, this.record);
 
     this._accessorCache = {};
 
@@ -283,7 +282,15 @@ class BaseModel {
 
       await Promise.all(removePromises);
 
-      await this.entity.remove(this.generateCompositeKeys()).go();
+      if (this.collection && typeof this.collection.removeByIndexKeys === 'function') {
+        await this.collection.removeByIndexKeys([this.generateCompositeKeys()]);
+      } else if (this.postgrestService?.entities?.[this.entityName]?.remove) {
+        await this.postgrestService.entities[this.entityName]
+          .remove(this.generateCompositeKeys())
+          .go();
+      } else {
+        throw new DataAccessError(`No remove strategy available for ${this.entityName}`, this);
+      }
 
       this.#invalidateCache();
 

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

@@ -18,6 +18,7 @@ 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 ConsumerCollection from '../consumer/consumer.collection.js';
 import ExperimentCollection from '../experiment/experiment.collection.js';
 import EntitlementCollection from '../entitlement/entitlement.collection.js';
 import FixEntityCollection from '../fix-entity/fix-entity.collection.js';
@@ -49,6 +50,7 @@ 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 AuditUrlSchema from '../audit-url/audit-url.schema.js';
+import ConsumerSchema from '../consumer/consumer.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';
@@ -84,16 +86,20 @@ import SentimentTopicSchema from '../sentiment-topic/sentiment-topic.schema.js';
 class EntityRegistry {
   static entities = {};
 
+  static defaultEntities = {};
+
   /**
    * Constructs an instance of EntityRegistry.
    * @constructor
    * @param {Object} services - Dictionary of services keyed by datastore type.
-   * @param {Object} services.dynamo - The ElectroDB service instance for DynamoDB operations.
+   * @param {Object} services.postgrest - The PostgREST client instance for Postgres operations.
    * @param {{s3Client: S3Client, s3Bucket: string}|null} [services.s3] - S3 service configuration.
+   * @param {Object} config - Configuration object containing environment-derived settings.
    * @param {Object} log - A logger for capturing and logging information.
    */
-  constructor(services, log) {
+  constructor(services, config, log) {
     this.services = services;
+    this.config = config;
     this.log = log;
     this.collections = new Map();
 
@@ -103,14 +109,14 @@ 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.
+   * PostgREST-based collections are initialized with the postgrest service.
    * Configuration is handled specially as it's a standalone S3-based collection.
    * @private
    */
   #initialize() {
-    // Initialize ElectroDB-based collections
+    // Initialize PostgREST-based collections
     Object.values(EntityRegistry.entities).forEach(({ collection: Collection, schema }) => {
-      const collection = new Collection(this.services.dynamo, this, schema, this.log);
+      const collection = new Collection(this.services.postgrest, this, schema, this.log);
       this.collections.set(Collection.COLLECTION_NAME, collection);
     });
 
@@ -142,6 +148,14 @@ class EntityRegistry {
     return collections;
   }
 
+  /**
+   * Returns the camelCase names of all registered entities (including Configuration).
+   * @returns {string[]} - An array of entity names.
+   */
+  getEntityNames() {
+    return [...Object.keys(this.constructor.entities), 'configuration'];
+  }
+
   static getEntities() {
     return Object.keys(this.entities).reduce((acc, key) => {
       acc[key] = this.entities[key].schema.toElectroDBSchema();
@@ -152,6 +166,10 @@ class EntityRegistry {
   static registerEntity(schema, collection) {
     this.entities[decapitalize(schema.getEntityName())] = { schema, collection };
   }
+
+  static resetEntities() {
+    this.entities = { ...this.defaultEntities };
+  }
 }
 
 // Register ElectroDB-based entities only (Configuration is handled separately)
@@ -159,6 +177,7 @@ EntityRegistry.registerEntity(ApiKeySchema, ApiKeyCollection);
 EntityRegistry.registerEntity(AsyncJobSchema, AsyncJobCollection);
 EntityRegistry.registerEntity(AuditSchema, AuditCollection);
 EntityRegistry.registerEntity(AuditUrlSchema, AuditUrlCollection);
+EntityRegistry.registerEntity(ConsumerSchema, ConsumerCollection);
 EntityRegistry.registerEntity(EntitlementSchema, EntitlementCollection);
 EntityRegistry.registerEntity(FixEntitySchema, FixEntityCollection);
 EntityRegistry.registerEntity(FixEntitySuggestionSchema, FixEntitySuggestionCollection);
@@ -185,5 +204,6 @@ EntityRegistry.registerEntity(TrialUserActivitySchema, TrialUserActivityCollecti
 EntityRegistry.registerEntity(PageCitabilitySchema, PageCitabilityCollection);
 EntityRegistry.registerEntity(SentimentGuidelineSchema, SentimentGuidelineCollection);
 EntityRegistry.registerEntity(SentimentTopicSchema, SentimentTopicCollection);
+EntityRegistry.defaultEntities = { ...EntityRegistry.entities };
 
 export default EntityRegistry;

package/src/models/base/schema.builder.js

@@ -36,6 +36,7 @@ const DEFAULT_SERVICE_NAME = 'SpaceCat';
  */
 const ID_ATTRIBUTE_DATA = {
   type: 'string',
+  postgrestField: 'id',
   required: true,
   readOnly: true,
   // https://electrodb.dev/en/modeling/attributes/#default
@@ -215,6 +216,7 @@ class SchemaBuilder {
 
     this.addAttribute('recordExpiresAt', {
       type: 'number',
+      postgrestIgnore: true,
       required: true,
       readOnly: true,
       default: () => Math.floor(Date.now() / 1000) + ttlInDays * 24 * 60 * 60,

package/src/models/base/schema.js

@@ -156,6 +156,17 @@ class Schema {
     return result;
   }
 
+  // Internal helper: v3 schemas use `composite` keys (legacy Electro used `facets`).
+  static #getKeyParts(indexPart) {
+    if (Array.isArray(indexPart?.composite)) {
+      return indexPart.composite;
+    }
+    if (Array.isArray(indexPart?.facets)) {
+      return indexPart.facets;
+    }
+    return [];
+  }
+
   getIndexByName(indexName) {
     return this.indexes[indexName];
   }
@@ -167,10 +178,10 @@ class Schema {
       const subKeyNames = sortKeys.slice(0, length);
       const index = Object.values(this.indexes).find((candidate) => {
         const { pk, sk } = candidate;
-        const allKeys = [...(pk?.facets || []), ...(sk?.facets || [])];
+        const allKeys = [...Schema.#getKeyParts(pk), ...Schema.#getKeyParts(sk)];
 
         // check if all keys in the index are in the sort keys
-        const pkKeys = Array.isArray(pk?.facets) ? pk.facets : [];
+        const pkKeys = Schema.#getKeyParts(pk);
         return pkKeys.every((key) => subKeyNames.includes(key))
           && subKeyNames.every((key) => allKeys.includes(key));
       });
@@ -246,8 +257,8 @@ class Schema {
       return [];
     }
 
-    const pkKeys = Array.isArray(index.pk?.facets) ? index.pk.facets : [];
-    const skKeys = Array.isArray(index.sk?.facets) ? index.sk.facets : [];
+    const pkKeys = Schema.#getKeyParts(index.pk);
+    const skKeys = Schema.#getKeyParts(index.sk);
 
     return [...pkKeys, ...skKeys];
   }

package/src/models/consumer/consumer.collection.js

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { hasText, isNonEmptyArray } from '@adobe/spacecat-shared-utils';
+
+import BaseCollection from '../base/base.collection.js';
+import ValidationError from '../../errors/validation.error.js';
+import Consumer from './consumer.model.js';
+
+/**
+ * ConsumerCollection - A collection class responsible for managing Consumer entities.
+ * Extends the BaseCollection to provide specific methods for interacting with Consumer records.
+ *
+ * @class ConsumerCollection
+ * @extends BaseCollection
+ */
+class ConsumerCollection extends BaseCollection {
+  static COLLECTION_NAME = 'ConsumerCollection';
+
+  #validCapabilities = null;
+
+  /**
+   * Returns the set of valid capabilities, generated dynamically from all registered
+   * entity names and operations. Computed once and cached.
+   * Format: entityName:operation (e.g. "site:read", "organization:write")
+   * @returns {Set<string>} - The set of valid capability strings.
+   * @private
+   */
+  #getValidCapabilities() {
+    if (!this.#validCapabilities) {
+      const entityNames = this.entityRegistry.getEntityNames();
+      this.#validCapabilities = new Set(
+        entityNames.flatMap(
+          (name) => Consumer.CAPABILITIES.map((op) => `${name}:${op}`),
+        ),
+      );
+    }
+    return this.#validCapabilities;
+  }
+
+  /**
+   * Validates that all capabilities in the given array are known entity:operation pairs.
+   * Called during both create() and save() to prevent capability escalation.
+   * @param {string[]} capabilities - The capabilities to validate.
+   * @throws {ValidationError} - Throws if any capability is not recognized.
+   */
+  validateCapabilities(capabilities) {
+    if (!isNonEmptyArray(capabilities)) {
+      return;
+    }
+
+    const validCapabilities = this.#getValidCapabilities();
+    const invalid = capabilities.filter((cap) => !validCapabilities.has(cap));
+
+    if (invalid.length > 0) {
+      throw new ValidationError(
+        `Invalid capabilities: [${invalid.join(', ')}]`,
+        this,
+      );
+    }
+  }
+
+  /**
+   * Validates that the given imsOrgId is in the allowed list from config.
+   * @param {string} imsOrgId - The IMS Org ID to validate.
+   * @throws {ValidationError} - Throws if the imsOrgId is not in the allowed list.
+   * @private
+   */
+  #validateImsOrgId(imsOrgId) {
+    const { s2sAllowedImsOrgIds } = this.entityRegistry.config;
+
+    if (!isNonEmptyArray(s2sAllowedImsOrgIds)) {
+      throw new ValidationError(
+        'S2S_ALLOWED_IMS_ORG_IDS is not configured. Cannot create a consumer without an allowlist.',
+        this,
+      );
+    }
+
+    if (!s2sAllowedImsOrgIds.includes(imsOrgId)) {
+      throw new ValidationError(
+        `The imsOrgId "${imsOrgId}" is not in the list of allowed IMS Org IDs`,
+        this,
+      );
+    }
+  }
+
+  /**
+   * Validates that no existing consumer has the same clientId.
+   * Uses findByClientId() to enforce global uniqueness, which is correct because IMS
+   * client_ids are globally unique per integration in Adobe Developer Console regardless
+   * of the owning org. The composite index ['clientId', 'imsOrgId'] exists for efficient
+   * scoped lookups, not to imply per-org uniqueness.
+   * @param {string} clientId - The clientId to check.
+   * @throws {ValidationError} - Throws if a consumer with this clientId already exists.
+   * @private
+   */
+  async #validateClientIdUniqueness(clientId) {
+    if (!hasText(clientId)) {
+      throw new ValidationError(
+        'clientId is required to create a consumer',
+        this,
+      );
+    }
+
+    const existing = await this.findByClientId(clientId);
+    if (existing) {
+      throw new ValidationError(
+        `A consumer with clientId "${clientId}" already exists`,
+        this,
+      );
+    }
+  }
+
+  /**
+   * Creates a new Consumer entity after validating imsOrgId, capabilities, and clientId uniqueness.
+   * @param {Object} item - The data for the entity to be created.
+   * @param {Object} [options] - Additional options for the creation process.
+   * @returns {Promise<BaseModel>} - A promise that resolves to the created model instance.
+   * @throws {ValidationError} - Throws if validation fails.
+   */
+  async create(item, options = {}) {
+    this.#validateImsOrgId(item?.imsOrgId);
+    this.validateCapabilities(item?.capabilities);
+    await this.#validateClientIdUniqueness(item?.clientId);
+    return super.create(item, options);
+  }
+
+  /**
+   * Bulk creation is not supported for Consumer entities.
+   * All consumers must be created individually via create() to enforce
+   * imsOrgId allowlist, capability validation, and clientId uniqueness checks.
+   * @throws {Error} Always throws — use create() instead.
+   */
+  // eslint-disable-next-line class-methods-use-this, no-unused-vars
+  async createMany(_items, _parent) {
+    throw new Error('createMany is not supported for Consumer. Use create() instead.');
+  }
+}
+
+export default ConsumerCollection;

package/src/models/consumer/consumer.model.js

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { isIsoDate } from '@adobe/spacecat-shared-utils';
+
+import BaseModel from '../base/base.model.js';
+
+/**
+ * Consumer - A class representing a Consumer entity.
+ * Provides methods to access and manipulate Consumer-specific data.
+ *
+ * @class Consumer
+ * @extends BaseModel
+ */
+class Consumer extends BaseModel {
+  static ENTITY_NAME = 'Consumer';
+
+  static STATUS = {
+    ACTIVE: 'ACTIVE',
+    SUSPENDED: 'SUSPENDED',
+    REVOKED: 'REVOKED',
+  };
+
+  /**
+   * Checks whether this consumer has been revoked.
+   * @returns {boolean} - True if the consumer has been revoked.
+   */
+  isRevoked() {
+    return this.getStatus() === Consumer.STATUS.REVOKED
+      || (isIsoDate(this.getRevokedAt()) && new Date(this.getRevokedAt()) <= new Date());
+  }
+
+  /**
+   * Saves the consumer after validating capabilities against the allowlist.
+   * Prevents capability escalation via setCapabilities() + save().
+   * @async
+   * @returns {Promise<Consumer>} - The saved consumer instance.
+   * @throws {ValidationError} - If capabilities are invalid.
+   */
+  async save() {
+    this.collection.validateCapabilities(this.getCapabilities());
+    return super.save();
+  }
+
+  static CAPABILITIES = ['read', 'write', 'delete'];
+
+  static IMS_ORG_ID_REGEX = /^[a-z0-9]{24}@AdobeOrg$/i;
+
+  static TECHNICAL_ACCOUNT_ID_REGEX = /^[a-z0-9]{24}@techacct\.adobe\.com$/i;
+}
+
+export default Consumer;

package/src/models/consumer/consumer.schema.js

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { isIsoDate } from '@adobe/spacecat-shared-utils';
+
+import SchemaBuilder from '../base/schema.builder.js';
+import Consumer from './consumer.model.js';
+import ConsumerCollection from './consumer.collection.js';
+
+/*
+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(Consumer, ConsumerCollection)
+  .addAttribute('clientId', {
+    type: 'string',
+    required: true,
+    readOnly: true,
+  })
+  .addAttribute('technicalAccountId', {
+    type: 'string',
+    required: true,
+    readOnly: true,
+    validate: (value) => Consumer.TECHNICAL_ACCOUNT_ID_REGEX.test(value),
+  })
+  .addAttribute('consumerName', {
+    type: 'string',
+    required: true,
+  })
+  .addAttribute('status', {
+    type: Object.values(Consumer.STATUS),
+    required: true,
+  })
+  .addAttribute('capabilities', {
+    type: 'list',
+    required: true,
+    items: {
+      type: 'string',
+    },
+  })
+  .addAttribute('revokedAt', {
+    type: 'string',
+    validate: (value) => !value || isIsoDate(value),
+  })
+  .addAttribute('imsOrgId', {
+    type: 'string',
+    required: true,
+    readOnly: true,
+    validate: (value) => Consumer.IMS_ORG_ID_REGEX.test(value),
+  })
+  .addAllIndex(['imsOrgId'])
+  .addAllIndex(['clientId', 'imsOrgId']);
+
+export default schema.build();

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import type { BaseCollection, BaseModel } from '../index';
+
+export type ConsumerStatus = 'ACTIVE' | 'SUSPENDED' | 'REVOKED';
+
+export interface Consumer extends BaseModel {
+  getClientId(): string;
+  getTechnicalAccountId(): string;
+  getConsumerName(): string;
+  getStatus(): ConsumerStatus;
+  getCapabilities(): string[];
+  getImsOrgId(): string;
+  getRevokedAt(): string | undefined;
+  isRevoked(): boolean;
+  setConsumerName(consumerName: string): Consumer;
+  setStatus(status: ConsumerStatus): Consumer;
+  setCapabilities(capabilities: string[]): Consumer;
+  setRevokedAt(revokedAt: string): Consumer;
+}
+
+export interface ConsumerCollection extends BaseCollection<Consumer> {
+  allByImsOrgId(imsOrgId: string): Promise<Consumer[]>;
+  allByClientId(clientId: string): Promise<Consumer[]>;
+  allByClientIdAndImsOrgId(clientId: string, imsOrgId: string): Promise<Consumer[]>;
+  findByImsOrgId(imsOrgId: string): Promise<Consumer | null>;
+  findByClientId(clientId: string): Promise<Consumer | null>;
+  findByClientIdAndImsOrgId(clientId: string, imsOrgId: string): Promise<Consumer | null>;
+}

package/src/models/consumer/index.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import Consumer from './consumer.model.js';
+import ConsumerCollection from './consumer.collection.js';
+
+export {
+  Consumer,
+  ConsumerCollection,
+};

package/src/models/fix-entity-suggestion/fix-entity-suggestion.model.js

@@ -25,6 +25,21 @@ class FixEntitySuggestion extends BaseModel {
 
   static DEFAULT_UPDATED_BY = 'spacecat';
 
+  getId() {
+    const id = super.getId();
+    if (id) {
+      return id;
+    }
+
+    const suggestionId = this.getSuggestionId();
+    const fixEntityId = this.getFixEntityId();
+    if (suggestionId && fixEntityId) {
+      return `${suggestionId}#${fixEntityId}`;
+    }
+
+    return undefined;
+  }
+
   /**
    * Generates the composite keys for the FixEntitySuggestion model.
    * @returns {Object} - The composite keys.

package/src/models/fix-entity-suggestion/fix-entity-suggestion.schema.js

@@ -23,6 +23,17 @@ Indexes Doc: https://electrodb.dev/en/modeling/indexes/
 const schema = new SchemaBuilder(FixEntitySuggestion, FixEntitySuggestionCollection)
   .withPrimaryPartitionKeys(['suggestionId'])
   .withPrimarySortKeys(['fixEntityId'])
+  .addAttribute('fixEntitySuggestionId', {
+    type: 'string',
+    required: false,
+    readOnly: true,
+    postgrestIgnore: true,
+  })
+  .addAttribute('updatedBy', {
+    type: 'string',
+    required: false,
+    postgrestIgnore: true,
+  })
   .addReference('belongs_to', 'FixEntity')
   .addReference('belongs_to', 'Suggestion')
   .addAttribute('opportunityId', {
@@ -38,6 +49,7 @@ const schema = new SchemaBuilder(FixEntitySuggestion, FixEntitySuggestionCollect
   .addAttribute('fixEntityCreatedDate', {
     type: 'string',
     readOnly: true,
+    postgrestIgnore: true,
     watch: ['fixEntityCreatedAt'],
     set: (_, { fixEntityCreatedAt }) => (fixEntityCreatedAt ? fixEntityCreatedAt.split('T')[0] : undefined),
   })

package/src/models/index.d.ts

@@ -14,6 +14,7 @@ export type * from './audit';
 export type * from './async-job';
 export type * from './configuration';
 export type * from './base';
+export type * from './consumer';
 export type * from './fix-entity';
 export type * from './fix-entity-suggestion';
 export type * from './experiment';

package/src/models/index.js

@@ -16,6 +16,7 @@ export * from './audit/index.js';
 export * from './audit-url/index.js';
 export * from './base/index.js';
 export * from './configuration/index.js';
+export * from './consumer/index.js';
 export * from './entitlement/index.js';
 export * from './fix-entity/index.js';
 export * from './fix-entity-suggestion/index.js';

package/src/models/key-event/key-event.collection.js

@@ -11,6 +11,7 @@
  */
 
 import BaseCollection from '../base/base.collection.js';
+import DataAccessError from '../../errors/data-access.error.js';
 
 /**
  * KeyEventCollection - A collection class responsible for managing KeyEvent entities.
@@ -22,7 +23,28 @@ import BaseCollection from '../base/base.collection.js';
 class KeyEventCollection extends BaseCollection {
   static COLLECTION_NAME = 'KeyEventCollection';
 
-  // add custom methods here
+  #throwDeprecated() {
+    throw new DataAccessError(
+      'KeyEvent is deprecated in data-access v3. Use Audit/LatestAudit and related Postgres-backed entities instead.',
+      this,
+    );
+  }
+
+  async all() { return this.#throwDeprecated(); }
+
+  async allByIndexKeys() { return this.#throwDeprecated(); }
+
+  async findById() { return this.#throwDeprecated(); }
+
+  async findByIndexKeys() { return this.#throwDeprecated(); }
+
+  async create() { return this.#throwDeprecated(); }
+
+  async createMany() { return this.#throwDeprecated(); }
+
+  async removeByIds() { return this.#throwDeprecated(); }
+
+  async removeByIndexKeys() { return this.#throwDeprecated(); }
 }
 
 export default KeyEventCollection;