@decaf-ts/db-decorators 0.6.1 → 0.6.2

package/lib/esm/repository/Repository.js

@@ -1,13 +1,61 @@
-import { enforceDBDecorators } from "./utils";
-import { OperationKeys } from "../operations/constants";
-import { InternalError, ValidationError } from "./errors";
-import { BaseRepository } from "./BaseRepository";
-import { DBKeys } from "../model/constants";
-import { Context } from "./Context";
+import { enforceDBDecorators } from "./utils.js";
+import { OperationKeys } from "./../operations/constants.js";
+import { InternalError, ValidationError } from "./errors.js";
+import { BaseRepository } from "./BaseRepository.js";
+import { DBKeys } from "./../model/constants.js";
+import { Context } from "./Context.js";
+/**
+ * @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 class Repository extends 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.args(OperationKeys.CREATE, this.class, args);
         model = new this.class(model);
@@ -17,6 +65,16 @@ export class Repository extends BaseRepository {
             throw new 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.args(OperationKeys.CREATE, this.class, args);
         await Promise.all(models.map(async (m) => {
@@ -38,6 +96,18 @@ export class Repository extends BaseRepository {
             throw new 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.args(OperationKeys.UPDATE, this.class, args);
         const pk = model[this.pk];
@@ -51,6 +121,18 @@ export class Repository extends BaseRepository {
             throw new 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.args(OperationKeys.UPDATE, this.class, args);
         const ids = models.map((m) => {
@@ -76,8 +158,15 @@ export class Repository extends BaseRepository {
             throw new 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 DBKeys.REFLECT + key;
     }
 }
-//# 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/esm/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">;

package/lib/esm/repository/constants.js

@@ -1,3 +1,10 @@
+/**
+ * @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 const DefaultRepositoryFlags = {
     parentContext: undefined,
     childContexts: [],
@@ -9,4 +16,4 @@ export const DefaultRepositoryFlags = {
     breakOnHandlerError: true,
     rebuildWithTransient: true,
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3JlcG9zaXRvcnkvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUF1QztJQUN4RSxhQUFhLEVBQUUsU0FBUztJQUN4QixhQUFhLEVBQUUsRUFBRTtJQUNqQiwyQkFBMkIsRUFBRSxFQUFFO0lBQy9CLFFBQVEsRUFBRSxFQUFFO0lBQ1osY0FBYyxFQUFFLEtBQUs7SUFDckIsY0FBYyxFQUFFLEVBQUU7SUFDbEIsU0FBUyxFQUFFLFNBQVM7SUFDcEIsbUJBQW1CLEVBQUUsSUFBSTtJQUN6QixvQkFBb0IsRUFBRSxJQUFJO0NBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG5leHBvcnQgY29uc3QgRGVmYXVsdFJlcG9zaXRvcnlGbGFnczogT21pdDxSZXBvc2l0b3J5RmxhZ3MsIFwidGltZXN0YW1wXCI+ID0ge1xuICBwYXJlbnRDb250ZXh0OiB1bmRlZmluZWQsXG4gIGNoaWxkQ29udGV4dHM6IFtdLFxuICBpZ25vcmVkVmFsaWRhdGlvblByb3BlcnRpZXM6IFtdLFxuICBjYWxsQXJnczogW10sXG4gIHdyaXRlT3BlcmF0aW9uOiBmYWxzZSxcbiAgYWZmZWN0ZWRUYWJsZXM6IFtdLFxuICBvcGVyYXRpb246IHVuZGVmaW5lZCxcbiAgYnJlYWtPbkhhbmRsZXJFcnJvcjogdHJ1ZSxcbiAgcmVidWlsZFdpdGhUcmFuc2llbnQ6IHRydWUsXG59O1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3JlcG9zaXRvcnkvY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOzs7Ozs7R0FNRztBQUNILE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUF1QztJQUN4RSxhQUFhLEVBQUUsU0FBUztJQUN4QixhQUFhLEVBQUUsRUFBRTtJQUNqQiwyQkFBMkIsRUFBRSxFQUFFO0lBQy9CLFFBQVEsRUFBRSxFQUFFO0lBQ1osY0FBYyxFQUFFLEtBQUs7SUFDckIsY0FBYyxFQUFFLEVBQUU7SUFDbEIsU0FBUyxFQUFFLFNBQVM7SUFDcEIsbUJBQW1CLEVBQUUsSUFBSTtJQUN6QixvQkFBb0IsRUFBRSxJQUFJO0NBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBEZWZhdWx0IGNvbmZpZ3VyYXRpb24gZmxhZ3MgZm9yIHJlcG9zaXRvcnkgb3BlcmF0aW9ucy5cbiAqIEBzdW1tYXJ5IFByb3ZpZGVzIGRlZmF1bHQgdmFsdWVzIGZvciByZXBvc2l0b3J5IG9wZXJhdGlvbiBmbGFncywgZXhjbHVkaW5nIHRoZSB0aW1lc3RhbXAgcHJvcGVydHkuXG4gKiBUaGVzZSBmbGFncyBjb250cm9sIGJlaGF2aW9yIHN1Y2ggYXMgY29udGV4dCBoYW5kbGluZywgdmFsaWRhdGlvbiwgZXJyb3IgaGFuZGxpbmcsIGFuZCBtb3JlLlxuICogQGNvbnN0IERlZmF1bHRSZXBvc2l0b3J5RmxhZ3NcbiAqIEBtZW1iZXJPZiBtb2R1bGU6ZGItZGVjb3JhdG9yc1xuICovXG5leHBvcnQgY29uc3QgRGVmYXVsdFJlcG9zaXRvcnlGbGFnczogT21pdDxSZXBvc2l0b3J5RmxhZ3MsIFwidGltZXN0YW1wXCI+ID0ge1xuICBwYXJlbnRDb250ZXh0OiB1bmRlZmluZWQsXG4gIGNoaWxkQ29udGV4dHM6IFtdLFxuICBpZ25vcmVkVmFsaWRhdGlvblByb3BlcnRpZXM6IFtdLFxuICBjYWxsQXJnczogW10sXG4gIHdyaXRlT3BlcmF0aW9uOiBmYWxzZSxcbiAgYWZmZWN0ZWRUYWJsZXM6IFtdLFxuICBvcGVyYXRpb246IHVuZGVmaW5lZCxcbiAgYnJlYWtPbkhhbmRsZXJFcnJvcjogdHJ1ZSxcbiAgcmVidWlsZFdpdGhUcmFuc2llbnQ6IHRydWUsXG59O1xuIl19

package/lib/esm/repository/errors.d.ts

@@ -1,69 +1,96 @@
 /**
- * @summary Base Error
- *
- * @param {string} msg the error message
- *
- * @class BaseDLTError
- * @extends Error
+ * @description Base error class for the repository module
+ * @summary Abstract base error class that all other error types extend from. Provides common error handling functionality.
+ * @param {string} name - The name of the error
+ * @param {string|Error} msg - The error message or Error object
+ * @param {number} code - The HTTP status code associated with this error
+ * @class BaseError
+ * @example
+ * // This is an abstract class and should not be instantiated directly
+ * // Instead, use one of the concrete error classes:
+ * throw new ValidationError('Invalid data provided');
  */
 export declare abstract class BaseError extends Error {
     readonly code: number;
     protected constructor(name: string, msg: string | Error, code?: number);
 }
 /**
- * @summary Represents a failure in the Model details
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown when validation fails
+ * @summary Represents a failure in the Model details, typically thrown when data validation fails
+ * @param {string|Error} msg - The error message or Error object
+ * @return {ValidationError} A new ValidationError instance
  * @class ValidationError
- * @extends BaseError
+ * @example
+ * // Throw a validation error when data is invalid
+ * if (!isValid(data)) {
+ *   throw new ValidationError('Invalid data format');
+ * }
  */
 export declare class ValidationError extends BaseError {
     constructor(msg: string | Error);
 }
 /**
- * @summary Represents an internal failure (should mean an error in code)
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown for internal system failures
+ * @summary Represents an internal failure (should mean an error in code) with HTTP 500 status code
+ * @param {string|Error} msg - The error message or Error object
+ * @return {InternalError} A new InternalError instance
  * @class InternalError
- * @extends BaseError
+ * @example
+ * // Throw an internal error when an unexpected condition occurs
+ * try {
+ *   // Some operation
+ * } catch (error) {
+ *   throw new InternalError('Unexpected internal error occurred');
+ * }
  */
 export declare class InternalError extends BaseError {
     constructor(msg: string | Error);
 }
 /**
- * @summary Represents a failure in the Model de/serialization
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown when serialization or deserialization fails
+ * @summary Represents a failure in the Model de/serialization, typically when converting between data formats
+ * @param {string|Error} msg - The error message or Error object
+ * @return {SerializationError} A new SerializationError instance
  * @class SerializationError
- * @extends BaseError
- *
+ * @example
+ * // Throw a serialization error when JSON parsing fails
+ * try {
+ *   const data = JSON.parse(invalidJson);
+ * } catch (error) {
+ *   throw new SerializationError('Failed to parse JSON data');
+ * }
  */
 export declare class SerializationError extends BaseError {
     constructor(msg: string | Error);
 }
 /**
- * @summary Represents a failure in finding a model
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown when a requested resource is not found
+ * @summary Represents a failure in finding a model, resulting in a 404 HTTP status code
+ * @param {string|Error} msg - The error message or Error object
+ * @return {NotFoundError} A new NotFoundError instance
  * @class NotFoundError
- * @extends BaseError
- *
+ * @example
+ * // Throw a not found error when a record doesn't exist
+ * const user = await repository.findById(id);
+ * if (!user) {
+ *   throw new NotFoundError(`User with ID ${id} not found`);
+ * }
  */
 export declare class NotFoundError extends BaseError {
     constructor(msg: string | Error);
 }
 /**
- * @summary Represents a conflict in the storage
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown when a conflict occurs in the storage
+ * @summary Represents a conflict in the storage, typically when trying to create a duplicate resource
+ * @param {string|Error} msg - The error message or Error object
+ * @return {ConflictError} A new ConflictError instance
  * @class ConflictError
- * @extends BaseError
- *
+ * @example
+ * // Throw a conflict error when trying to create a duplicate record
+ * const existingUser = await repository.findByEmail(email);
+ * if (existingUser) {
+ *   throw new ConflictError(`User with email ${email} already exists`);
+ * }
  */
 export declare class ConflictError extends BaseError {
     constructor(msg: string | Error);

package/lib/esm/repository/errors.js

@@ -1,10 +1,14 @@
 /**
- * @summary Base Error
- *
- * @param {string} msg the error message
- *
- * @class BaseDLTError
- * @extends Error
+ * @description Base error class for the repository module
+ * @summary Abstract base error class that all other error types extend from. Provides common error handling functionality.
+ * @param {string} name - The name of the error
+ * @param {string|Error} msg - The error message or Error object
+ * @param {number} code - The HTTP status code associated with this error
+ * @class BaseError
+ * @example
+ * // This is an abstract class and should not be instantiated directly
+ * // Instead, use one of the concrete error classes:
+ * throw new ValidationError('Invalid data provided');
  */
 export class BaseError extends Error {
     constructor(name, msg, code = 500) {
@@ -18,12 +22,16 @@ export class BaseError extends Error {
     }
 }
 /**
- * @summary Represents a failure in the Model details
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown when validation fails
+ * @summary Represents a failure in the Model details, typically thrown when data validation fails
+ * @param {string|Error} msg - The error message or Error object
+ * @return {ValidationError} A new ValidationError instance
  * @class ValidationError
- * @extends BaseError
+ * @example
+ * // Throw a validation error when data is invalid
+ * if (!isValid(data)) {
+ *   throw new ValidationError('Invalid data format');
+ * }
  */
 export class ValidationError extends BaseError {
     constructor(msg) {
@@ -31,12 +39,18 @@ export class ValidationError extends BaseError {
     }
 }
 /**
- * @summary Represents an internal failure (should mean an error in code)
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown for internal system failures
+ * @summary Represents an internal failure (should mean an error in code) with HTTP 500 status code
+ * @param {string|Error} msg - The error message or Error object
+ * @return {InternalError} A new InternalError instance
  * @class InternalError
- * @extends BaseError
+ * @example
+ * // Throw an internal error when an unexpected condition occurs
+ * try {
+ *   // Some operation
+ * } catch (error) {
+ *   throw new InternalError('Unexpected internal error occurred');
+ * }
  */
 export class InternalError extends BaseError {
     constructor(msg) {
@@ -44,13 +58,18 @@ export class InternalError extends BaseError {
     }
 }
 /**
- * @summary Represents a failure in the Model de/serialization
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown when serialization or deserialization fails
+ * @summary Represents a failure in the Model de/serialization, typically when converting between data formats
+ * @param {string|Error} msg - The error message or Error object
+ * @return {SerializationError} A new SerializationError instance
  * @class SerializationError
- * @extends BaseError
- *
+ * @example
+ * // Throw a serialization error when JSON parsing fails
+ * try {
+ *   const data = JSON.parse(invalidJson);
+ * } catch (error) {
+ *   throw new SerializationError('Failed to parse JSON data');
+ * }
  */
 export class SerializationError extends BaseError {
     constructor(msg) {
@@ -58,13 +77,17 @@ export class SerializationError extends BaseError {
     }
 }
 /**
- * @summary Represents a failure in finding a model
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown when a requested resource is not found
+ * @summary Represents a failure in finding a model, resulting in a 404 HTTP status code
+ * @param {string|Error} msg - The error message or Error object
+ * @return {NotFoundError} A new NotFoundError instance
  * @class NotFoundError
- * @extends BaseError
- *
+ * @example
+ * // Throw a not found error when a record doesn't exist
+ * const user = await repository.findById(id);
+ * if (!user) {
+ *   throw new NotFoundError(`User with ID ${id} not found`);
+ * }
  */
 export class NotFoundError extends BaseError {
     constructor(msg) {
@@ -72,17 +95,21 @@ export class NotFoundError extends BaseError {
     }
 }
 /**
- * @summary Represents a conflict in the storage
- *
- * @param {string} msg the error message
- *
+ * @description Error thrown when a conflict occurs in the storage
+ * @summary Represents a conflict in the storage, typically when trying to create a duplicate resource
+ * @param {string|Error} msg - The error message or Error object
+ * @return {ConflictError} A new ConflictError instance
  * @class ConflictError
- * @extends BaseError
- *
+ * @example
+ * // Throw a conflict error when trying to create a duplicate record
+ * const existingUser = await repository.findByEmail(email);
+ * if (existingUser) {
+ *   throw new ConflictError(`User with email ${email} already exists`);
+ * }
  */
 export class ConflictError extends BaseError {
     constructor(msg) {
         super(ConflictError.name, msg, 409);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/repository/index.js

@@ -1,9 +1,9 @@
-export * from "./BaseRepository";
-export * from "./constants";
-export * from "./Context";
-export * from "./errors";
-export * from "./Repository";
-export * from "./types";
-export * from "./utils";
-export * from "./wrappers";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVwb3NpdG9yeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vQmFzZVJlcG9zaXRvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vQ29udGV4dFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZXJyb3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9SZXBvc2l0b3J5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3dyYXBwZXJzXCI7XG4iXX0=
+export * from "./BaseRepository.js";
+export * from "./constants.js";
+export * from "./Context.js";
+export * from "./errors.js";
+export * from "./Repository.js";
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./wrappers.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVwb3NpdG9yeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxvQ0FBaUM7QUFDakMsK0JBQTRCO0FBQzVCLDZCQUEwQjtBQUMxQiw0QkFBeUI7QUFDekIsZ0NBQTZCO0FBQzdCLDJCQUF3QjtBQUN4QiwyQkFBd0I7QUFDeEIsOEJBQTJCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vQmFzZVJlcG9zaXRvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vQ29udGV4dFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZXJyb3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9SZXBvc2l0b3J5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3dyYXBwZXJzXCI7XG4iXX0=

package/lib/esm/repository/types.d.ts

@@ -1,7 +1,32 @@
 import { Context } from "./Context";
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { OperationKeys } from "../operations";
+/**
+ * @description Type utility for ensuring model extension.
+ * @summary A conditional type that ensures a type extends the Model class.
+ * If the type extends Model, it returns the type; otherwise, it returns never.
+ * @template M - The type to check, defaults to Model
+ * @typedef {M extends Model ? M : never} ModelExtension
+ * @memberOf module:db-decorators
+ */
 type ModelExtension<M extends Model = Model> = M extends Model ? M : never;
+/**
+ * @description Configuration flags for repository operations.
+ * @summary Defines the configuration options that control repository behavior during operations.
+ * These flags manage context relationships, validation behavior, operation metadata, and error handling.
+ * @typedef {Object} RepositoryFlags
+ * @property {Context} [parentContext] - The parent context for hierarchical operations
+ * @property {Context[]} [childContexts] - Child contexts spawned from this context
+ * @property {any[]} [callArgs] - Arguments passed to the operation
+ * @property {string[]} ignoredValidationProperties - Properties to exclude from validation
+ * @property affectedTables - Tables or models affected by the operation
+ * @property {boolean} writeOperation - Whether the operation modifies data
+ * @property {Date} timestamp - When the operation was initiated
+ * @property {OperationKeys} [operation] - The type of operation being performed
+ * @property {boolean} breakOnHandlerError - Whether to stop processing on handler errors
+ * @property {boolean} rebuildWithTransient - Whether to include transient properties when rebuilding models
+ * @memberOf module:db-decorators
+ */
 export type RepositoryFlags = {
     parentContext?: Context<any>;
     childContexts?: Context<any>[];

package/lib/esm/repository/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVwb3NpdG9yeS90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udGV4dCB9IGZyb20gXCIuL0NvbnRleHRcIjtcbmltcG9ydCB7IENvbnN0cnVjdG9yLCBNb2RlbCB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IE9wZXJhdGlvbktleXMgfSBmcm9tIFwiLi4vb3BlcmF0aW9uc1wiO1xuXG50eXBlIE1vZGVsRXh0ZW5zaW9uPE0gZXh0ZW5kcyBNb2RlbCA9IE1vZGVsPiA9IE0gZXh0ZW5kcyBNb2RlbCA/IE0gOiBuZXZlcjtcblxuZXhwb3J0IHR5cGUgUmVwb3NpdG9yeUZsYWdzID0ge1xuICBwYXJlbnRDb250ZXh0PzogQ29udGV4dDxhbnk+O1xuICBjaGlsZENvbnRleHRzPzogQ29udGV4dDxhbnk+W107XG4gIGNhbGxBcmdzPzogYW55W107XG4gIGlnbm9yZWRWYWxpZGF0aW9uUHJvcGVydGllczogc3RyaW5nW107XG4gIGFmZmVjdGVkVGFibGVzOlxuICAgIHwgKHN0cmluZyB8IENvbnN0cnVjdG9yPE1vZGVsRXh0ZW5zaW9uPilbXVxuICAgIHwgc3RyaW5nXG4gICAgfCBDb25zdHJ1Y3RvcjxNb2RlbEV4dGVuc2lvbj47XG4gIHdyaXRlT3BlcmF0aW9uOiBib29sZWFuO1xuICB0aW1lc3RhbXA6IERhdGU7XG4gIG9wZXJhdGlvbj86IE9wZXJhdGlvbktleXM7XG4gIGJyZWFrT25IYW5kbGVyRXJyb3I6IGJvb2xlYW47XG4gIHJlYnVpbGRXaXRoVHJhbnNpZW50OiBib29sZWFuO1xufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/repository/utils.d.ts

@@ -3,6 +3,17 @@ import { DecoratorMetadata } from "@decaf-ts/reflection";
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { Context } from "./Context";
 import { RepositoryFlags } from "./types";
+/**
+ * @description Context arguments for repository operations.
+ * @summary Represents the context and arguments for repository operations.
+ * This type is used to pass context and arguments between repository methods.
+ * @template F - The repository flags type, defaults to RepositoryFlags
+ * @template C - The context type, defaults to Context<F>
+ * @typedef {Object} ContextArgs
+ * @property {C} context - The operation context
+ * @property {any[]} args - The operation arguments
+ * @memberOf module:db-decorators
+ */
 export type ContextArgs<F extends RepositoryFlags = RepositoryFlags, C extends Context<F> = Context<F>> = {
     context: C;
     args: any[];