@decaf-ts/db-decorators 0.6.1 → 0.6.2

package/lib/repository/Context.d.ts

@@ -3,17 +3,168 @@ import { Contextual } from "../interfaces/Contextual";
 import { OperationKeys } from "../operations/constants";
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { RepositoryFlags } from "./types";
+/**
+ * @description Factory type for creating context instances.
+ * @summary Defines a function type that creates context instances with specific repository flags.
+ * @template F - The repository flags type extending RepositoryFlags
+ * @typedef {Function} ContextFactory
+ * @memberOf module:db-decorators
+ */
 export type ContextFactory<F extends RepositoryFlags> = <C extends Context<F>>(arg: Omit<F, "timestamp">) => C;
+/**
+ * @description Default factory for creating context instances.
+ * @summary A factory function that creates new Context instances with the provided repository flags.
+ * It automatically adds a timestamp to the context and returns a properly typed context instance.
+ * @const DefaultContextFactory
+ * @memberOf module:db-decorators
+ */
 export declare const DefaultContextFactory: ContextFactory<any>;
-export declare class Context<F extends RepositoryFlags = RepositoryFlags> {
+/**
+ * @description A context management class for handling repository operations.
+ * @summary The Context class provides a mechanism for managing repository operations with flags,
+ * parent-child relationships, and state accumulation. It allows for hierarchical context chains
+ * and maintains operation-specific configurations while supporting type safety through generics.
+ *
+ * @template F - Type extending RepositoryFlags that defines the context configuration
+ *
+ * @param {ObjectAccumulator<F>} cache - The internal cache storing accumulated values
+ *
+ * @class
+ *
+ * @example
+ * ```typescript
+ * // Creating a new context with repository flags
+ * const context = new Context<RepositoryFlags>();
+ *
+ * // Accumulating values
+ * const enrichedContext = context.accumulate({
+ *   writeOperation: true,
+ *   affectedTables: ['users'],
+ *   operation: OperationKeys.CREATE
+ * });
+ *
+ * // Accessing values
+ * const isWrite = enrichedContext.get('writeOperation'); // true
+ * const tables = enrichedContext.get('affectedTables'); // ['users']
+ * ```
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant C as Client
+ *   participant Ctx as Context
+ *   participant Cache as ObjectAccumulator
+ *
+ *   C->>Ctx: new Context()
+ *   Ctx->>Cache: create cache
+ *
+ *   C->>Ctx: accumulate(value)
+ *   Ctx->>Cache: accumulate(value)
+ *   Cache-->>Ctx: updated cache
+ *   Ctx-->>C: updated context
+ *
+ *   C->>Ctx: get(key)
+ *   Ctx->>Cache: get(key)
+ *   alt Key exists in cache
+ *     Cache-->>Ctx: value
+ *   else Key not found
+ *     Ctx->>Ctx: check parent context
+ *     alt Parent exists
+ *       Ctx->>Parent: get(key)
+ *       Parent-->>Ctx: value
+ *     else No parent
+ *       Ctx-->>C: throw error
+ *     end
+ *   end
+ *   Ctx-->>C: requested value
+ */
+export declare class Context<F extends RepositoryFlags> {
+    constructor();
     static factory: ContextFactory<any>;
     private readonly cache;
-    constructor(obj?: F);
+    /**
+     * @description Accumulates new values into the context.
+     * @summary Merges the provided value object with the existing context state,
+     * creating a new immutable cache state.
+     *
+     * @template F - current accumulator type
+     * @template V - Type extending object for the values to accumulate
+     * @param {V} value - The object containing values to accumulate
+     * @returns A new context instance with accumulated values
+     */
     accumulate<V extends object>(value: V): Context<F & V>;
     get timestamp(): Date;
+    /**
+     * @description Retrieves a value from the context by key.
+     * @summary Attempts to get a value from the current context's cache.
+     * If not found, traverses up the parent context chain.
+     *
+     * @template K - Type extending keyof F for the key to retrieve
+     * @template F - Accumulator type
+     * @param {K} key - The key to retrieve from the context
+     * @returns The value associated with the key
+     * @throws {Error} If the key is not found in the context chain
+     */
     get<K extends keyof F>(key: K): F[K];
+    /**
+     * @description Creates a child context
+     * @summary Generates a new context instance with current context as parent
+     *
+     * @template M - Type extending Model
+     * @param {OperationKeys} operation - The operation type
+     * @param {Constructor<M>} [model] - Optional model constructor
+     * @returns {C} New child context instance
+     */
     child<M extends Model, C extends Context<F>>(operation: OperationKeys, model?: Constructor<M>): C;
+    /**
+     * @description Creates a child context from another context
+     * @summary Generates a new context instance with parent reference
+     *
+     * @template F - Type extending Repository Flags
+     * @template C - Type extending Context<F>
+     * @param {C} context - The parent context
+     * @param {Partial<F>} [overrides] - Optional flag overrides
+     * @returns {C} New child context instance
+     */
     static childFrom<F extends RepositoryFlags, C extends Context<F>>(context: C, overrides?: Partial<F>): C;
+    /**
+     * @description Creates a new context from operation parameters
+     * @summary Generates a context instance for specific operation
+     *
+     * @template F - Type extending Repository Flags
+     * @template M - Type extending Model
+     * @param {OperationKeys.DELETE} operation - The operation type
+     * @param {Partial<F>} overrides - Flag overrides
+     * @param {Constructor<M>} model - The model constructor
+     * @param {any} args - Operation arguments
+     * @returns {Promise<C>} Promise resolving to new context
+     */
     static from<M extends Model, F extends RepositoryFlags, C extends Context<F>>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, overrides: Partial<F>, model: Constructor<M>, ...args: any[]): Promise<C>;
+    /**
+     * @description Prepares arguments for context operations
+     * @summary Creates a context args object with the specified operation parameters
+     *
+     * @template F - Type extending {@link RepositoryFlags}
+     * @template M - Type extending {@link Model}
+     * @param {OperationKeys.DELETE} operation - The operation type
+     * @param {Constructor<M>} model - The model constructor
+     * @param {any[]} args - Operation arguments
+     * @param {Contextual<F>} [contextual] - Optional contextual object
+     * @param {Partial<F>} [overrides] - Optional flag overrides
+     * @returns {Promise<ContextArgs>} Promise resolving to context arguments
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant C as Context
+     *   participant M as Model
+     *   participant A as Args
+     *
+     *   C->>C: Receive operation request
+     *   C->>M: Validate model constructor
+     *   C->>C: Create child context
+     *   C->>A: Process operation args
+     *   A->>C: Return context args
+     *   C->>C: Apply overrides
+     *   C->>C: Return final context
+     */
     static args<M extends Model, C extends Context<F>, F extends RepositoryFlags>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, model: Constructor<M>, args: any[], contextual?: Contextual<F>, overrides?: Partial<F>): Promise<ContextArgs<F, C>>;
 }

