@decaf-ts/db-decorators 0.3.1 → 0.4.0

package/lib/esm/model/decorators.js

@@ -1,6 +1,6 @@
 import { DBKeys, DefaultSeparator } from "./constants";
 import { apply } from "@decaf-ts/reflection";
-import { Hashing, propMetadata, sf } from "@decaf-ts/decorator-validation";
+import { Hashing, propMetadata, sf, } from "@decaf-ts/decorator-validation";
 import { onCreateUpdate } from "../operations/decorators";
 import { InternalError } from "../repository/errors";
 import { Repository } from "../repository/Repository";
@@ -20,7 +20,7 @@ export function hashOnCreateUpdate(data, key, model, oldModel) {
 export function hash() {
     return apply(onCreateUpdate(hashOnCreateUpdate), propMetadata(Repository.key(DBKeys.HASH), {}));
 }
-export function composedFromCreateUpdate(data, key, model) {
+export function composedFromCreateUpdate(context, data, key, model) {
     try {
         const { args, type, prefix, suffix, separator } = data;
         const composed = args.map((arg) => {
@@ -66,4 +66,4 @@ export function composed(args, separator = DefaultSeparator, hash = false, prefi
     return composedFrom(args, hash, separator, "values", prefix, suffix);
 }
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/model/model.d.ts

@@ -1,8 +1,112 @@
-import { Comparable, Hashable, ModelArg, ModelErrorDefinition, Serializable, Validatable } from "@decaf-ts/decorator-validation";
-declare global {
-    export abstract class Model implements Validatable, Serializable, Hashable, Comparable<Model> {
+import { Comparable, Hashable, ModelArg, ModelErrorDefinition, Serializable, Validatable, Constructor, ModelBuilderFunction, BuilderRegistry, ModelConstructor } from "@decaf-ts/decorator-validation";
+declare module "@decaf-ts/decorator-validation" {
+    abstract class Model implements Validatable, Serializable, Hashable, Comparable<Model> {
         protected constructor(arg?: ModelArg<Model>);
         hasErrors(...exclusions: any[]): ModelErrorDefinition | undefined;
         hasErrors(previousVersion?: Model | any, ...exclusions: any[]): ModelErrorDefinition | undefined;
+        /**
+         * @summary Compare object equality recursively
+         * @param {any} obj object to compare to
+         * @param {string} [exceptions] property names to be excluded from the comparison
+         */
+        equals(obj: any, ...exceptions: string[]): boolean;
+        /**
+         * @summary Returns the serialized model according to the currently defined {@link Serializer}
+         */
+        serialize(): string;
+        /**
+         * @summary Override the implementation for js's 'toString()' which sucks...
+         * @override
+         */
+        toString(): string;
+        /**
+         * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;
+         */
+        hash(): string;
+        /**
+         * @summary Deserializes a Model
+         * @param {string} str
+         *
+         * @param args
+         * @throws {Error} If it fails to parse the string, or if it fails to build the model
+         */
+        static deserialize(str: string): any;
+        /**
+         * @summary Repopulates the Object properties with the ones from the new object
+         * @description Iterates all common properties of obj (if existing) and self, and copies them onto self
+         *
+         * @param {T} self
+         * @param {T | Record<string, any>} [obj]
+         *
+         */
+        static fromObject<T extends Model>(self: T, obj?: T | Record<string, any>): T;
+        /**
+         * @summary Repopulates the instance with the ones from the new Model Object
+         * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.
+         * Is aware of nested Model Objects and rebuilds them also.
+         * When List properties are decorated with {@link list}, they list items will also be rebuilt
+         *
+         * @param {T} self
+         * @param {T | Record<string, any>} [obj]
+         *
+         */
+        static fromModel<T extends Model>(self: T, obj?: T | Record<string, any>): T;
+        /**
+         * @summary Sets the Global {@link ModelBuilderFunction}
+         * @param {ModelBuilderFunction} [builder]
+         */
+        static setBuilder(builder?: ModelBuilderFunction): void;
+        /**
+         * @summary Retrieves the current global {@link ModelBuilderFunction}
+         */
+        static getBuilder(): ModelBuilderFunction | undefined;
+        /**
+         * Returns the current {@link ModelRegistryManager}
+         *
+         * @return ModelRegistry, defaults to {@link ModelRegistryManager}
+         */
+        private static getRegistry;
+        /**
+         * Returns the current actingModelRegistry
+         *
+         * @param {BuilderRegistry} modelRegistry the new implementation of Registry
+         */
+        static setRegistry(modelRegistry: BuilderRegistry<any>): void;
+        /**
+         * @summary register new Models
+         * @param {any} constructor
+         * @param {string} [name] when not defined, the name of the constructor will be used
+         *
+         * @see ModelRegistry
+         */
+        static register<T extends Model>(constructor: ModelConstructor<T>, name?: string): void;
+        /**
+         * @summary Gets a registered Model {@link ModelConstructor}
+         * @param {string} name
+         *
+         * @see ModelRegistry
+         */
+        static get<T extends Model>(name: string): ModelConstructor<T> | undefined;
+        /**
+         * @param {Record<string, any>} obj
+         * @param {string} [clazz] when provided, it will attempt to find the matching constructor
+         *
+         * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property
+         *
+         * @see ModelRegistry
+         */
+        static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;
+        static getMetadata<V extends Model>(model: V): any;
+        static getAttributes<V extends Model>(model: Constructor<V> | V): string[];
+        static equals<V extends Model>(obj1: V, obj2: V, ...exceptions: any[]): boolean;
+        static hasErrors<V extends Model>(model: V, ...exceptions: any[]): ModelErrorDefinition | undefined;
+        static serialize<V extends Model>(model: V): any;
+        static hash<V extends Model>(model: V): any;
+        /**
+         * @summary Builds the key to store as Metadata under Reflections
+         * @description concatenates {@link ModelKeys#REFLECT} with the provided key
+         * @param {string} str
+         */
+        static key(str: string): string;
     }
 }

package/lib/esm/model/model.js

@@ -11,4 +11,4 @@ Model.prototype.hasErrors = function (previousVersion, ...exclusions) {
     return validateCompare(previousVersion, this, ...exclusions);
 };
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/model/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,EACL,QAAQ,GAKT,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C,KAAK,CAAC,SAAS,CAAC,SAAS,GAAG,UAE1B,eAAyB,EACzB,GAAG,UAAiB;IAEpB,IAAI,eAAe,IAAI,CAAC,CAAC,eAAe,YAAY,KAAK,CAAC,EAAE,CAAC;QAC3D,UAAU,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QACpC,eAAe,GAAG,SAAS,CAAC;IAC9B,CAAC;IAED,MAAM,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,GAAG,UAAU,CAAC,CAAC;IAC3C,IAAI,IAAI,IAAI,CAAC,eAAe;QAAE,OAAO,IAAI,CAAC;IAE1C,OAAO,eAAe,CAAC,eAAe,EAAE,IAAI,EAAE,GAAG,UAAU,CAAC,CAAC;AAC/D,CAAC,CAAC","file":"model/model.js","sourcesContent":["import {\n  Comparable,\n  Hashable,\n  ModelArg,\n  ModelErrorDefinition,\n  Serializable,\n  Validatable,\n  Model,\n  validate,\n  Constructor,\n  ModelBuilderFunction,\n  BuilderRegistry,\n  ModelConstructor,\n} from \"@decaf-ts/decorator-validation\";\nimport { validateCompare } from \"./validation\";\n\nModel.prototype.hasErrors = function <M extends Model>(\n  this: M,\n  previousVersion?: M | any,\n  ...exclusions: any[]\n): ModelErrorDefinition | undefined {\n  if (previousVersion && !(previousVersion instanceof Model)) {\n    exclusions.unshift(previousVersion);\n    previousVersion = undefined;\n  }\n\n  const errs = validate(this, ...exclusions);\n  if (errs || !previousVersion) return errs;\n\n  return validateCompare(previousVersion, this, ...exclusions);\n};\n\ndeclare module \"@decaf-ts/decorator-validation\" {\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-expect-error\n  declare abstract class Model\n    implements Validatable, Serializable, Hashable, Comparable<Model>\n  {\n    protected constructor(arg?: ModelArg<Model>);\n\n    hasErrors(...exclusions: any[]): ModelErrorDefinition | undefined;\n    hasErrors(\n      previousVersion?: Model | any,\n      ...exclusions: any[]\n    ): ModelErrorDefinition | undefined;\n\n    /**\n     * @summary Compare object equality recursively\n     * @param {any} obj object to compare to\n     * @param {string} [exceptions] property names to be excluded from the comparison\n     */\n    equals(obj: any, ...exceptions: string[]): boolean;\n    /**\n     * @summary Returns the serialized model according to the currently defined {@link Serializer}\n     */\n    serialize(): string;\n    /**\n     * @summary Override the implementation for js's 'toString()' which sucks...\n     * @override\n     */\n    toString(): string;\n    /**\n     * @summary Defines a default implementation for object hash. Relies on a very basic implementation based on Java's string hash;\n     */\n    hash(): string;\n    /**\n     * @summary Deserializes a Model\n     * @param {string} str\n     *\n     * @param args\n     * @throws {Error} If it fails to parse the string, or if it fails to build the model\n     */\n    static deserialize(str: string): any;\n    /**\n     * @summary Repopulates the Object properties with the ones from the new object\n     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self\n     *\n     * @param {T} self\n     * @param {T | Record<string, any>} [obj]\n     *\n     */\n    static fromObject<T extends Model>(\n      self: T,\n      obj?: T | Record<string, any>\n    ): T;\n    /**\n     * @summary Repopulates the instance with the ones from the new Model Object\n     * @description Iterates all common properties of obj (if existing) and self, and copies them onto self.\n     * Is aware of nested Model Objects and rebuilds them also.\n     * When List properties are decorated with {@link list}, they list items will also be rebuilt\n     *\n     * @param {T} self\n     * @param {T | Record<string, any>} [obj]\n     *\n     */\n    static fromModel<T extends Model>(\n      self: T,\n      obj?: T | Record<string, any>\n    ): T;\n    /**\n     * @summary Sets the Global {@link ModelBuilderFunction}\n     * @param {ModelBuilderFunction} [builder]\n     */\n    static setBuilder(builder?: ModelBuilderFunction): void;\n    /**\n     * @summary Retrieves the current global {@link ModelBuilderFunction}\n     */\n    static getBuilder(): ModelBuilderFunction | undefined;\n    /**\n     * Returns the current {@link ModelRegistryManager}\n     *\n     * @return ModelRegistry, defaults to {@link ModelRegistryManager}\n     */\n    private static getRegistry;\n    /**\n     * Returns the current actingModelRegistry\n     *\n     * @param {BuilderRegistry} modelRegistry the new implementation of Registry\n     */\n    static setRegistry(modelRegistry: BuilderRegistry<any>): void;\n    /**\n     * @summary register new Models\n     * @param {any} constructor\n     * @param {string} [name] when not defined, the name of the constructor will be used\n     *\n     * @see ModelRegistry\n     */\n    static register<T extends Model>(\n      constructor: ModelConstructor<T>,\n      name?: string\n    ): void;\n    /**\n     * @summary Gets a registered Model {@link ModelConstructor}\n     * @param {string} name\n     *\n     * @see ModelRegistry\n     */\n    static get<T extends Model>(name: string): ModelConstructor<T> | undefined;\n    /**\n     * @param {Record<string, any>} obj\n     * @param {string} [clazz] when provided, it will attempt to find the matching constructor\n     *\n     * @throws Error If clazz is not found, or obj is not a {@link Model} meaning it has no {@link ModelKeys.ANCHOR} property\n     *\n     * @see ModelRegistry\n     */\n    static build<T extends Model>(obj?: Record<string, any>, clazz?: string): T;\n    static getMetadata<V extends Model>(model: V): any;\n    static getAttributes<V extends Model>(model: Constructor<V> | V): string[];\n    static equals<V extends Model>(\n      obj1: V,\n      obj2: V,\n      ...exceptions: any[]\n    ): boolean;\n    static hasErrors<V extends Model>(\n      model: V,\n      ...exceptions: any[]\n    ): ModelErrorDefinition | undefined;\n    static serialize<V extends Model>(model: V): any;\n    static hash<V extends Model>(model: V): any;\n    /**\n     * @summary Builds the key to store as Metadata under Reflections\n     * @description concatenates {@link ModelKeys#REFLECT} with the provided key\n     * @param {string} str\n     */\n    static key(str: string): string;\n  }\n}\n"]}

package/lib/esm/model/validation.d.ts

@@ -1,4 +1,4 @@
-import { ModelErrorDefinition } from "@decaf-ts/decorator-validation";
+import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
 /**
  * @summary Validates the update of a model
  *

package/lib/esm/model/validation.js

@@ -119,4 +119,4 @@ export function validateCompare(oldModel, newModel, ...exceptions) {
     return result ? new ModelErrorDefinition(result) : undefined;
 }
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/model/validation.ts"],"names":[],"mappings":"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","file":"model/validation.js","sourcesContent":["import {\n  ModelErrorDefinition,\n  ModelErrors,\n  ModelKeys,\n  ReservedModels,\n  sf,\n  Validatable,\n  Validation,\n  ValidationKeys,\n  ValidationPropertyDecoratorDefinition,\n} from \"@decaf-ts/decorator-validation\";\nimport { DecoratorMetadata, getPropertyDecorators } from \"@decaf-ts/reflection\";\nimport { UpdateValidationKeys, UpdateValidator } from \"../validation\";\nimport { findModelId } from \"../identity\";\n\n/**\n * @summary Validates the update of a model\n *\n * @param {T} oldModel\n * @param {T} newModel\n * @param {string[]} [exceptions]\n *\n * @function validateCompare\n * @return {ModelErrorDefinition | undefined}\n *\n * @memberOf module:db-decorators.Model\n */\nexport function validateCompare<T extends Model>(\n  oldModel: T,\n  newModel: T,\n  ...exceptions: string[]\n): ModelErrorDefinition | undefined {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n  for (const prop in newModel)\n    if (\n      Object.prototype.hasOwnProperty.call(newModel, prop) &&\n      exceptions.indexOf(prop) === -1\n    )\n      decoratedProperties.push(\n        getPropertyDecorators(\n          UpdateValidationKeys.REFLECT,\n          newModel,\n          prop\n        ) as ValidationPropertyDecoratorDefinition\n      );\n\n  let result: ModelErrors | undefined = undefined;\n\n  for (const decoratedProperty of decoratedProperties) {\n    const { prop, decorators } = decoratedProperty;\n\n    decorators.shift(); // remove the design:type decorator, since the type will already be checked\n\n    if (!decorators || !decorators.length) continue;\n    let errs: Record<string, string | undefined> | undefined = undefined;\n\n    for (const decorator of decorators) {\n      const validator: UpdateValidator = Validation.get(\n        decorator.key\n      ) as UpdateValidator;\n      if (!validator) {\n        console.error(\n          `Could not find Matching validator for ${decorator.key} for property ${String(decoratedProperty.prop)}`\n        );\n        continue;\n      }\n\n      const err: string | undefined = validator.updateHasErrors(\n        (newModel as any)[prop.toString()],\n        (oldModel as any)[prop.toString()],\n        ...Object.values(decorator.props)\n      );\n\n      if (err) {\n        errs = errs || {};\n        errs[decorator.key] = err;\n      }\n    }\n\n    if (errs) {\n      result = result || {};\n      result[decoratedProperty.prop.toString()] = errs;\n    }\n  }\n  // tests nested classes\n  for (const prop of Object.keys(newModel).filter(\n    (k) => !result || !result[k]\n  )) {\n    let err: string | undefined;\n    // if a nested Model\n    const allDecorators = getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      newModel,\n      prop\n    ).decorators;\n    const decorators = getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      newModel,\n      prop\n    ).decorators.filter(\n      (d) => [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1\n    );\n    if (!decorators || !decorators.length) continue;\n    const dec = decorators.pop() as DecoratorMetadata;\n    const clazz = dec.props.name\n      ? [dec.props.name]\n      : Array.isArray(dec.props.customTypes)\n        ? dec.props.customTypes\n        : [dec.props.customTypes];\n    const reserved = Object.values(ReservedModels).map((v) =>\n      v.toLowerCase()\n    ) as string[];\n\n    for (const c of clazz) {\n      if (reserved.indexOf(c.toLowerCase()) === -1) {\n        switch (c) {\n          case Array.name:\n          case Set.name:\n            if (allDecorators.length) {\n              const listDec = allDecorators.find(\n                (d) => d.key === ValidationKeys.LIST\n              );\n              if (listDec) {\n                let currentList, oldList;\n\n                switch (c) {\n                  case Array.name:\n                    currentList = (newModel as Record<string, any>)[prop];\n                    oldList = (oldModel as Record<string, any>)[prop];\n                    break;\n                  case Set.name:\n                    currentList = (newModel as Record<string, any>)[\n                      prop\n                    ].values();\n                    oldList = (oldModel as Record<string, any>)[prop].values();\n                    break;\n                  default:\n                    throw new Error(`Invalid attribute type ${c}`);\n                }\n\n                err = currentList\n                  .map((v: Validatable) => {\n                    const id = findModelId(v as any, true);\n                    if (!id) return \"Failed to find model id\";\n                    const oldModel = oldList.find(\n                      (el: any) => id === findModelId(el, true)\n                    );\n\n                    if (!oldModel) return; // nothing to compare with\n                    return v.hasErrors(oldModel);\n                  })\n                  .filter((e: any) => !!e) as any;\n\n                if (!err?.length) {\n                  // if the result is an empty list...\n                  err = undefined;\n                }\n              }\n            }\n            break;\n          default:\n            try {\n              if (\n                (newModel as Record<string, any>)[prop] &&\n                (oldModel as Record<string, any>)[prop]\n              )\n                err = (newModel as Record<string, any>)[prop].hasErrors(\n                  (oldModel as Record<string, any>)[prop]\n                );\n              // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            } catch (e: any) {\n              console.warn(sf(\"Model should be validatable but its not\"));\n            }\n        }\n      }\n      if (err) {\n        result = result || {};\n        result[prop] = err as any;\n      }\n    }\n  }\n  return result ? new ModelErrorDefinition(result) : undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/model/validation.ts"],"names":[],"mappings":"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","file":"model/validation.js","sourcesContent":["import {\n  Model,\n  ModelErrorDefinition,\n  ModelErrors,\n  ModelKeys,\n  ReservedModels,\n  sf,\n  Validatable,\n  Validation,\n  ValidationKeys,\n  ValidationPropertyDecoratorDefinition,\n} from \"@decaf-ts/decorator-validation\";\nimport { DecoratorMetadata, getPropertyDecorators } from \"@decaf-ts/reflection\";\nimport { UpdateValidationKeys, UpdateValidator } from \"../validation\";\nimport { findModelId } from \"../identity\";\n\n/**\n * @summary Validates the update of a model\n *\n * @param {T} oldModel\n * @param {T} newModel\n * @param {string[]} [exceptions]\n *\n * @function validateCompare\n * @return {ModelErrorDefinition | undefined}\n *\n * @memberOf module:db-decorators.Model\n */\nexport function validateCompare<T extends Model>(\n  oldModel: T,\n  newModel: T,\n  ...exceptions: string[]\n): ModelErrorDefinition | undefined {\n  const decoratedProperties: ValidationPropertyDecoratorDefinition[] = [];\n  for (const prop in newModel)\n    if (\n      Object.prototype.hasOwnProperty.call(newModel, prop) &&\n      exceptions.indexOf(prop) === -1\n    )\n      decoratedProperties.push(\n        getPropertyDecorators(\n          UpdateValidationKeys.REFLECT,\n          newModel,\n          prop\n        ) as ValidationPropertyDecoratorDefinition\n      );\n\n  let result: ModelErrors | undefined = undefined;\n\n  for (const decoratedProperty of decoratedProperties) {\n    const { prop, decorators } = decoratedProperty;\n\n    decorators.shift(); // remove the design:type decorator, since the type will already be checked\n\n    if (!decorators || !decorators.length) continue;\n    let errs: Record<string, string | undefined> | undefined = undefined;\n\n    for (const decorator of decorators) {\n      const validator: UpdateValidator = Validation.get(\n        decorator.key\n      ) as UpdateValidator;\n      if (!validator) {\n        console.error(\n          `Could not find Matching validator for ${decorator.key} for property ${String(decoratedProperty.prop)}`\n        );\n        continue;\n      }\n\n      const err: string | undefined = validator.updateHasErrors(\n        (newModel as any)[prop.toString()],\n        (oldModel as any)[prop.toString()],\n        ...Object.values(decorator.props)\n      );\n\n      if (err) {\n        errs = errs || {};\n        errs[decorator.key] = err;\n      }\n    }\n\n    if (errs) {\n      result = result || {};\n      result[decoratedProperty.prop.toString()] = errs;\n    }\n  }\n  // tests nested classes\n  for (const prop of Object.keys(newModel).filter(\n    (k) => !result || !result[k]\n  )) {\n    let err: string | undefined;\n    // if a nested Model\n    const allDecorators = getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      newModel,\n      prop\n    ).decorators;\n    const decorators = getPropertyDecorators(\n      ValidationKeys.REFLECT,\n      newModel,\n      prop\n    ).decorators.filter(\n      (d) => [ModelKeys.TYPE, ValidationKeys.TYPE].indexOf(d.key) !== -1\n    );\n    if (!decorators || !decorators.length) continue;\n    const dec = decorators.pop() as DecoratorMetadata;\n    const clazz = dec.props.name\n      ? [dec.props.name]\n      : Array.isArray(dec.props.customTypes)\n        ? dec.props.customTypes\n        : [dec.props.customTypes];\n    const reserved = Object.values(ReservedModels).map((v) =>\n      v.toLowerCase()\n    ) as string[];\n\n    for (const c of clazz) {\n      if (reserved.indexOf(c.toLowerCase()) === -1) {\n        switch (c) {\n          case Array.name:\n          case Set.name:\n            if (allDecorators.length) {\n              const listDec = allDecorators.find(\n                (d) => d.key === ValidationKeys.LIST\n              );\n              if (listDec) {\n                let currentList, oldList;\n\n                switch (c) {\n                  case Array.name:\n                    currentList = (newModel as Record<string, any>)[prop];\n                    oldList = (oldModel as Record<string, any>)[prop];\n                    break;\n                  case Set.name:\n                    currentList = (newModel as Record<string, any>)[\n                      prop\n                    ].values();\n                    oldList = (oldModel as Record<string, any>)[prop].values();\n                    break;\n                  default:\n                    throw new Error(`Invalid attribute type ${c}`);\n                }\n\n                err = currentList\n                  .map((v: Validatable) => {\n                    const id = findModelId(v as any, true);\n                    if (!id) return \"Failed to find model id\";\n                    const oldModel = oldList.find(\n                      (el: any) => id === findModelId(el, true)\n                    );\n\n                    if (!oldModel) return; // nothing to compare with\n                    return v.hasErrors(oldModel);\n                  })\n                  .filter((e: any) => !!e) as any;\n\n                if (!err?.length) {\n                  // if the result is an empty list...\n                  err = undefined;\n                }\n              }\n            }\n            break;\n          default:\n            try {\n              if (\n                (newModel as Record<string, any>)[prop] &&\n                (oldModel as Record<string, any>)[prop]\n              )\n                err = (newModel as Record<string, any>)[prop].hasErrors(\n                  (oldModel as Record<string, any>)[prop]\n                );\n              // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            } catch (e: any) {\n              console.warn(sf(\"Model should be validatable but its not\"));\n            }\n        }\n      }\n      if (err) {\n        result = result || {};\n        result[prop] = err as any;\n      }\n    }\n  }\n  return result ? new ModelErrorDefinition(result) : undefined;\n}\n"]}

package/lib/esm/operations/Operations.d.ts

@@ -1,3 +1,4 @@
+import { Model } from "@decaf-ts/decorator-validation";
 import { OperationHandler } from "./types";
 import { OperationKeys } from "./constants";
 /**

package/lib/esm/operations/Operations.js

@@ -32,4 +32,4 @@ export class Operations {
     }
 }
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/operations/OperationsRegistry.d.ts

@@ -1,6 +1,7 @@
 import { OperationHandler } from "./types";
 import { OperationKeys } from "./constants";
 import { IRepository } from "../interfaces/IRepository";
+import { Model } from "@decaf-ts/decorator-validation";
 /**
  * @summary Holds the registered operation handlers
  *

package/lib/esm/operations/OperationsRegistry.js

@@ -62,4 +62,4 @@ export class OperationsRegistry {
     }
 }
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/lib/esm/operations/decorators.d.ts

@@ -32,7 +32,7 @@ export declare function onUpdate<T>(handler: UpdateOperationHandler<any, any, T>
  * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE}
  *
  * @param {OnOperationHandler<any>} handler The method called upon the operation
- * @param data?
+ * @param data
  *
  * @see on
  *
@@ -66,7 +66,20 @@ export declare function onRead<T>(handler: IdOperationHandler<any, any, T>, data
  *
  * @category Decorators
  */
-export declare function onDelete<T>(handler: IdOperationHandler<any, any, T>, data: T): (target: object, propertyKey: string | symbol) => void;
+export declare function onDelete<T>(handler: OperationHandler<any, any, T>, data: T): (target: object, propertyKey: string | symbol) => void;
+/**
+ * @summary Defines a behaviour to set on the defined {@link DBOperations.DELETE}
+ *
+ * @param {OnOperationHandler<any>} handler The method called upon the operation
+ * @param data
+ *
+ * @see on
+ *
+ * @function onAny
+ *
+ * @category Decorators
+ */
+export declare function onAny<T>(handler: OperationHandler<any, any, T>, data: T): (target: object, propertyKey: string | symbol) => void;
 /**
  * @summary Defines a behaviour to set on the defined {@link DBOperations}
  *
@@ -148,6 +161,20 @@ export declare function afterRead<T>(handler: StandardOperationHandler<any, any,
  * @category Decorators
  */
 export declare function afterDelete<T>(handler: StandardOperationHandler<any, any, T>, data?: T): (target: object, propertyKey: string | symbol) => void;
+/**
+ * @summary Defines a behaviour to set after the defined {@link DBOperations.DELETE}
+ *
+ * @param {AfterOperationHandler<any>} handler The method called upon the operation
+ * @param data
+ * @param {any[]} [args] Arguments that will be passed in order to the handler method
+ *
+ * @see after
+ *
+ * @function afterAny
+ *
+ * @category Decorators
+ */
+export declare function afterAny<T>(handler: StandardOperationHandler<any, any, T>, data?: T): (target: object, propertyKey: string | symbol) => void;
 /**
  * @summary Defines a behaviour to set on the defined {@link DBOperations}
  *

package/lib/esm/operations/decorators.js

@@ -43,7 +43,7 @@ export function onUpdate(handler, data) {
  * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE}
  *
  * @param {OnOperationHandler<any>} handler The method called upon the operation
- * @param data?
+ * @param data
  *
  * @see on
  *
@@ -84,6 +84,21 @@ export function onRead(handler, data) {
 export function onDelete(handler, data) {
     return on(DBOperations.DELETE, handler, data);
 }
+/**
+ * @summary Defines a behaviour to set on the defined {@link DBOperations.DELETE}
+ *
+ * @param {OnOperationHandler<any>} handler The method called upon the operation
+ * @param data
+ *
+ * @see on
+ *
+ * @function onAny
+ *
+ * @category Decorators
+ */
+export function onAny(handler, data) {
+    return on(DBOperations.ALL, handler, data);
+}
 /**
  * @summary Defines a behaviour to set on the defined {@link DBOperations}
  *
@@ -177,6 +192,22 @@ export function afterRead(handler, data) {
 export function afterDelete(handler, data) {
     return after(DBOperations.DELETE, handler, data);
 }
+/**
+ * @summary Defines a behaviour to set after the defined {@link DBOperations.DELETE}
+ *
+ * @param {AfterOperationHandler<any>} handler The method called upon the operation
+ * @param data
+ * @param {any[]} [args] Arguments that will be passed in order to the handler method
+ *
+ * @see after
+ *
+ * @function afterAny
+ *
+ * @category Decorators
+ */
+export function afterAny(handler, data) {
+    return after(DBOperations.ALL, handler, data);
+}
 /**
  * @summary Defines a behaviour to set on the defined {@link DBOperations}
  *
@@ -223,4 +254,4 @@ export function operation(baseOp, operation = DBOperations.ALL, handler, dataToA
     };
 }
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/operations/decorators.ts"],"names":[],"mappings":"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","file":"operations/decorators.js","sourcesContent":["import {\n  IdOperationHandler,\n  OperationHandler,\n  StandardOperationHandler,\n  UpdateOperationHandler,\n} from \"./types\";\nimport { DBOperations, OperationKeys } from \"./constants\";\nimport { Operations } from \"./Operations\";\nimport { apply } from \"@decaf-ts/reflection\";\nimport { propMetadata } from \"@decaf-ts/decorator-validation\";\n\nfunction handle(op: OperationKeys, handler: OperationHandler<any, any, any>) {\n  return (target: any, propertyKey: string) => {\n    Operations.register(handler, op, target, propertyKey);\n  };\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE_UPDATE}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n * @param {any[]} [args] Arguments that will be passed in order to the handler method\n *\n * @see on\n *\n * @function onCreateUpdate\n *\n * @category Decorators\n */\nexport function onCreateUpdate<T>(\n  handler:\n    | StandardOperationHandler<any, any, T>\n    | UpdateOperationHandler<any, any, T>,\n  data?: T\n) {\n  return on(DBOperations.CREATE_UPDATE, handler, data);\n}\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.UPDATE}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n * @param {any[]} [args] Arguments that will be passed in order to the handler method\n *\n * @see on\n *\n * @function onUpdate\n *\n * @category Decorators\n */\nexport function onUpdate<T>(\n  handler: UpdateOperationHandler<any, any, T>,\n  data?: T\n) {\n  return on(DBOperations.UPDATE, handler, data);\n}\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data?\n *\n * @see on\n *\n * @function onCreate\n *\n * @category Decorators\n */\nexport function onCreate<T>(\n  handler: StandardOperationHandler<any, any, T>,\n  data?: T\n) {\n  return on(DBOperations.CREATE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.READ}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see on\n *\n * @function onRead\n *\n * @category Decorators\n */\nexport function onRead<T>(handler: IdOperationHandler<any, any, T>, data: T) {\n  return on(DBOperations.READ, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.DELETE}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see on\n *\n * @function onDelete\n *\n * @category Decorators\n */\nexport function onDelete<T>(handler: IdOperationHandler<any, any, T>, data: T) {\n  return on(DBOperations.DELETE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations}\n *\n * @param {OperationKeys[] | DBOperations} op One of {@link DBOperations}\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * ex: handler(...args, ...props.map(p => target[p]))\n *\n * @function on\n *\n * @category Decorators\n */\nexport function on<T>(\n  op: OperationKeys[] = DBOperations.ALL,\n  handler: OperationHandler<any, any, T>,\n  data?: T\n) {\n  return operation(OperationKeys.ON, op, handler, data);\n}\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.CREATE_UPDATE}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see after\n *\n * @function afterCreateUpdate\n *\n * @category Decorators\n */\nexport function afterCreateUpdate<T>(\n  handler:\n    | StandardOperationHandler<any, any, T>\n    | UpdateOperationHandler<any, any, T>,\n  data: T\n) {\n  return after(DBOperations.CREATE_UPDATE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.UPDATE}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see after\n *\n * @function afterUpdate\n *\n * @category Decorators\n */\nexport function afterUpdate<T>(\n  handler: UpdateOperationHandler<any, any, T>,\n  data: T\n) {\n  return after(DBOperations.UPDATE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.CREATE}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see after\n *\n * @function afterCreate\n *\n * @category Decorators\n */\nexport function afterCreate<T>(\n  handler: StandardOperationHandler<any, any, T>,\n  data: T\n) {\n  return after(DBOperations.CREATE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.READ}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n * @param {any[]} [args] Arguments that will be passed in order to the handler method\n *\n * @see after\n *\n * @function afterRead\n *\n * @category Decorators\n */\nexport function afterRead<T>(\n  handler: StandardOperationHandler<any, any, T>,\n  data?: T\n) {\n  return after(DBOperations.READ, handler, data);\n}\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.DELETE}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n * @param {any[]} [args] Arguments that will be passed in order to the handler method\n *\n * @see after\n *\n * @function afterDelete\n *\n * @category Decorators\n */\nexport function afterDelete<T>(\n  handler: StandardOperationHandler<any, any, T>,\n  data?: T\n) {\n  return after(DBOperations.DELETE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations}\n *\n * @param {OperationKeys[] | DBOperations} op One of {@link DBOperations}\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n *\n * ex: handler(...args, ...props.map(p => target[p]))\n *\n * @param data\n * @param args\n * @function after\n *\n * @category Decorators\n */\nexport function after<T>(\n  op: OperationKeys[] = DBOperations.ALL,\n  handler: OperationHandler<any, any, T>,\n  data?: T\n) {\n  return operation(OperationKeys.AFTER, op, handler, data);\n}\n\nexport function operation<T>(\n  baseOp: OperationKeys.ON | OperationKeys.AFTER,\n  operation: OperationKeys[] = DBOperations.ALL,\n  handler: OperationHandler<any, any, T>,\n  dataToAdd?: T\n) {\n  return (target: object, propertyKey: string | symbol) => {\n    const name = target.constructor.name;\n    const decorators = operation.reduce((accum: any[], op) => {\n      const compoundKey = baseOp + op;\n      let data = Reflect.getMetadata(\n        Operations.key(compoundKey),\n        target,\n        propertyKey\n      );\n      if (!data)\n        data = {\n          operation: op,\n          handlers: {},\n        };\n\n      const handlerKey = Operations.getHandlerName(handler);\n\n      if (\n        !data.handlers[name] ||\n        !data.handlers[name][propertyKey] ||\n        !(handlerKey in data.handlers[name][propertyKey])\n      ) {\n        data.handlers[name] = data.handlers[name] || {};\n        data.handlers[name][propertyKey] =\n          data.handlers[name][propertyKey] || {};\n        data.handlers[name][propertyKey][handlerKey] = {\n          data: dataToAdd,\n        };\n\n        accum.push(\n          handle(compoundKey as OperationKeys, handler),\n          propMetadata(Operations.key(compoundKey), data)\n        );\n      }\n      return accum;\n    }, []);\n    return apply(...decorators)(target, propertyKey);\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/operations/decorators.ts"],"names":[],"mappings":"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","file":"operations/decorators.js","sourcesContent":["import {\n  IdOperationHandler,\n  OperationHandler,\n  StandardOperationHandler,\n  UpdateOperationHandler,\n} from \"./types\";\nimport { DBOperations, OperationKeys } from \"./constants\";\nimport { Operations } from \"./Operations\";\nimport { apply } from \"@decaf-ts/reflection\";\nimport { propMetadata } from \"@decaf-ts/decorator-validation\";\n\nfunction handle(op: OperationKeys, handler: OperationHandler<any, any, any>) {\n  return (target: any, propertyKey: string) => {\n    Operations.register(handler, op, target, propertyKey);\n  };\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE_UPDATE}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n * @param {any[]} [args] Arguments that will be passed in order to the handler method\n *\n * @see on\n *\n * @function onCreateUpdate\n *\n * @category Decorators\n */\nexport function onCreateUpdate<T>(\n  handler:\n    | StandardOperationHandler<any, any, T>\n    | UpdateOperationHandler<any, any, T>,\n  data?: T\n) {\n  return on(DBOperations.CREATE_UPDATE, handler, data);\n}\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.UPDATE}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n * @param {any[]} [args] Arguments that will be passed in order to the handler method\n *\n * @see on\n *\n * @function onUpdate\n *\n * @category Decorators\n */\nexport function onUpdate<T>(\n  handler: UpdateOperationHandler<any, any, T>,\n  data?: T\n) {\n  return on(DBOperations.UPDATE, handler, data);\n}\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see on\n *\n * @function onCreate\n *\n * @category Decorators\n */\nexport function onCreate<T>(\n  handler: StandardOperationHandler<any, any, T>,\n  data?: T\n) {\n  return on(DBOperations.CREATE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.READ}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see on\n *\n * @function onRead\n *\n * @category Decorators\n */\nexport function onRead<T>(handler: IdOperationHandler<any, any, T>, data: T) {\n  return on(DBOperations.READ, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.DELETE}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see on\n *\n * @function onDelete\n *\n * @category Decorators\n */\nexport function onDelete<T>(handler: OperationHandler<any, any, T>, data: T) {\n  return on(DBOperations.DELETE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations.DELETE}\n *\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see on\n *\n * @function onAny\n *\n * @category Decorators\n */\nexport function onAny<T>(handler: OperationHandler<any, any, T>, data: T) {\n  return on(DBOperations.ALL, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations}\n *\n * @param {OperationKeys[] | DBOperations} op One of {@link DBOperations}\n * @param {OnOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * ex: handler(...args, ...props.map(p => target[p]))\n *\n * @function on\n *\n * @category Decorators\n */\nexport function on<T>(\n  op: OperationKeys[] = DBOperations.ALL,\n  handler: OperationHandler<any, any, T>,\n  data?: T\n) {\n  return operation(OperationKeys.ON, op, handler, data);\n}\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.CREATE_UPDATE}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see after\n *\n * @function afterCreateUpdate\n *\n * @category Decorators\n */\nexport function afterCreateUpdate<T>(\n  handler:\n    | StandardOperationHandler<any, any, T>\n    | UpdateOperationHandler<any, any, T>,\n  data: T\n) {\n  return after(DBOperations.CREATE_UPDATE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.UPDATE}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see after\n *\n * @function afterUpdate\n *\n * @category Decorators\n */\nexport function afterUpdate<T>(\n  handler: UpdateOperationHandler<any, any, T>,\n  data: T\n) {\n  return after(DBOperations.UPDATE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.CREATE}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n *\n * @see after\n *\n * @function afterCreate\n *\n * @category Decorators\n */\nexport function afterCreate<T>(\n  handler: StandardOperationHandler<any, any, T>,\n  data: T\n) {\n  return after(DBOperations.CREATE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.READ}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n * @param {any[]} [args] Arguments that will be passed in order to the handler method\n *\n * @see after\n *\n * @function afterRead\n *\n * @category Decorators\n */\nexport function afterRead<T>(\n  handler: StandardOperationHandler<any, any, T>,\n  data?: T\n) {\n  return after(DBOperations.READ, handler, data);\n}\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.DELETE}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n * @param {any[]} [args] Arguments that will be passed in order to the handler method\n *\n * @see after\n *\n * @function afterDelete\n *\n * @category Decorators\n */\nexport function afterDelete<T>(\n  handler: StandardOperationHandler<any, any, T>,\n  data?: T\n) {\n  return after(DBOperations.DELETE, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set after the defined {@link DBOperations.DELETE}\n *\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n * @param data\n * @param {any[]} [args] Arguments that will be passed in order to the handler method\n *\n * @see after\n *\n * @function afterAny\n *\n * @category Decorators\n */\nexport function afterAny<T>(\n  handler: StandardOperationHandler<any, any, T>,\n  data?: T\n) {\n  return after(DBOperations.ALL, handler, data);\n}\n\n/**\n * @summary Defines a behaviour to set on the defined {@link DBOperations}\n *\n * @param {OperationKeys[] | DBOperations} op One of {@link DBOperations}\n * @param {AfterOperationHandler<any>} handler The method called upon the operation\n *\n * ex: handler(...args, ...props.map(p => target[p]))\n *\n * @param data\n * @param args\n * @function after\n *\n * @category Decorators\n */\nexport function after<T>(\n  op: OperationKeys[] = DBOperations.ALL,\n  handler: OperationHandler<any, any, T>,\n  data?: T\n) {\n  return operation(OperationKeys.AFTER, op, handler, data);\n}\n\nexport function operation<T>(\n  baseOp: OperationKeys.ON | OperationKeys.AFTER,\n  operation: OperationKeys[] = DBOperations.ALL,\n  handler: OperationHandler<any, any, T>,\n  dataToAdd?: T\n) {\n  return (target: object, propertyKey: string | symbol) => {\n    const name = target.constructor.name;\n    const decorators = operation.reduce((accum: any[], op) => {\n      const compoundKey = baseOp + op;\n      let data = Reflect.getMetadata(\n        Operations.key(compoundKey),\n        target,\n        propertyKey\n      );\n      if (!data)\n        data = {\n          operation: op,\n          handlers: {},\n        };\n\n      const handlerKey = Operations.getHandlerName(handler);\n\n      if (\n        !data.handlers[name] ||\n        !data.handlers[name][propertyKey] ||\n        !(handlerKey in data.handlers[name][propertyKey])\n      ) {\n        data.handlers[name] = data.handlers[name] || {};\n        data.handlers[name][propertyKey] =\n          data.handlers[name][propertyKey] || {};\n        data.handlers[name][propertyKey][handlerKey] = {\n          data: dataToAdd,\n        };\n\n        accum.push(\n          handle(compoundKey as OperationKeys, handler),\n          propMetadata(Operations.key(compoundKey), data)\n        );\n      }\n      return accum;\n    }, []);\n    return apply(...decorators)(target, propertyKey);\n  };\n}\n"]}

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

@@ -1,27 +1,29 @@
 import { OperationKeys } from "./constants";
 import { IRepository } from "../interfaces/IRepository";
-export type OperationMetadata<T> = {
+import { Model } from "@decaf-ts/decorator-validation";
+import { Context } from "../repository/Context";
+export type OperationMetadata<V> = {
     operation: OperationKeys;
     handler: string;
-    metadata?: T;
+    metadata?: V;
 };
 /**
  * @typedef OperationHandler
  * @memberOf db-decorators.operations
  */
-export type OperationHandler<T extends Model, Y extends IRepository<T>, V> = StandardOperationHandler<T, Y, V> | UpdateOperationHandler<T, Y, V> | IdOperationHandler<T, Y, V>;
+export type OperationHandler<M extends Model, R extends IRepository<M>, V> = StandardOperationHandler<M, R, V> | UpdateOperationHandler<M, R, V> | IdOperationHandler<M, R, V>;
 /**
  * @typedef OnOperationHandler
  * @memberOf db-decorators.operations
  */
-export type StandardOperationHandler<T extends Model, Y extends IRepository<T>, V> = (this: Y, metadata: V, key: any, model: T) => Promise<void> | void;
+export type StandardOperationHandler<M extends Model, R extends IRepository<M>, V> = (this: R, context: Context, metadata: V, key: any, model: M) => Promise<void> | void;
 /**
  * @typedef IdOperationHandler
  * @memberOf db-decorators.operations
  */
-export type IdOperationHandler<T extends Model, Y extends IRepository<T>, V> = (this: Y, decorator: V, key: any, id: string) => Promise<void> | void;
+export type IdOperationHandler<M extends Model, R extends IRepository<M>, V> = (this: R, context: Context, decorator: V, key: any, id: string) => Promise<void> | void;
 /**
  * @typedef AfterOperationHandler
  * @memberOf db-decorators.operations
  */
-export type UpdateOperationHandler<T extends Model, Y extends IRepository<T>, V> = (this: Y, decorator: V, key: any, model: T, oldModel: T) => Promise<void> | void;
+export type UpdateOperationHandler<M extends Model, R extends IRepository<M>, V> = (this: R, context: Context, decorator: V, key: any, model: M, oldModel: M) => Promise<void> | void;

package/lib/esm/operations/types.js

@@ -1,3 +1,3 @@
 export {};
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9vcGVyYXRpb25zL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJmaWxlIjoib3BlcmF0aW9ucy90eXBlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9wZXJhdGlvbktleXMgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmltcG9ydCB7IElSZXBvc2l0b3J5IH0gZnJvbSBcIi4uL2ludGVyZmFjZXMvSVJlcG9zaXRvcnlcIjtcblxuZXhwb3J0IHR5cGUgT3BlcmF0aW9uTWV0YWRhdGE8VD4gPSB7XG4gIG9wZXJhdGlvbjogT3BlcmF0aW9uS2V5cztcbiAgaGFuZGxlcjogc3RyaW5nO1xuICBtZXRhZGF0YT86IFQ7XG59O1xuXG4vKipcbiAqIEB0eXBlZGVmIE9wZXJhdGlvbkhhbmRsZXJcbiAqIEBtZW1iZXJPZiBkYi1kZWNvcmF0b3JzLm9wZXJhdGlvbnNcbiAqL1xuZXhwb3J0IHR5cGUgT3BlcmF0aW9uSGFuZGxlcjxUIGV4dGVuZHMgTW9kZWwsIFkgZXh0ZW5kcyBJUmVwb3NpdG9yeTxUPiwgVj4gPVxuICB8IFN0YW5kYXJkT3BlcmF0aW9uSGFuZGxlcjxULCBZLCBWPlxuICB8IFVwZGF0ZU9wZXJhdGlvbkhhbmRsZXI8VCwgWSwgVj5cbiAgfCBJZE9wZXJhdGlvbkhhbmRsZXI8VCwgWSwgVj47XG5cbi8qKlxuICogQHR5cGVkZWYgT25PcGVyYXRpb25IYW5kbGVyXG4gKiBAbWVtYmVyT2YgZGItZGVjb3JhdG9ycy5vcGVyYXRpb25zXG4gKi9cbmV4cG9ydCB0eXBlIFN0YW5kYXJkT3BlcmF0aW9uSGFuZGxlcjxcbiAgVCBleHRlbmRzIE1vZGVsLFxuICBZIGV4dGVuZHMgSVJlcG9zaXRvcnk8VD4sXG4gIFYsXG4+ID0gKHRoaXM6IFksIG1ldGFkYXRhOiBWLCBrZXk6IGFueSwgbW9kZWw6IFQpID0+IFByb21pc2U8dm9pZD4gfCB2b2lkO1xuXG4vKipcbiAqIEB0eXBlZGVmIElkT3BlcmF0aW9uSGFuZGxlclxuICogQG1lbWJlck9mIGRiLWRlY29yYXRvcnMub3BlcmF0aW9uc1xuICovXG5leHBvcnQgdHlwZSBJZE9wZXJhdGlvbkhhbmRsZXI8VCBleHRlbmRzIE1vZGVsLCBZIGV4dGVuZHMgSVJlcG9zaXRvcnk8VD4sIFY+ID0gKFxuICB0aGlzOiBZLFxuICBkZWNvcmF0b3I6IFYsXG4gIGtleTogYW55LFxuICBpZDogc3RyaW5nXG4pID0+IFByb21pc2U8dm9pZD4gfCB2b2lkO1xuXG4vKipcbiAqIEB0eXBlZGVmIEFmdGVyT3BlcmF0aW9uSGFuZGxlclxuICogQG1lbWJlck9mIGRiLWRlY29yYXRvcnMub3BlcmF0aW9uc1xuICovXG5leHBvcnQgdHlwZSBVcGRhdGVPcGVyYXRpb25IYW5kbGVyPFxuICBUIGV4dGVuZHMgTW9kZWwsXG4gIFkgZXh0ZW5kcyBJUmVwb3NpdG9yeTxUPixcbiAgVixcbj4gPSAoXG4gIHRoaXM6IFksXG4gIGRlY29yYXRvcjogVixcbiAga2V5OiBhbnksXG4gIG1vZGVsOiBULFxuICBvbGRNb2RlbDogVFxuKSA9PiBQcm9taXNlPHZvaWQ+IHwgdm9pZDtcbiJdfQ==
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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