@decaf-ts/db-decorators 0.6.1 → 0.6.3

package/lib/esm/repository/BaseRepository.js

@@ -1,15 +1,118 @@
-import { enforceDBDecorators } from "./utils";
-import { OperationKeys } from "../operations/constants";
-import { InternalError } from "./errors";
-import { wrapMethodWithContext } from "./wrappers";
-import { findPrimaryKey } from "../identity/utils";
-import { Context } from "./Context";
+import { enforceDBDecorators } from "./utils.js";
+import { OperationKeys } from "./../operations/constants.js";
+import { InternalError } from "./errors.js";
+import { wrapMethodWithContext } from "./wrappers.js";
+import { findPrimaryKey } from "./../identity/utils.js";
+import { Context } from "./Context.js";
+/**
+ * @description Base repository implementation providing CRUD operations for models.
+ * @summary The BaseRepository class serves as a foundation for repository implementations, providing
+ * abstract and concrete methods for creating, reading, updating, and deleting model instances.
+ * It handles operation lifecycles including prefix and suffix operations, and enforces decorators.
+ * @template M - The model type extending Model
+ * @template F - The repository flags type, defaults to RepositoryFlags
+ * @template C - The context type, defaults to Context<F>
+ * @param {Constructor<M>} clazz - The constructor for the model class
+ * @class BaseRepository
+ * @example
+ * class UserModel extends Model {
+ *   @id()
+ *   id: string;
+ *
+ *   @required()
+ *   name: string;
+ * }
+ *
+ * class UserRepository extends BaseRepository<UserModel> {
+ *   constructor() {
+ *     super(UserModel);
+ *   }
+ *
+ *   async create(model: UserModel): Promise<UserModel> {
+ *     // Implementation
+ *     return model;
+ *   }
+ *
+ *   async read(key: string): Promise<UserModel> {
+ *     // Implementation
+ *     return new UserModel({ id: key, name: 'User' });
+ *   }
+ *
+ *   async update(model: UserModel): Promise<UserModel> {
+ *     // Implementation
+ *     return model;
+ *   }
+ *
+ *   async delete(key: string): Promise<UserModel> {
+ *     // Implementation
+ *     const model = await this.read(key);
+ *     return model;
+ *   }
+ * }
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant R as Repository
+ *   participant P as Prefix Methods
+ *   participant D as Database
+ *   participant S as Suffix Methods
+ *   participant V as Validators/Decorators
+ *
+ *   Note over C,V: Create Operation
+ *   C->>R: create(model)
+ *   R->>P: createPrefix(model)
+ *   P->>V: enforceDBDecorators(ON)
+ *   P->>D: Database operation
+ *   D->>S: createSuffix(model)
+ *   S->>V: enforceDBDecorators(AFTER)
+ *   S->>C: Return model
+ *
+ *   Note over C,V: Read Operation
+ *   C->>R: read(key)
+ *   R->>P: readPrefix(key)
+ *   P->>V: enforceDBDecorators(ON)
+ *   P->>D: Database operation
+ *   D->>S: readSuffix(model)
+ *   S->>V: enforceDBDecorators(AFTER)
+ *   S->>C: Return model
+ *
+ *   Note over C,V: Update Operation
+ *   C->>R: update(model)
+ *   R->>P: updatePrefix(model)
+ *   P->>V: enforceDBDecorators(ON)
+ *   P->>D: Database operation
+ *   D->>S: updateSuffix(model)
+ *   S->>V: enforceDBDecorators(AFTER)
+ *   S->>C: Return model
+ *
+ *   Note over C,V: Delete Operation
+ *   C->>R: delete(key)
+ *   R->>P: deletePrefix(key)
+ *   P->>V: enforceDBDecorators(ON)
+ *   P->>D: Database operation
+ *   D->>S: deleteSuffix(model)
+ *   S->>V: enforceDBDecorators(AFTER)
+ *   S->>C: Return model
+ */
 export class BaseRepository {
+    /**
+     * @description Gets the model class constructor.
+     * @summary Retrieves the constructor for the model class associated with this repository.
+     * Throws an error if no class definition is found.
+     * @return {Constructor<M>} The constructor for the model class
+     */
     get class() {
         if (!this._class)
             throw new InternalError(`No class definition found for this repository`);
         return this._class;
     }
+    /**
+     * @description Gets the primary key property name of the model.
+     * @summary Retrieves the name of the property that serves as the primary key for the model.
+     * If not already determined, it finds the primary key using the model's decorators.
+     * @return The name of the primary key property
+     */
     get pk() {
         if (!this._pk) {
             const { id, props } = findPrimaryKey(new this.class());
@@ -18,6 +121,12 @@ export class BaseRepository {
         }
         return this._pk;
     }
+    /**
+     * @description Gets the primary key properties.
+     * @summary Retrieves the properties associated with the primary key of the model.
+     * If not already determined, it triggers the pk getter to find the primary key properties.
+     * @return {any} The properties of the primary key
+     */
     get pkProps() {
         if (!this._pkProps) {
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -35,19 +144,53 @@ export class BaseRepository {
             wrapMethodWithContext(self, self[name + "Prefix"], m, self[name + "Suffix"]);
         });
     }
+    /**
+     * @description Creates multiple model instances in the repository.
+     * @summary Persists multiple model instances to the underlying data store by calling
+     * the create method for each model in the array.
+     * @param {M[]} models - The array of model instances to create
+     * @param {any[]} args - Additional arguments for the create operation
+     * @return {Promise<M[]>} A promise that resolves to an array of created model instances
+     */
     async createAll(models, ...args) {
         return Promise.all(models.map((m) => this.create(m, ...args)));
     }
+    /**
+     * @description Prepares a model for creation and executes pre-creation operations.
+     * @summary Processes a model before it is created in the data store. This includes
+     * creating a context, instantiating a new model instance, and enforcing any decorators
+     * that should be applied before creation.
+     * @param {M} model - The model instance to prepare for creation
+     * @param {any[]} args - Additional arguments for the create operation
+     * @return A promise that resolves to an array containing the prepared model and context arguments
+     */
     async createPrefix(model, ...args) {
         const contextArgs = await Context.args(OperationKeys.CREATE, this.class, args);
         model = new this.class(model);
         await enforceDBDecorators(this, contextArgs.context, model, OperationKeys.CREATE, OperationKeys.ON);
         return [model, ...contextArgs.args];
     }
+    /**
+     * @description Processes a model after creation and executes post-creation operations.
+     * @summary Finalizes a model after it has been created in the data store. This includes
+     * enforcing any decorators that should be applied after creation.
+     * @param {M} model - The model instance that was created
+     * @param {C} context - The context for the operation
+     * @return {Promise<M>} A promise that resolves to the processed model instance
+     */
     async createSuffix(model, context) {
         await enforceDBDecorators(this, context, model, OperationKeys.CREATE, OperationKeys.AFTER);
         return model;
     }
+    /**
+     * @description Prepares multiple models for creation and executes pre-creation operations.
+     * @summary Processes multiple models before they are created in the data store. This includes
+     * creating a context, instantiating new model instances, and enforcing any decorators
+     * that should be applied before creation for each model.
+     * @param {M[]} models - The array of model instances to prepare for creation
+     * @param {any[]} args - Additional arguments for the create operation
+     * @return  A promise that resolves to an array containing the prepared models and context arguments
+     */
     async createAllPrefix(models, ...args) {
         const contextArgs = await Context.args(OperationKeys.CREATE, this.class, args);
         await Promise.all(models.map(async (m) => {
@@ -57,17 +200,50 @@ export class BaseRepository {
         }));
         return [models, ...contextArgs.args];
     }
+    /**
+     * @description Processes multiple models after creation and executes post-creation operations.
+     * @summary Finalizes multiple models after they have been created in the data store. This includes
+     * enforcing any decorators that should be applied after creation for each model.
+     * @param {M[]} models - The array of model instances that were created
+     * @param {C} context - The context for the operation
+     * @return {Promise<M[]>} A promise that resolves to the array of processed model instances
+     */
     async createAllSuffix(models, context) {
         await Promise.all(models.map((m) => enforceDBDecorators(this, context, m, OperationKeys.CREATE, OperationKeys.AFTER)));
         return models;
     }
+    /**
+     * @description Retrieves multiple model instances from the repository by their primary keys.
+     * @summary Fetches multiple model instances from the underlying data store using their primary keys
+     * by calling the read method for each key in the array.
+     * @param {string[] | number[]} keys - The array of primary keys of the models to retrieve
+     * @param {any[]} args - Additional arguments for the read operation
+     * @return {Promise<M[]>} A promise that resolves to an array of retrieved model instances
+     */
     async readAll(keys, ...args) {
         return await Promise.all(keys.map((id) => this.read(id, ...args)));
     }
+    /**
+     * @description Processes a model after retrieval and executes post-read operations.
+     * @summary Finalizes a model after it has been retrieved from the data store. This includes
+     * enforcing any decorators that should be applied after reading.
+     * @param {M} model - The model instance that was retrieved
+     * @param {C} context - The context for the operation
+     * @return {Promise<M>} A promise that resolves to the processed model instance
+     */
     async readSuffix(model, context) {
         await enforceDBDecorators(this, context, model, OperationKeys.READ, OperationKeys.AFTER);
         return model;
     }
+    /**
+     * @description Prepares for reading a model and executes pre-read operations.
+     * @summary Processes a key before a model is read from the data store. This includes
+     * creating a context, instantiating a new model instance with the key, and enforcing any decorators
+     * that should be applied before reading.
+     * @param {string} key - The primary key of the model to read
+     * @param {any[]} args - Additional arguments for the read operation
+     * @return A promise that resolves to an array containing the key and context arguments
+     */
     async readPrefix(key, ...args) {
         const contextArgs = await Context.args(OperationKeys.READ, this.class, args);
         const model = new this.class();
@@ -75,6 +251,15 @@ export class BaseRepository {
         await enforceDBDecorators(this, contextArgs.context, model, OperationKeys.READ, OperationKeys.ON);
         return [key, ...contextArgs.args];
     }
+    /**
+     * @description Prepares for reading multiple models and executes pre-read operations.
+     * @summary Processes multiple keys before models are read from the data store. This includes
+     * creating a context, instantiating new model instances with the keys, and enforcing any decorators
+     * that should be applied before reading for each key.
+     * @param {string[] | number[]} keys - The array of primary keys of the models to read
+     * @param {any[]} args - Additional arguments for the read operation
+     * @return A promise that resolves to an array containing the keys and context arguments
+     */
     async readAllPrefix(keys, ...args) {
         const contextArgs = await Context.args(OperationKeys.READ, this.class, args);
         await Promise.all(keys.map(async (k) => {
@@ -84,17 +269,50 @@ export class BaseRepository {
         }));
         return [keys, ...contextArgs.args];
     }
+    /**
+     * @description Processes multiple models after retrieval and executes post-read operations.
+     * @summary Finalizes multiple models after they have been retrieved from the data store. This includes
+     * enforcing any decorators that should be applied after reading for each model.
+     * @param {M[]} models - The array of model instances that were retrieved
+     * @param {C} context - The context for the operation
+     * @return {Promise<M[]>} A promise that resolves to the array of processed model instances
+     */
     async readAllSuffix(models, context) {
         await Promise.all(models.map((m) => enforceDBDecorators(this, context, m, OperationKeys.READ, OperationKeys.AFTER)));
         return models;
     }
+    /**
+     * @description Updates multiple model instances in the repository.
+     * @summary Updates multiple model instances in the underlying data store by calling
+     * the update method for each model in the array.
+     * @param {M[]} models - The array of model instances to update
+     * @param {any[]} args - Additional arguments for the update operation
+     * @return {Promise<M[]>} A promise that resolves to an array of updated model instances
+     */
     async updateAll(models, ...args) {
         return Promise.all(models.map((m) => this.update(m, ...args)));
     }
+    /**
+     * @description Processes a model after update and executes post-update operations.
+     * @summary Finalizes a model after it has been updated in the data store. This includes
+     * enforcing any decorators that should be applied after updating.
+     * @param {M} model - The model instance that was updated
+     * @param {C} context - The context for the operation
+     * @return {Promise<M>} A promise that resolves to the processed model instance
+     */
     async updateSuffix(model, context) {
         await enforceDBDecorators(this, context, model, OperationKeys.UPDATE, OperationKeys.AFTER);
         return model;
     }
+    /**
+     * @description Prepares a model for update and executes pre-update operations.
+     * @summary Processes a model before it is updated in the data store. This includes
+     * creating a context, validating the primary key, retrieving the existing model,
+     * and enforcing any decorators that should be applied before updating.
+     * @param {M} model - The model instance to prepare for update
+     * @param {any[]} args - Additional arguments for the update operation
+     * @return A promise that resolves to an array containing the prepared model and context arguments
+     */
     async updatePrefix(model, ...args) {
         const contextArgs = await Context.args(OperationKeys.UPDATE, this.class, args);
         const id = model[this.pk];
@@ -104,6 +322,15 @@ export class BaseRepository {
         await enforceDBDecorators(this, contextArgs.context, model, OperationKeys.UPDATE, OperationKeys.ON, oldModel);
         return [model, ...contextArgs.args];
     }
+    /**
+     * @description Prepares multiple models for update and executes pre-update operations.
+     * @summary Processes multiple models before they are updated in the data store. This includes
+     * creating a context, instantiating new model instances, and enforcing any decorators
+     * that should be applied before updating for each model.
+     * @param {M[]} models - The array of model instances to prepare for update
+     * @param {any[]} args - Additional arguments for the update operation
+     * @return A promise that resolves to an array containing the prepared models and context arguments
+     */
     async updateAllPrefix(models, ...args) {
         const contextArgs = await Context.args(OperationKeys.UPDATE, this.class, args);
         await Promise.all(models.map((m) => {
@@ -113,23 +340,65 @@ export class BaseRepository {
         }));
         return [models, ...contextArgs.args];
     }
+    /**
+     * @description Processes multiple models after update and executes post-update operations.
+     * @summary Finalizes multiple models after they have been updated in the data store. This includes
+     * enforcing any decorators that should be applied after updating for each model.
+     * @param {M[]} models - The array of model instances that were updated
+     * @param {C} context - The context for the operation
+     * @return {Promise<M[]>} A promise that resolves to the array of processed model instances
+     */
     async updateAllSuffix(models, context) {
         await Promise.all(models.map((m) => enforceDBDecorators(this, context, m, OperationKeys.UPDATE, OperationKeys.AFTER)));
         return models;
     }
+    /**
+     * @description Deletes multiple model instances from the repository by their primary keys.
+     * @summary Removes multiple model instances from the underlying data store using their primary keys
+     * by calling the delete method for each key in the array.
+     * @param {string[] | number[]} keys - The array of primary keys of the models to delete
+     * @param {any[]} args - Additional arguments for the delete operation
+     * @return {Promise<M[]>} A promise that resolves to an array of deleted model instances
+     */
     async deleteAll(keys, ...args) {
         return Promise.all(keys.map((k) => this.delete(k, ...args)));
     }
+    /**
+     * @description Processes a model after deletion and executes post-delete operations.
+     * @summary Finalizes a model after it has been deleted from the data store. This includes
+     * enforcing any decorators that should be applied after deletion.
+     * @param {M} model - The model instance that was deleted
+     * @param {C} context - The context for the operation
+     * @return {Promise<M>} A promise that resolves to the processed model instance
+     */
     async deleteSuffix(model, context) {
         await enforceDBDecorators(this, context, model, OperationKeys.DELETE, OperationKeys.AFTER);
         return model;
     }
+    /**
+     * @description Prepares for deleting a model and executes pre-delete operations.
+     * @summary Processes a key before a model is deleted from the data store. This includes
+     * creating a context, retrieving the model to be deleted, and enforcing any decorators
+     * that should be applied before deletion.
+     * @param {any} key - The primary key of the model to delete
+     * @param {any[]} args - Additional arguments for the delete operation
+     * @return A promise that resolves to an array containing the key and context arguments
+     */
     async deletePrefix(key, ...args) {
         const contextArgs = await Context.args(OperationKeys.DELETE, this.class, args);
         const model = await this.read(key, ...contextArgs.args);
         await enforceDBDecorators(this, contextArgs.context, model, OperationKeys.DELETE, OperationKeys.ON);
         return [key, ...contextArgs.args];
     }
+    /**
+     * @description Prepares for deleting multiple models and executes pre-delete operations.
+     * @summary Processes multiple keys before models are deleted from the data store. This includes
+     * creating a context, retrieving the models to be deleted, and enforcing any decorators
+     * that should be applied before deletion for each model.
+     * @param {string[] | number[]} keys - The array of primary keys of the models to delete
+     * @param {any[]} args - Additional arguments for the delete operation
+     * @return A promise that resolves to an array containing the keys and context arguments
+     */
     async deleteAllPrefix(keys, ...args) {
         const contextArgs = await Context.args(OperationKeys.DELETE, this.class, args);
         const models = await this.readAll(keys, ...contextArgs.args);
@@ -138,10 +407,26 @@ export class BaseRepository {
         }));
         return [keys, ...contextArgs.args];
     }
+    /**
+     * @description Processes multiple models after deletion and executes post-delete operations.
+     * @summary Finalizes multiple models after they have been deleted from the data store. This includes
+     * enforcing any decorators that should be applied after deletion for each model.
+     * @param {M[]} models - The array of model instances that were deleted
+     * @param {C} context - The context for the operation
+     * @return {Promise<M[]>} A promise that resolves to the array of processed model instances
+     */
     async deleteAllSuffix(models, context) {
         await Promise.all(models.map((m) => enforceDBDecorators(this, context, m, OperationKeys.DELETE, OperationKeys.AFTER)));
         return models;
     }
+    /**
+     * @description Merges two model instances into a new instance.
+     * @summary Creates a new model instance by combining properties from an old model and a new model.
+     * Properties from the new model override properties from the old model if they are defined.
+     * @param {M} oldModel - The original model instance
+     * @param {M} model - The new model instance with updated properties
+     * @return {M} A new model instance with merged properties
+     */
     merge(oldModel, model) {
         const extract = (model) => Object.entries(model).reduce((accum, [key, val]) => {
             if (typeof val !== "undefined")
@@ -150,8 +435,13 @@ export class BaseRepository {
         }, {});
         return new this.class(Object.assign({}, extract(oldModel), extract(model)));
     }
+    /**
+     * @description Returns a string representation of the repository.
+     * @summary Creates a string that identifies this repository by the name of its model class.
+     * @return {string} A string representation of the repository
+     */
     toString() {
         return `${this.class.name} Repository`;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BaseRepository.js","sourceRoot":"","sources":["../../../src/repository/BaseRepository.ts"],"names":[],"mappings":"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","sourcesContent":["import { IRepository } from \"../interfaces/IRepository\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { enforceDBDecorators } from \"./utils\";\nimport { OperationKeys } from \"../operations/constants\";\nimport { InternalError } from \"./errors\";\nimport { wrapMethodWithContext } from \"./wrappers\";\nimport { findPrimaryKey } from \"../identity/utils\";\nimport { Context } from \"./Context\";\nimport { RepositoryFlags } from \"./types\";\n\nexport abstract class BaseRepository<\n  M extends Model,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> implements IRepository<M, F, C>\n{\n  private readonly _class!: Constructor<M>;\n  private _pk!: keyof M;\n  private _pkProps!: any;\n\n  get class() {\n    if (!this._class)\n      throw new InternalError(`No class definition found for this repository`);\n    return this._class;\n  }\n\n  get pk(): keyof M {\n    if (!this._pk) {\n      const { id, props } = findPrimaryKey(new this.class());\n      this._pk = id;\n      this._pkProps = props;\n    }\n    return this._pk;\n  }\n\n  protected get pkProps(): any {\n    if (!this._pkProps) {\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      const pk = this.pk;\n    }\n    return this._pkProps;\n  }\n\n  protected constructor(clazz?: Constructor<M>) {\n    if (clazz) this._class = clazz;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const self = this;\n    [this.create, this.read, this.update, this.delete].forEach((m) => {\n      const name = m.name;\n      wrapMethodWithContext(\n        self,\n        (self as any)[name + \"Prefix\"],\n        m,\n        (self as any)[name + \"Suffix\"]\n      );\n    });\n  }\n\n  abstract create(model: M, ...args: any[]): Promise<M>;\n\n  async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    return Promise.all(models.map((m) => this.create(m, ...args)));\n  }\n\n  protected async createPrefix(model: M, ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.CREATE,\n      this.class,\n      args\n    );\n    model = new this.class(model);\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.CREATE,\n      OperationKeys.ON\n    );\n    return [model, ...contextArgs.args];\n  }\n\n  protected async createSuffix(model: M, context: C) {\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      context,\n      model,\n      OperationKeys.CREATE,\n      OperationKeys.AFTER\n    );\n    return model;\n  }\n\n  protected async createAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.CREATE,\n      this.class,\n      args\n    );\n    await Promise.all(\n      models.map(async (m) => {\n        m = new this.class(m);\n        await enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    return [models, ...contextArgs.args];\n  }\n\n  protected async createAllSuffix(models: M[], context: C) {\n    await Promise.all(\n      models.map((m) =>\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.AFTER\n        )\n      )\n    );\n    return models;\n  }\n\n  abstract read(key: string | number, ...args: any[]): Promise<M>;\n\n  async readAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    return await Promise.all(keys.map((id) => this.read(id, ...args)));\n  }\n\n  protected async readSuffix(model: M, context: C) {\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      context,\n      model,\n      OperationKeys.READ,\n      OperationKeys.AFTER\n    );\n    return model;\n  }\n\n  protected async readPrefix(key: string, ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.READ,\n      this.class,\n      args\n    );\n    const model: M = new this.class();\n    model[this.pk] = key as any;\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.READ,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  protected async readAllPrefix(keys: string[] | number[], ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.READ,\n      this.class,\n      args\n    );\n    await Promise.all(\n      keys.map(async (k) => {\n        const m = new this.class();\n        m[this.pk] = k as any;\n        return enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.READ,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  protected async readAllSuffix(models: M[], context: C) {\n    await Promise.all(\n      models.map((m) =>\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          context,\n          m,\n          OperationKeys.READ,\n          OperationKeys.AFTER\n        )\n      )\n    );\n    return models;\n  }\n\n  abstract update(model: M, ...args: any[]): Promise<M>;\n\n  async updateAll(models: M[], ...args: any): Promise<M[]> {\n    return Promise.all(models.map((m) => this.update(m, ...args)));\n  }\n\n  protected async updateSuffix(model: M, context: C) {\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      context,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.AFTER\n    );\n    return model;\n  }\n\n  protected async updatePrefix(model: M, ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.UPDATE,\n      this.class,\n      args\n    );\n    const id = model[this.pk];\n    if (!id)\n      throw new InternalError(\n        `No value for the Id is defined under the property ${this.pk as string}`\n      );\n    const oldModel = await this.read(id as string);\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.ON,\n      oldModel\n    );\n    return [model, ...contextArgs.args];\n  }\n\n  protected async updateAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.UPDATE,\n      this.class,\n      args\n    );\n    await Promise.all(\n      models.map((m) => {\n        m = new this.class(m);\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.UPDATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    return [models, ...contextArgs.args];\n  }\n\n  protected async updateAllSuffix(models: M[], context: C) {\n    await Promise.all(\n      models.map((m) =>\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          context,\n          m,\n          OperationKeys.UPDATE,\n          OperationKeys.AFTER\n        )\n      )\n    );\n    return models;\n  }\n\n  abstract delete(key: string | number, ...args: any[]): Promise<M>;\n\n  async deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    return Promise.all(keys.map((k) => this.delete(k, ...args)));\n  }\n\n  protected async deleteSuffix(model: M, context: C) {\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      context,\n      model,\n      OperationKeys.DELETE,\n      OperationKeys.AFTER\n    );\n    return model;\n  }\n\n  protected async deletePrefix(key: any, ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.DELETE,\n      this.class,\n      args\n    );\n    const model = await this.read(key, ...contextArgs.args);\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.DELETE,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  protected async deleteAllPrefix(keys: string[] | number[], ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.DELETE,\n      this.class,\n      args\n    );\n    const models = await this.readAll(keys, ...contextArgs.args);\n    await Promise.all(\n      models.map(async (m) => {\n        return enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.DELETE,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  protected async deleteAllSuffix(models: M[], context: C) {\n    await Promise.all(\n      models.map((m) =>\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          context,\n          m,\n          OperationKeys.DELETE,\n          OperationKeys.AFTER\n        )\n      )\n    );\n    return models;\n  }\n\n  protected merge(oldModel: M, model: M): M {\n    const extract = (model: M) =>\n      Object.entries(model).reduce((accum: Record<string, any>, [key, val]) => {\n        if (typeof val !== \"undefined\") accum[key] = val;\n        return accum;\n      }, {});\n\n    return new this.class(Object.assign({}, extract(oldModel), extract(model)));\n  }\n\n  toString() {\n    return `${this.class.name} Repository`;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BaseRepository.js","sourceRoot":"","sources":["../../../src/repository/BaseRepository.ts"],"names":[],"mappings":"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","sourcesContent":["import { IRepository } from \"../interfaces/IRepository\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { enforceDBDecorators } from \"./utils\";\nimport { OperationKeys } from \"../operations/constants\";\nimport { InternalError } from \"./errors\";\nimport { wrapMethodWithContext } from \"./wrappers\";\nimport { findPrimaryKey } from \"../identity/utils\";\nimport { Context } from \"./Context\";\nimport { RepositoryFlags } from \"./types\";\n\n/**\n * @description Base repository implementation providing CRUD operations for models.\n * @summary The BaseRepository class serves as a foundation for repository implementations, providing\n * abstract and concrete methods for creating, reading, updating, and deleting model instances.\n * It handles operation lifecycles including prefix and suffix operations, and enforces decorators.\n * @template M - The model type extending Model\n * @template F - The repository flags type, defaults to RepositoryFlags\n * @template C - The context type, defaults to Context<F>\n * @param {Constructor<M>} clazz - The constructor for the model class\n * @class BaseRepository\n * @example\n * class UserModel extends Model {\n *   @id()\n *   id: string;\n *\n *   @required()\n *   name: string;\n * }\n *\n * class UserRepository extends BaseRepository<UserModel> {\n *   constructor() {\n *     super(UserModel);\n *   }\n *\n *   async create(model: UserModel): Promise<UserModel> {\n *     // Implementation\n *     return model;\n *   }\n *\n *   async read(key: string): Promise<UserModel> {\n *     // Implementation\n *     return new UserModel({ id: key, name: 'User' });\n *   }\n *\n *   async update(model: UserModel): Promise<UserModel> {\n *     // Implementation\n *     return model;\n *   }\n *\n *   async delete(key: string): Promise<UserModel> {\n *     // Implementation\n *     const model = await this.read(key);\n *     return model;\n *   }\n * }\n *\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant R as Repository\n *   participant P as Prefix Methods\n *   participant D as Database\n *   participant S as Suffix Methods\n *   participant V as Validators/Decorators\n *\n *   Note over C,V: Create Operation\n *   C->>R: create(model)\n *   R->>P: createPrefix(model)\n *   P->>V: enforceDBDecorators(ON)\n *   P->>D: Database operation\n *   D->>S: createSuffix(model)\n *   S->>V: enforceDBDecorators(AFTER)\n *   S->>C: Return model\n *\n *   Note over C,V: Read Operation\n *   C->>R: read(key)\n *   R->>P: readPrefix(key)\n *   P->>V: enforceDBDecorators(ON)\n *   P->>D: Database operation\n *   D->>S: readSuffix(model)\n *   S->>V: enforceDBDecorators(AFTER)\n *   S->>C: Return model\n *\n *   Note over C,V: Update Operation\n *   C->>R: update(model)\n *   R->>P: updatePrefix(model)\n *   P->>V: enforceDBDecorators(ON)\n *   P->>D: Database operation\n *   D->>S: updateSuffix(model)\n *   S->>V: enforceDBDecorators(AFTER)\n *   S->>C: Return model\n *\n *   Note over C,V: Delete Operation\n *   C->>R: delete(key)\n *   R->>P: deletePrefix(key)\n *   P->>V: enforceDBDecorators(ON)\n *   P->>D: Database operation\n *   D->>S: deleteSuffix(model)\n *   S->>V: enforceDBDecorators(AFTER)\n *   S->>C: Return model\n */\nexport abstract class BaseRepository<\n  M extends Model,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> implements IRepository<M, F, C>\n{\n  private readonly _class!: Constructor<M>;\n  private _pk!: keyof M;\n  private _pkProps!: any;\n\n  /**\n   * @description Gets the model class constructor.\n   * @summary Retrieves the constructor for the model class associated with this repository.\n   * Throws an error if no class definition is found.\n   * @return {Constructor<M>} The constructor for the model class\n   */\n  get class() {\n    if (!this._class)\n      throw new InternalError(`No class definition found for this repository`);\n    return this._class;\n  }\n\n  /**\n   * @description Gets the primary key property name of the model.\n   * @summary Retrieves the name of the property that serves as the primary key for the model.\n   * If not already determined, it finds the primary key using the model's decorators.\n   * @return The name of the primary key property\n   */\n  get pk(): keyof M {\n    if (!this._pk) {\n      const { id, props } = findPrimaryKey(new this.class());\n      this._pk = id;\n      this._pkProps = props;\n    }\n    return this._pk;\n  }\n\n  /**\n   * @description Gets the primary key properties.\n   * @summary Retrieves the properties associated with the primary key of the model.\n   * If not already determined, it triggers the pk getter to find the primary key properties.\n   * @return {any} The properties of the primary key\n   */\n  protected get pkProps(): any {\n    if (!this._pkProps) {\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      const pk = this.pk;\n    }\n    return this._pkProps;\n  }\n\n  protected constructor(clazz?: Constructor<M>) {\n    if (clazz) this._class = clazz;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const self = this;\n    [this.create, this.read, this.update, this.delete].forEach((m) => {\n      const name = m.name;\n      wrapMethodWithContext(\n        self,\n        (self as any)[name + \"Prefix\"],\n        m,\n        (self as any)[name + \"Suffix\"]\n      );\n    });\n  }\n\n  /**\n   * @description Creates a new model instance in the repository.\n   * @summary Persists a new model instance to the underlying data store.\n   * This method must be implemented by concrete repository classes.\n   * @param {M} model - The model instance to create\n   * @param {any[]} args - Additional arguments for the create operation\n   * @return {Promise<M>} A promise that resolves to the created model instance\n   */\n  abstract create(model: M, ...args: any[]): Promise<M>;\n\n  /**\n   * @description Creates multiple model instances in the repository.\n   * @summary Persists multiple model instances to the underlying data store by calling\n   * the create method for each model in the array.\n   * @param {M[]} models - The array of model instances to create\n   * @param {any[]} args - Additional arguments for the create operation\n   * @return {Promise<M[]>} A promise that resolves to an array of created model instances\n   */\n  async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    return Promise.all(models.map((m) => this.create(m, ...args)));\n  }\n\n  /**\n   * @description Prepares a model for creation and executes pre-creation operations.\n   * @summary Processes a model before it is created in the data store. This includes\n   * creating a context, instantiating a new model instance, and enforcing any decorators\n   * that should be applied before creation.\n   * @param {M} model - The model instance to prepare for creation\n   * @param {any[]} args - Additional arguments for the create operation\n   * @return A promise that resolves to an array containing the prepared model and context arguments\n   */\n  protected async createPrefix(model: M, ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.CREATE,\n      this.class,\n      args\n    );\n    model = new this.class(model);\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.CREATE,\n      OperationKeys.ON\n    );\n    return [model, ...contextArgs.args];\n  }\n\n  /**\n   * @description Processes a model after creation and executes post-creation operations.\n   * @summary Finalizes a model after it has been created in the data store. This includes\n   * enforcing any decorators that should be applied after creation.\n   * @param {M} model - The model instance that was created\n   * @param {C} context - The context for the operation\n   * @return {Promise<M>} A promise that resolves to the processed model instance\n   */\n  protected async createSuffix(model: M, context: C) {\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      context,\n      model,\n      OperationKeys.CREATE,\n      OperationKeys.AFTER\n    );\n    return model;\n  }\n\n  /**\n   * @description Prepares multiple models for creation and executes pre-creation operations.\n   * @summary Processes multiple models before they are created in the data store. This includes\n   * creating a context, instantiating new model instances, and enforcing any decorators\n   * that should be applied before creation for each model.\n   * @param {M[]} models - The array of model instances to prepare for creation\n   * @param {any[]} args - Additional arguments for the create operation\n   * @return  A promise that resolves to an array containing the prepared models and context arguments\n   */\n  protected async createAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.CREATE,\n      this.class,\n      args\n    );\n    await Promise.all(\n      models.map(async (m) => {\n        m = new this.class(m);\n        await enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Processes multiple models after creation and executes post-creation operations.\n   * @summary Finalizes multiple models after they have been created in the data store. This includes\n   * enforcing any decorators that should be applied after creation for each model.\n   * @param {M[]} models - The array of model instances that were created\n   * @param {C} context - The context for the operation\n   * @return {Promise<M[]>} A promise that resolves to the array of processed model instances\n   */\n  protected async createAllSuffix(models: M[], context: C) {\n    await Promise.all(\n      models.map((m) =>\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.AFTER\n        )\n      )\n    );\n    return models;\n  }\n\n  /**\n   * @description Retrieves a model instance from the repository by its primary key.\n   * @summary Fetches a model instance from the underlying data store using its primary key.\n   * This method must be implemented by concrete repository classes.\n   * @param {string | number} key - The primary key of the model to retrieve\n   * @param {any[]} args - Additional arguments for the read operation\n   * @return {Promise<M>} A promise that resolves to the retrieved model instance\n   */\n  abstract read(key: string | number, ...args: any[]): Promise<M>;\n\n  /**\n   * @description Retrieves multiple model instances from the repository by their primary keys.\n   * @summary Fetches multiple model instances from the underlying data store using their primary keys\n   * by calling the read method for each key in the array.\n   * @param {string[] | number[]} keys - The array of primary keys of the models to retrieve\n   * @param {any[]} args - Additional arguments for the read operation\n   * @return {Promise<M[]>} A promise that resolves to an array of retrieved model instances\n   */\n  async readAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    return await Promise.all(keys.map((id) => this.read(id, ...args)));\n  }\n\n  /**\n   * @description Processes a model after retrieval and executes post-read operations.\n   * @summary Finalizes a model after it has been retrieved from the data store. This includes\n   * enforcing any decorators that should be applied after reading.\n   * @param {M} model - The model instance that was retrieved\n   * @param {C} context - The context for the operation\n   * @return {Promise<M>} A promise that resolves to the processed model instance\n   */\n  protected async readSuffix(model: M, context: C) {\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      context,\n      model,\n      OperationKeys.READ,\n      OperationKeys.AFTER\n    );\n    return model;\n  }\n\n  /**\n   * @description Prepares for reading a model and executes pre-read operations.\n   * @summary Processes a key before a model is read from the data store. This includes\n   * creating a context, instantiating a new model instance with the key, and enforcing any decorators\n   * that should be applied before reading.\n   * @param {string} key - The primary key of the model to read\n   * @param {any[]} args - Additional arguments for the read operation\n   * @return A promise that resolves to an array containing the key and context arguments\n   */\n  protected async readPrefix(key: string, ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.READ,\n      this.class,\n      args\n    );\n    const model: M = new this.class();\n    model[this.pk] = key as any;\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.READ,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepares for reading multiple models and executes pre-read operations.\n   * @summary Processes multiple keys before models are read from the data store. This includes\n   * creating a context, instantiating new model instances with the keys, and enforcing any decorators\n   * that should be applied before reading for each key.\n   * @param {string[] | number[]} keys - The array of primary keys of the models to read\n   * @param {any[]} args - Additional arguments for the read operation\n   * @return A promise that resolves to an array containing the keys and context arguments\n   */\n  protected async readAllPrefix(keys: string[] | number[], ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.READ,\n      this.class,\n      args\n    );\n    await Promise.all(\n      keys.map(async (k) => {\n        const m = new this.class();\n        m[this.pk] = k as any;\n        return enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.READ,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  /**\n   * @description Processes multiple models after retrieval and executes post-read operations.\n   * @summary Finalizes multiple models after they have been retrieved from the data store. This includes\n   * enforcing any decorators that should be applied after reading for each model.\n   * @param {M[]} models - The array of model instances that were retrieved\n   * @param {C} context - The context for the operation\n   * @return {Promise<M[]>} A promise that resolves to the array of processed model instances\n   */\n  protected async readAllSuffix(models: M[], context: C) {\n    await Promise.all(\n      models.map((m) =>\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          context,\n          m,\n          OperationKeys.READ,\n          OperationKeys.AFTER\n        )\n      )\n    );\n    return models;\n  }\n\n  /**\n   * @description Updates an existing model instance in the repository.\n   * @summary Updates an existing model instance in the underlying data store.\n   * This method must be implemented by concrete repository classes.\n   * @param {M} model - The model instance to update\n   * @param {any[]} args - Additional arguments for the update operation\n   * @return {Promise<M>} A promise that resolves to the updated model instance\n   */\n  abstract update(model: M, ...args: any[]): Promise<M>;\n\n  /**\n   * @description Updates multiple model instances in the repository.\n   * @summary Updates multiple model instances in the underlying data store by calling\n   * the update method for each model in the array.\n   * @param {M[]} models - The array of model instances to update\n   * @param {any[]} args - Additional arguments for the update operation\n   * @return {Promise<M[]>} A promise that resolves to an array of updated model instances\n   */\n  async updateAll(models: M[], ...args: any): Promise<M[]> {\n    return Promise.all(models.map((m) => this.update(m, ...args)));\n  }\n\n  /**\n   * @description Processes a model after update and executes post-update operations.\n   * @summary Finalizes a model after it has been updated in the data store. This includes\n   * enforcing any decorators that should be applied after updating.\n   * @param {M} model - The model instance that was updated\n   * @param {C} context - The context for the operation\n   * @return {Promise<M>} A promise that resolves to the processed model instance\n   */\n  protected async updateSuffix(model: M, context: C) {\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      context,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.AFTER\n    );\n    return model;\n  }\n\n  /**\n   * @description Prepares a model for update and executes pre-update operations.\n   * @summary Processes a model before it is updated in the data store. This includes\n   * creating a context, validating the primary key, retrieving the existing model,\n   * and enforcing any decorators that should be applied before updating.\n   * @param {M} model - The model instance to prepare for update\n   * @param {any[]} args - Additional arguments for the update operation\n   * @return A promise that resolves to an array containing the prepared model and context arguments\n   */\n  protected async updatePrefix(model: M, ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.UPDATE,\n      this.class,\n      args\n    );\n    const id = model[this.pk];\n    if (!id)\n      throw new InternalError(\n        `No value for the Id is defined under the property ${this.pk as string}`\n      );\n    const oldModel = await this.read(id as string);\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.ON,\n      oldModel\n    );\n    return [model, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepares multiple models for update and executes pre-update operations.\n   * @summary Processes multiple models before they are updated in the data store. This includes\n   * creating a context, instantiating new model instances, and enforcing any decorators\n   * that should be applied before updating for each model.\n   * @param {M[]} models - The array of model instances to prepare for update\n   * @param {any[]} args - Additional arguments for the update operation\n   * @return A promise that resolves to an array containing the prepared models and context arguments\n   */\n  protected async updateAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.UPDATE,\n      this.class,\n      args\n    );\n    await Promise.all(\n      models.map((m) => {\n        m = new this.class(m);\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.UPDATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Processes multiple models after update and executes post-update operations.\n   * @summary Finalizes multiple models after they have been updated in the data store. This includes\n   * enforcing any decorators that should be applied after updating for each model.\n   * @param {M[]} models - The array of model instances that were updated\n   * @param {C} context - The context for the operation\n   * @return {Promise<M[]>} A promise that resolves to the array of processed model instances\n   */\n  protected async updateAllSuffix(models: M[], context: C) {\n    await Promise.all(\n      models.map((m) =>\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          context,\n          m,\n          OperationKeys.UPDATE,\n          OperationKeys.AFTER\n        )\n      )\n    );\n    return models;\n  }\n\n  /**\n   * @description Deletes a model instance from the repository by its primary key.\n   * @summary Removes a model instance from the underlying data store using its primary key.\n   * This method must be implemented by concrete repository classes.\n   * @param {string | number} key - The primary key of the model to delete\n   * @param {any[]} args - Additional arguments for the delete operation\n   * @return {Promise<M>} A promise that resolves to the deleted model instance\n   */\n  abstract delete(key: string | number, ...args: any[]): Promise<M>;\n\n  /**\n   * @description Deletes multiple model instances from the repository by their primary keys.\n   * @summary Removes multiple model instances from the underlying data store using their primary keys\n   * by calling the delete method for each key in the array.\n   * @param {string[] | number[]} keys - The array of primary keys of the models to delete\n   * @param {any[]} args - Additional arguments for the delete operation\n   * @return {Promise<M[]>} A promise that resolves to an array of deleted model instances\n   */\n  async deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]> {\n    return Promise.all(keys.map((k) => this.delete(k, ...args)));\n  }\n\n  /**\n   * @description Processes a model after deletion and executes post-delete operations.\n   * @summary Finalizes a model after it has been deleted from the data store. This includes\n   * enforcing any decorators that should be applied after deletion.\n   * @param {M} model - The model instance that was deleted\n   * @param {C} context - The context for the operation\n   * @return {Promise<M>} A promise that resolves to the processed model instance\n   */\n  protected async deleteSuffix(model: M, context: C) {\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      context,\n      model,\n      OperationKeys.DELETE,\n      OperationKeys.AFTER\n    );\n    return model;\n  }\n\n  /**\n   * @description Prepares for deleting a model and executes pre-delete operations.\n   * @summary Processes a key before a model is deleted from the data store. This includes\n   * creating a context, retrieving the model to be deleted, and enforcing any decorators\n   * that should be applied before deletion.\n   * @param {any} key - The primary key of the model to delete\n   * @param {any[]} args - Additional arguments for the delete operation\n   * @return A promise that resolves to an array containing the key and context arguments\n   */\n  protected async deletePrefix(key: any, ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.DELETE,\n      this.class,\n      args\n    );\n    const model = await this.read(key, ...contextArgs.args);\n    await enforceDBDecorators<M, typeof this, any, F, C>(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.DELETE,\n      OperationKeys.ON\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepares for deleting multiple models and executes pre-delete operations.\n   * @summary Processes multiple keys before models are deleted from the data store. This includes\n   * creating a context, retrieving the models to be deleted, and enforcing any decorators\n   * that should be applied before deletion for each model.\n   * @param {string[] | number[]} keys - The array of primary keys of the models to delete\n   * @param {any[]} args - Additional arguments for the delete operation\n   * @return A promise that resolves to an array containing the keys and context arguments\n   */\n  protected async deleteAllPrefix(keys: string[] | number[], ...args: any[]) {\n    const contextArgs = await Context.args<M, C, F>(\n      OperationKeys.DELETE,\n      this.class,\n      args\n    );\n    const models = await this.readAll(keys, ...contextArgs.args);\n    await Promise.all(\n      models.map(async (m) => {\n        return enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.DELETE,\n          OperationKeys.ON\n        );\n      })\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  /**\n   * @description Processes multiple models after deletion and executes post-delete operations.\n   * @summary Finalizes multiple models after they have been deleted from the data store. This includes\n   * enforcing any decorators that should be applied after deletion for each model.\n   * @param {M[]} models - The array of model instances that were deleted\n   * @param {C} context - The context for the operation\n   * @return {Promise<M[]>} A promise that resolves to the array of processed model instances\n   */\n  protected async deleteAllSuffix(models: M[], context: C) {\n    await Promise.all(\n      models.map((m) =>\n        enforceDBDecorators<M, typeof this, any, F, C>(\n          this,\n          context,\n          m,\n          OperationKeys.DELETE,\n          OperationKeys.AFTER\n        )\n      )\n    );\n    return models;\n  }\n\n  /**\n   * @description Merges two model instances into a new instance.\n   * @summary Creates a new model instance by combining properties from an old model and a new model.\n   * Properties from the new model override properties from the old model if they are defined.\n   * @param {M} oldModel - The original model instance\n   * @param {M} model - The new model instance with updated properties\n   * @return {M} A new model instance with merged properties\n   */\n  protected merge(oldModel: M, model: M): M {\n    const extract = (model: M) =>\n      Object.entries(model).reduce((accum: Record<string, any>, [key, val]) => {\n        if (typeof val !== \"undefined\") accum[key] = val;\n        return accum;\n      }, {});\n\n    return new this.class(Object.assign({}, extract(oldModel), extract(model)));\n  }\n\n  /**\n   * @description Returns a string representation of the repository.\n   * @summary Creates a string that identifies this repository by the name of its model class.\n   * @return {string} A string representation of the repository\n   */\n  toString() {\n    return `${this.class.name} Repository`;\n  }\n}\n"]}