package/lib/repository/Repository.cjs

@@ -7,10 +7,58 @@ const errors_1 = require("./errors.cjs");
 const BaseRepository_1 = require("./BaseRepository.cjs");
 const constants_2 = require("./../model/constants.cjs");
 const Context_1 = require("./Context.cjs");
+/**
+ * @description Concrete repository implementation with validation support.
+ * @summary The Repository class extends BaseRepository to provide additional validation
+ * functionality. It overrides prefix methods to perform model validation before database
+ * operations and throws ValidationError when validation fails.
+ * @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>
+ * @class Repository
+ * @example
+ * class UserModel extends Model {
+ *   @id()
+ *   id: string;
+ *
+ *   @required()
+ *   @minLength(3)
+ *   name: string;
+ * }
+ *
+ * class UserRepository extends Repository<UserModel> {
+ *   constructor() {
+ *     super(UserModel);
+ *   }
+ *
+ *   async create(model: UserModel): Promise<UserModel> {
+ *     // Implementation with automatic validation
+ *     return model;
+ *   }
+ * }
+ *
+ * // Using the repository
+ * const repo = new UserRepository();
+ * try {
+ *   const user = await repo.create({ name: 'Jo' }); // Will throw ValidationError
+ * } catch (error) {
+ *   console.error(error); // ValidationError: name must be at least 3 characters
+ * }
+ */
 class Repository extends BaseRepository_1.BaseRepository {
     constructor(clazz) {
         super(clazz);
     }
+    /**
+     * @description Prepares a model for creation with validation.
+     * @summary Overrides the base createPrefix method to add validation checks.
+     * Creates a context, instantiates a new model, enforces decorators, and validates
+     * the model before allowing creation to proceed.
+     * @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 validated model and context arguments
+     * @throws {ValidationError} If the model fails validation
+     */
     async createPrefix(model, ...args) {
         const contextArgs = await Context_1.Context.args(constants_1.OperationKeys.CREATE, this.class, args);
         model = new this.class(model);
@@ -20,6 +68,16 @@ class Repository extends BaseRepository_1.BaseRepository {
             throw new errors_1.ValidationError(errors.toString());
         return [model, ...contextArgs.args];
     }
+    /**
+     * @description Prepares multiple models for creation with validation.
+     * @summary Overrides the base createAllPrefix method to add validation checks for multiple models.
+     * Creates a context, instantiates new models, enforces decorators, and validates
+     * each model before allowing creation to proceed. Collects validation errors from all models.
+     * @param {M[]} models - The array of model instances to prepare for creation
+     * @param {any[]} args - Additional arguments for the create operation
+     * @return {Promise<any[]>} A promise that resolves to an array containing the validated models and context arguments
+     * @throws {ValidationError} If any model fails validation, with details about which models failed
+     */
     async createAllPrefix(models, ...args) {
         const contextArgs = await Context_1.Context.args(constants_1.OperationKeys.CREATE, this.class, args);
         await Promise.all(models.map(async (m) => {
@@ -41,6 +99,18 @@ class Repository extends BaseRepository_1.BaseRepository {
             throw new errors_1.ValidationError(errors);
         return [models, ...contextArgs.args];
     }
+    /**
+     * @description Prepares a model for update with validation.
+     * @summary Overrides the base updatePrefix method to add validation checks.
+     * Creates a context, validates the primary key, retrieves the existing model,
+     * merges the old and new models, enforces decorators, and validates the model
+     * before allowing the update to proceed.
+     * @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 validated model and context arguments
+     * @throws {InternalError} If the model doesn't have a primary key value
+     * @throws {ValidationError} If the model fails validation
+     */
     async updatePrefix(model, ...args) {
         const contextArgs = await Context_1.Context.args(constants_1.OperationKeys.UPDATE, this.class, args);
         const pk = model[this.pk];
@@ -54,6 +124,18 @@ class Repository extends BaseRepository_1.BaseRepository {
             throw new errors_1.ValidationError(errors.toString());
         return [model, ...contextArgs.args];
     }
+    /**
+     * @description Prepares multiple models for update with validation.
+     * @summary Overrides the base updateAllPrefix method to add validation checks for multiple models.
+     * Creates a context, validates primary keys, retrieves existing models, merges old and new models,
+     * enforces decorators, and validates each model before allowing updates to proceed.
+     * Collects validation errors from all models.
+     * @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 validated models and context arguments
+     * @throws {InternalError} If any model doesn't have a primary key value
+     * @throws {ValidationError} If any model fails validation, with details about which models failed
+     */
     async updateAllPrefix(models, ...args) {
         const contextArgs = await Context_1.Context.args(constants_1.OperationKeys.UPDATE, this.class, args);
         const ids = models.map((m) => {
@@ -79,9 +161,16 @@ class Repository extends BaseRepository_1.BaseRepository {
             throw new errors_1.ValidationError(errors);
         return [models, ...contextArgs.args];
     }
+    /**
+     * @description Creates a reflection key for database operations.
+     * @summary Generates a key for storing metadata in the reflection system by prefixing
+     * the provided key with the database reflection prefix.
+     * @param {string} key - The base key to prefix
+     * @return {string} The prefixed reflection key
+     */
     static key(key) {
         return constants_2.DBKeys.REFLECT + key;
     }
 }
 exports.Repository = Repository;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Repository.js","sourceRoot":"","sources":["../../src/repository/Repository.ts"],"names":[],"mappings":"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","sourcesContent":["import { enforceDBDecorators } from \"./utils\";\nimport { OperationKeys } from \"../operations/constants\";\nimport { InternalError, ValidationError } from \"./errors\";\nimport { BaseRepository } from \"./BaseRepository\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { DBKeys } from \"../model/constants\";\nimport { Context } from \"./Context\";\nimport { RepositoryFlags } from \"./types\";\n\nexport abstract class Repository<\n  M extends Model,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> extends BaseRepository<M, F, C> {\n  protected constructor(clazz?: Constructor<M>) {\n    super(clazz);\n  }\n\n  protected override async createPrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...any[]]> {\n    const contextArgs = await Context.args(\n      OperationKeys.CREATE,\n      this.class,\n      args\n    );\n    model = new this.class(model);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.CREATE,\n      OperationKeys.ON\n    );\n\n    const errors = model.hasErrors();\n    if (errors) throw new ValidationError(errors.toString());\n\n    return [model, ...contextArgs.args];\n  }\n\n  protected override async createAllPrefix(\n    models: M[],\n    ...args: any[]\n  ): Promise<any[]> {\n    const contextArgs = await Context.args(\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(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    const errors = models\n      .map((m) => m.hasErrors())\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n    return [models, ...contextArgs.args];\n  }\n\n  protected override async updatePrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...args: any[]]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args\n    );\n    const pk = (model as any)[this.pk];\n    if (!pk)\n      throw new InternalError(\n        `No value for the Id is defined under the property ${this.pk as string}`\n      );\n\n    const oldModel: M = await this.read(pk);\n\n    model = this.merge(oldModel, model);\n\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.ON,\n      oldModel\n    );\n\n    const errors = model.hasErrors(oldModel as any);\n    if (errors) throw new ValidationError(errors.toString());\n    return [model, ...contextArgs.args];\n  }\n\n  protected override async updateAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args\n    );\n    const ids = models.map((m) => {\n      const id = m[this.pk];\n      if (typeof id === \"undefined\")\n        throw new InternalError(\n          `No value for the Id is defined under the property ${this.pk as string}`\n        );\n      return id as string;\n    });\n    const oldModels: M[] = await this.readAll(ids, ...contextArgs.args);\n    models = models.map((m, i) => this.merge(oldModels[i], m));\n    await Promise.all(\n      models.map((m, i) =>\n        enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.UPDATE,\n          OperationKeys.ON,\n          oldModels[i]\n        )\n      )\n    );\n\n    const errors = models\n      .map((m, i) => m.hasErrors(oldModels[i] as any))\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n    return [models, ...contextArgs.args];\n  }\n\n  static key(key: string) {\n    return DBKeys.REFLECT + key;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Repository.js","sourceRoot":"","sources":["../../src/repository/Repository.ts"],"names":[],"mappings":"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","sourcesContent":["import { enforceDBDecorators } from \"./utils\";\nimport { OperationKeys } from \"../operations/constants\";\nimport { InternalError, ValidationError } from \"./errors\";\nimport { BaseRepository } from \"./BaseRepository\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { DBKeys } from \"../model/constants\";\nimport { Context } from \"./Context\";\nimport { RepositoryFlags } from \"./types\";\n\n/**\n * @description Concrete repository implementation with validation support.\n * @summary The Repository class extends BaseRepository to provide additional validation\n * functionality. It overrides prefix methods to perform model validation before database\n * operations and throws ValidationError when validation fails.\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 * @class Repository\n * @example\n * class UserModel extends Model {\n *   @id()\n *   id: string;\n *\n *   @required()\n *   @minLength(3)\n *   name: string;\n * }\n *\n * class UserRepository extends Repository<UserModel> {\n *   constructor() {\n *     super(UserModel);\n *   }\n *\n *   async create(model: UserModel): Promise<UserModel> {\n *     // Implementation with automatic validation\n *     return model;\n *   }\n * }\n *\n * // Using the repository\n * const repo = new UserRepository();\n * try {\n *   const user = await repo.create({ name: 'Jo' }); // Will throw ValidationError\n * } catch (error) {\n *   console.error(error); // ValidationError: name must be at least 3 characters\n * }\n */\nexport abstract class Repository<\n  M extends Model,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n> extends BaseRepository<M, F, C> {\n  protected constructor(clazz?: Constructor<M>) {\n    super(clazz);\n  }\n\n  /**\n   * @description Prepares a model for creation with validation.\n   * @summary Overrides the base createPrefix method to add validation checks.\n   * Creates a context, instantiates a new model, enforces decorators, and validates\n   * the model before allowing creation to proceed.\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 validated model and context arguments\n   * @throws {ValidationError} If the model fails validation\n   */\n  protected override async createPrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...any[]]> {\n    const contextArgs = await Context.args(\n      OperationKeys.CREATE,\n      this.class,\n      args\n    );\n    model = new this.class(model);\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.CREATE,\n      OperationKeys.ON\n    );\n\n    const errors = model.hasErrors();\n    if (errors) throw new ValidationError(errors.toString());\n\n    return [model, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepares multiple models for creation with validation.\n   * @summary Overrides the base createAllPrefix method to add validation checks for multiple models.\n   * Creates a context, instantiates new models, enforces decorators, and validates\n   * each model before allowing creation to proceed. Collects validation errors from all models.\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 {Promise<any[]>} A promise that resolves to an array containing the validated models and context arguments\n   * @throws {ValidationError} If any model fails validation, with details about which models failed\n   */\n  protected override async createAllPrefix(\n    models: M[],\n    ...args: any[]\n  ): Promise<any[]> {\n    const contextArgs = await Context.args(\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(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    const errors = models\n      .map((m) => m.hasErrors())\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepares a model for update with validation.\n   * @summary Overrides the base updatePrefix method to add validation checks.\n   * Creates a context, validates the primary key, retrieves the existing model,\n   * merges the old and new models, enforces decorators, and validates the model\n   * before allowing the update to proceed.\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 validated model and context arguments\n   * @throws {InternalError} If the model doesn't have a primary key value\n   * @throws {ValidationError} If the model fails validation\n   */\n  protected override async updatePrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...args: any[]]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args\n    );\n    const pk = (model as any)[this.pk];\n    if (!pk)\n      throw new InternalError(\n        `No value for the Id is defined under the property ${this.pk as string}`\n      );\n\n    const oldModel: M = await this.read(pk);\n\n    model = this.merge(oldModel, model);\n\n    await enforceDBDecorators(\n      this,\n      contextArgs.context,\n      model,\n      OperationKeys.UPDATE,\n      OperationKeys.ON,\n      oldModel\n    );\n\n    const errors = model.hasErrors(oldModel as any);\n    if (errors) throw new ValidationError(errors.toString());\n    return [model, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepares multiple models for update with validation.\n   * @summary Overrides the base updateAllPrefix method to add validation checks for multiple models.\n   * Creates a context, validates primary keys, retrieves existing models, merges old and new models,\n   * enforces decorators, and validates each model before allowing updates to proceed.\n   * Collects validation errors from all models.\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 validated models and context arguments\n   * @throws {InternalError} If any model doesn't have a primary key value\n   * @throws {ValidationError} If any model fails validation, with details about which models failed\n   */\n  protected override async updateAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args\n    );\n    const ids = models.map((m) => {\n      const id = m[this.pk];\n      if (typeof id === \"undefined\")\n        throw new InternalError(\n          `No value for the Id is defined under the property ${this.pk as string}`\n        );\n      return id as string;\n    });\n    const oldModels: M[] = await this.readAll(ids, ...contextArgs.args);\n    models = models.map((m, i) => this.merge(oldModels[i], m));\n    await Promise.all(\n      models.map((m, i) =>\n        enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.UPDATE,\n          OperationKeys.ON,\n          oldModels[i]\n        )\n      )\n    );\n\n    const errors = models\n      .map((m, i) => m.hasErrors(oldModels[i] as any))\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Creates a reflection key for database operations.\n   * @summary Generates a key for storing metadata in the reflection system by prefixing\n   * the provided key with the database reflection prefix.\n   * @param {string} key - The base key to prefix\n   * @return {string} The prefixed reflection key\n   */\n  static key(key: string) {\n    return DBKeys.REFLECT + key;\n  }\n}\n"]}

package/lib/repository/Repository.d.ts

@@ -2,11 +2,100 @@ import { BaseRepository } from "./BaseRepository";
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { Context } from "./Context";
 import { RepositoryFlags } from "./types";
+/**
+ * @description Concrete repository implementation with validation support.
+ * @summary The Repository class extends BaseRepository to provide additional validation
+ * functionality. It overrides prefix methods to perform model validation before database
+ * operations and throws ValidationError when validation fails.
+ * @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>
+ * @class Repository
+ * @example
+ * class UserModel extends Model {
+ *   @id()
+ *   id: string;
+ *
+ *   @required()
+ *   @minLength(3)
+ *   name: string;
+ * }
+ *
+ * class UserRepository extends Repository<UserModel> {
+ *   constructor() {
+ *     super(UserModel);
+ *   }
+ *
+ *   async create(model: UserModel): Promise<UserModel> {
+ *     // Implementation with automatic validation
+ *     return model;
+ *   }
+ * }
+ *
+ * // Using the repository
+ * const repo = new UserRepository();
+ * try {
+ *   const user = await repo.create({ name: 'Jo' }); // Will throw ValidationError
+ * } catch (error) {
+ *   console.error(error); // ValidationError: name must be at least 3 characters
+ * }
+ */
 export declare abstract class Repository<M extends Model, F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> extends BaseRepository<M, F, C> {
     protected constructor(clazz?: Constructor<M>);
+    /**
+     * @description Prepares a model for creation with validation.
+     * @summary Overrides the base createPrefix method to add validation checks.
+     * Creates a context, instantiates a new model, enforces decorators, and validates
+     * the model before allowing creation to proceed.
+     * @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 validated model and context arguments
+     * @throws {ValidationError} If the model fails validation
+     */
     protected createPrefix(model: M, ...args: any[]): Promise<[M, ...any[]]>;
+    /**
+     * @description Prepares multiple models for creation with validation.
+     * @summary Overrides the base createAllPrefix method to add validation checks for multiple models.
+     * Creates a context, instantiates new models, enforces decorators, and validates
+     * each model before allowing creation to proceed. Collects validation errors from all models.
+     * @param {M[]} models - The array of model instances to prepare for creation
+     * @param {any[]} args - Additional arguments for the create operation
+     * @return {Promise<any[]>} A promise that resolves to an array containing the validated models and context arguments
+     * @throws {ValidationError} If any model fails validation, with details about which models failed
+     */
     protected createAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
+    /**
+     * @description Prepares a model for update with validation.
+     * @summary Overrides the base updatePrefix method to add validation checks.
+     * Creates a context, validates the primary key, retrieves the existing model,
+     * merges the old and new models, enforces decorators, and validates the model
+     * before allowing the update to proceed.
+     * @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 validated model and context arguments
+     * @throws {InternalError} If the model doesn't have a primary key value
+     * @throws {ValidationError} If the model fails validation
+     */
     protected updatePrefix(model: M, ...args: any[]): Promise<[M, ...args: any[]]>;
+    /**
+     * @description Prepares multiple models for update with validation.
+     * @summary Overrides the base updateAllPrefix method to add validation checks for multiple models.
+     * Creates a context, validates primary keys, retrieves existing models, merges old and new models,
+     * enforces decorators, and validates each model before allowing updates to proceed.
+     * Collects validation errors from all models.
+     * @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 validated models and context arguments
+     * @throws {InternalError} If any model doesn't have a primary key value
+     * @throws {ValidationError} If any model fails validation, with details about which models failed
+     */
     protected updateAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
+    /**
+     * @description Creates a reflection key for database operations.
+     * @summary Generates a key for storing metadata in the reflection system by prefixing
+     * the provided key with the database reflection prefix.
+     * @param {string} key - The base key to prefix
+     * @return {string} The prefixed reflection key
+     */
     static key(key: string): string;
 }

package/lib/repository/constants.cjs

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultRepositoryFlags = void 0;
+/**
+ * @description Default configuration flags for repository operations.
+ * @summary Provides default values for repository operation flags, excluding the timestamp property.
+ * These flags control behavior such as context handling, validation, error handling, and more.
+ * @const DefaultRepositoryFlags
+ * @memberOf module:db-decorators
+ */
 exports.DefaultRepositoryFlags = {
     parentContext: undefined,
     childContexts: [],
@@ -12,4 +19,4 @@ exports.DefaultRepositoryFlags = {
     breakOnHandlerError: true,
     rebuildWithTransient: true,
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JlcG9zaXRvcnkvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVhLFFBQUEsc0JBQXNCLEdBQXVDO0lBQ3hFLGFBQWEsRUFBRSxTQUFTO0lBQ3hCLGFBQWEsRUFBRSxFQUFFO0lBQ2pCLDJCQUEyQixFQUFFLEVBQUU7SUFDL0IsUUFBUSxFQUFFLEVBQUU7SUFDWixjQUFjLEVBQUUsS0FBSztJQUNyQixjQUFjLEVBQUUsRUFBRTtJQUNsQixTQUFTLEVBQUUsU0FBUztJQUNwQixtQkFBbUIsRUFBRSxJQUFJO0lBQ3pCLG9CQUFvQixFQUFFLElBQUk7Q0FDM0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlcG9zaXRvcnlGbGFncyB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbmV4cG9ydCBjb25zdCBEZWZhdWx0UmVwb3NpdG9yeUZsYWdzOiBPbWl0PFJlcG9zaXRvcnlGbGFncywgXCJ0aW1lc3RhbXBcIj4gPSB7XG4gIHBhcmVudENvbnRleHQ6IHVuZGVmaW5lZCxcbiAgY2hpbGRDb250ZXh0czogW10sXG4gIGlnbm9yZWRWYWxpZGF0aW9uUHJvcGVydGllczogW10sXG4gIGNhbGxBcmdzOiBbXSxcbiAgd3JpdGVPcGVyYXRpb246IGZhbHNlLFxuICBhZmZlY3RlZFRhYmxlczogW10sXG4gIG9wZXJhdGlvbjogdW5kZWZpbmVkLFxuICBicmVha09uSGFuZGxlckVycm9yOiB0cnVlLFxuICByZWJ1aWxkV2l0aFRyYW5zaWVudDogdHJ1ZSxcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JlcG9zaXRvcnkvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBOzs7Ozs7R0FNRztBQUNVLFFBQUEsc0JBQXNCLEdBQXVDO0lBQ3hFLGFBQWEsRUFBRSxTQUFTO0lBQ3hCLGFBQWEsRUFBRSxFQUFFO0lBQ2pCLDJCQUEyQixFQUFFLEVBQUU7SUFDL0IsUUFBUSxFQUFFLEVBQUU7SUFDWixjQUFjLEVBQUUsS0FBSztJQUNyQixjQUFjLEVBQUUsRUFBRTtJQUNsQixTQUFTLEVBQUUsU0FBUztJQUNwQixtQkFBbUIsRUFBRSxJQUFJO0lBQ3pCLG9CQUFvQixFQUFFLElBQUk7Q0FDM0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJlcG9zaXRvcnlGbGFncyB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIERlZmF1bHQgY29uZmlndXJhdGlvbiBmbGFncyBmb3IgcmVwb3NpdG9yeSBvcGVyYXRpb25zLlxuICogQHN1bW1hcnkgUHJvdmlkZXMgZGVmYXVsdCB2YWx1ZXMgZm9yIHJlcG9zaXRvcnkgb3BlcmF0aW9uIGZsYWdzLCBleGNsdWRpbmcgdGhlIHRpbWVzdGFtcCBwcm9wZXJ0eS5cbiAqIFRoZXNlIGZsYWdzIGNvbnRyb2wgYmVoYXZpb3Igc3VjaCBhcyBjb250ZXh0IGhhbmRsaW5nLCB2YWxpZGF0aW9uLCBlcnJvciBoYW5kbGluZywgYW5kIG1vcmUuXG4gKiBAY29uc3QgRGVmYXVsdFJlcG9zaXRvcnlGbGFnc1xuICogQG1lbWJlck9mIG1vZHVsZTpkYi1kZWNvcmF0b3JzXG4gKi9cbmV4cG9ydCBjb25zdCBEZWZhdWx0UmVwb3NpdG9yeUZsYWdzOiBPbWl0PFJlcG9zaXRvcnlGbGFncywgXCJ0aW1lc3RhbXBcIj4gPSB7XG4gIHBhcmVudENvbnRleHQ6IHVuZGVmaW5lZCxcbiAgY2hpbGRDb250ZXh0czogW10sXG4gIGlnbm9yZWRWYWxpZGF0aW9uUHJvcGVydGllczogW10sXG4gIGNhbGxBcmdzOiBbXSxcbiAgd3JpdGVPcGVyYXRpb246IGZhbHNlLFxuICBhZmZlY3RlZFRhYmxlczogW10sXG4gIG9wZXJhdGlvbjogdW5kZWZpbmVkLFxuICBicmVha09uSGFuZGxlckVycm9yOiB0cnVlLFxuICByZWJ1aWxkV2l0aFRyYW5zaWVudDogdHJ1ZSxcbn07XG4iXX0=

package/lib/repository/constants.d.ts

@@ -1,2 +1,9 @@
 import { RepositoryFlags } from "./types";
+/**
+ * @description Default configuration flags for repository operations.
+ * @summary Provides default values for repository operation flags, excluding the timestamp property.
+ * These flags control behavior such as context handling, validation, error handling, and more.
+ * @const DefaultRepositoryFlags
+ * @memberOf module:db-decorators
+ */
 export declare const DefaultRepositoryFlags: Omit<RepositoryFlags, "timestamp">;