@decaf-ts/db-decorators 0.1.0

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

@@ -0,0 +1,23 @@
+/**
+ * @summary Set of constants to define db CRUD operations and their equivalent 'on' and 'after' phases
+ * @const OperationKeys
+ *
+ * @memberOf module:db-decorators.Operations
+ */
+export declare enum OperationKeys {
+    REFLECT = "operations.db.",
+    CREATE = "create",
+    READ = "read",
+    UPDATE = "update",
+    DELETE = "delete",
+    ON = "on.",
+    AFTER = "after."
+}
+/**
+ * @summary Maps out groups of CRUD operations for easier mapping of decorators
+ *
+ * @constant DBOperations
+ *
+ * @memberOf module:db-decorators.Operations
+ */
+export declare const DBOperations: Record<string, OperationKeys[]>;

package/lib/esm/operations/constants.js

@@ -0,0 +1 @@
+var OperationKeys;!function(e){e.REFLECT="operations.db.",e.CREATE="create",e.READ="read",e.UPDATE="update",e.DELETE="delete",e.ON="on.",e.AFTER="after."}(OperationKeys=OperationKeys||{});const DBOperations={CREATE:[OperationKeys.CREATE],READ:[OperationKeys.READ],UPDATE:[OperationKeys.UPDATE],DELETE:[OperationKeys.DELETE],CREATE_UPDATE:[OperationKeys.CREATE,OperationKeys.UPDATE],READ_CREATE:[OperationKeys.READ,OperationKeys.CREATE],ALL:[OperationKeys.CREATE,OperationKeys.READ,OperationKeys.UPDATE,OperationKeys.DELETE]};export{OperationKeys,DBOperations};

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

@@ -0,0 +1,166 @@
+import { IdOperationHandler, OperationHandler, StandardOperationHandler, UpdateOperationHandler } from "./types";
+import { OperationKeys } from "./constants";
+/**
+ * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE_UPDATE}
+ *
+ * @param {OnOperationHandler<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 on
+ *
+ * @function onCreateUpdate
+ *
+ * @category Decorators
+ */
+export declare function onCreateUpdate<T>(handler: StandardOperationHandler<any, any, T> | UpdateOperationHandler<any, any, T>, data?: T): (target: object, propertyKey: string | symbol) => void;
+/**
+ * @summary Defines a behaviour to set on the defined {@link DBOperations.UPDATE}
+ *
+ * @param {OnOperationHandler<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 on
+ *
+ * @function onUpdate
+ *
+ * @category Decorators
+ */
+export declare function onUpdate<T>(handler: UpdateOperationHandler<any, any, T>, data?: T): (target: object, propertyKey: string | symbol) => void;
+/**
+ * @summary Defines a behaviour to set on the defined {@link DBOperations.CREATE}
+ *
+ * @param {OnOperationHandler<any>} handler The method called upon the operation
+ * @param data?
+ *
+ * @see on
+ *
+ * @function onCreate
+ *
+ * @category Decorators
+ */
+export declare function onCreate<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.READ}
+ *
+ * @param {OnOperationHandler<any>} handler The method called upon the operation
+ * @param data
+ *
+ * @see on
+ *
+ * @function onRead
+ *
+ * @category Decorators
+ */
+export declare function onRead<T>(handler: IdOperationHandler<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 onDelete
+ *
+ * @category Decorators
+ */
+export declare function onDelete<T>(handler: IdOperationHandler<any, any, T>, data: T): (target: object, propertyKey: string | symbol) => void;
+/**
+ * @summary Defines a behaviour to set on the defined {@link DBOperations}
+ *
+ * @param {OperationKeys[] | DBOperations} op One of {@link DBOperations}
+ * @param {OnOperationHandler<any>} handler The method called upon the operation
+ * @param data
+ *
+ * ex: handler(...args, ...props.map(p => target[p]))
+ *
+ * @function on
+ *
+ * @category Decorators
+ */
+export declare function on<T>(op: OperationKeys[] | undefined, handler: OperationHandler<any, any, T>, data?: T): (target: object, propertyKey: string | symbol) => void;
+/**
+ * @summary Defines a behaviour to set after the defined {@link DBOperations.CREATE_UPDATE}
+ *
+ * @param {AfterOperationHandler<any>} handler The method called upon the operation
+ * @param data
+ *
+ * @see after
+ *
+ * @function afterCreateUpdate
+ *
+ * @category Decorators
+ */
+export declare function afterCreateUpdate<T>(handler: StandardOperationHandler<any, any, T> | UpdateOperationHandler<any, any, T>, data: T): (target: object, propertyKey: string | symbol) => void;
+/**
+ * @summary Defines a behaviour to set after the defined {@link DBOperations.UPDATE}
+ *
+ * @param {AfterOperationHandler<any>} handler The method called upon the operation
+ * @param data
+ *
+ * @see after
+ *
+ * @function afterUpdate
+ *
+ * @category Decorators
+ */
+export declare function afterUpdate<T>(handler: UpdateOperationHandler<any, any, T>, data: T): (target: object, propertyKey: string | symbol) => void;
+/**
+ * @summary Defines a behaviour to set after the defined {@link DBOperations.CREATE}
+ *
+ * @param {AfterOperationHandler<any>} handler The method called upon the operation
+ * @param data
+ *
+ * @see after
+ *
+ * @function afterCreate
+ *
+ * @category Decorators
+ */
+export declare function afterCreate<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.READ}
+ *
+ * @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 afterRead
+ *
+ * @category Decorators
+ */
+export declare function afterRead<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 afterDelete
+ *
+ * @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 on the defined {@link DBOperations}
+ *
+ * @param {OperationKeys[] | DBOperations} op One of {@link DBOperations}
+ * @param {AfterOperationHandler<any>} handler The method called upon the operation
+ *
+ * ex: handler(...args, ...props.map(p => target[p]))
+ *
+ * @param data
+ * @param args
+ * @function after
+ *
+ * @category Decorators
+ */
+export declare function after<T>(op: OperationKeys[] | undefined, handler: OperationHandler<any, any, T>, data?: T): (target: object, propertyKey: string | symbol) => void;
+export declare function operation<T>(baseOp: OperationKeys.ON | OperationKeys.AFTER, operation: OperationKeys[] | undefined, handler: OperationHandler<any, any, T>, dataToAdd?: T): (target: object, propertyKey: string | symbol) => void;

package/lib/esm/operations/decorators.js

@@ -0,0 +1 @@
+import{DBOperations,OperationKeys}from"./constants";import{Operations}from"./Operations";import{apply,metadata}from"@decaf-ts/reflection";function handle(n,r){return(e,t)=>{Operations.register(r,n,e,t)}}function onCreateUpdate(e,t){return on(DBOperations.CREATE_UPDATE,e,t)}function onUpdate(e,t){return on(DBOperations.UPDATE,e,t)}function onCreate(e,t){return on(DBOperations.CREATE,e,t)}function onRead(e,t){return on(DBOperations.READ,e,t)}function onDelete(e,t){return on(DBOperations.DELETE,e,t)}function on(e=DBOperations.ALL,t,n){return operation(OperationKeys.ON,e,t,n)}function afterCreateUpdate(e,t){return after(DBOperations.CREATE_UPDATE,e,t)}function afterUpdate(e,t){return after(DBOperations.UPDATE,e,t)}function afterCreate(e,t){return after(DBOperations.CREATE,e,t)}function afterRead(e,t){return after(DBOperations.READ,e,t)}function afterDelete(e,t){return after(DBOperations.DELETE,e,t)}function after(e=DBOperations.ALL,t,n){return operation(OperationKeys.AFTER,e,t,n)}function operation(p,t=DBOperations.ALL,s,f){return(a,o)=>{const i=a.constructor.name;var e=t.reduce((e,t)=>{var n=p+t;let r=Reflect.getMetadata(Operations.genKey(n),a,o);r=r||{operation:t,handlers:{}};t=Operations.getHandlerName(s);return r.handlers[i]&&r.handlers[i][o]&&t in r.handlers[i][o]||(r.handlers[i]=r.handlers[i]||{},r.handlers[i][o]=r.handlers[i][o]||{},r.handlers[i][o][t]={data:f},e.push(handle(n,s),metadata(Operations.genKey(n),r))),e},[]);return apply(...e)(a,o)}}export{onCreateUpdate,onUpdate,onCreate,onRead,onDelete,on,afterCreateUpdate,afterUpdate,afterCreate,afterRead,afterDelete,after,operation};

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

@@ -0,0 +1,5 @@
+export * from "./constants";
+export * from "./decorators";
+export * from "./Operations";
+export * from "./OperationsRegistry";
+export * from "./types";

package/lib/esm/operations/index.js

@@ -0,0 +1 @@
+export*from"./constants";export*from"./decorators";export*from"./Operations";export*from"./OperationsRegistry";export*from"./types";

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

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

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

@@ -0,0 +1,24 @@
+import { IRepository } from "../interfaces/IRepository";
+import { DBModel } from "../model/DBModel";
+import { Constructor } from "@decaf-ts/decorator-validation";
+import { DataCache } from "./DataCache";
+export declare abstract class BaseRepository<T extends DBModel> implements IRepository<T> {
+    private readonly _class;
+    private _cache?;
+    get class(): Constructor<T>;
+    get cache(): DataCache;
+    protected constructor();
+    create(model: T, ...args: any[]): Promise<T>;
+    protected createPrefix(model: T, ...args: any[]): Promise<any[]>;
+    protected createSuffix(model: T): Promise<T>;
+    read(key: string, ...args: any[]): Promise<T>;
+    protected readSuffix(model: T): Promise<T>;
+    protected readPrefix(key: string, ...args: any[]): Promise<any[]>;
+    update(model: T, ...args: any[]): Promise<T>;
+    protected updateSuffix(model: T): Promise<T>;
+    protected updatePrefix(model: T, ...args: any[]): Promise<any[]>;
+    delete(key: string, ...args: any[]): Promise<T>;
+    protected deleteSuffix(model: T): Promise<T>;
+    protected deletePrefix(key: any, ...args: any[]): Promise<any[]>;
+    toString(): string;
+}

package/lib/esm/repository/BaseRepository.js

@@ -0,0 +1 @@
+import{sf}from"@decaf-ts/decorator-validation";import{enforceDBDecorators}from"./utils";import{OperationKeys}from"../operations/constants";import{InternalError}from"./errors";import{DataCache}from"./DataCache";import{wrapMethod}from"./wrappers";import{findModelId}from"../identity";class BaseRepository{get class(){if(this._class)return this._class;throw new InternalError("No class definition found for this repository")}get cache(){return this._cache||(this._cache=new DataCache),this._cache}constructor(){const t=this;[this.create,this.read,this.update,this.delete].forEach(e=>{var r=e.name;wrapMethod(t,t[r+"Prefix"],e,t[r+"Suffix"])})}async create(e){throw new Error("Child classes must implement this.")}async createPrefix(e,...r){return e=new this.class(e),await enforceDBDecorators(this,e,OperationKeys.CREATE,OperationKeys.ON),[e,...r]}async createSuffix(e){return await enforceDBDecorators(this,e,OperationKeys.CREATE,OperationKeys.AFTER),e}async read(e){throw new Error("Child classes must implement this")}async readSuffix(e){return await enforceDBDecorators(this,e,OperationKeys.READ,OperationKeys.AFTER),e}async readPrefix(e,...r){var t=new this.class;return await enforceDBDecorators(this,t,OperationKeys.READ,OperationKeys.ON),[e,...r]}async update(e){throw new Error("Child classes must implement this")}async updateSuffix(e){return e=new this.class(e),await enforceDBDecorators(this,e,OperationKeys.UPDATE,OperationKeys.AFTER),e}async updatePrefix(e,...r){var t=findModelId(e),t=await this.read(t);return await enforceDBDecorators(this,e,OperationKeys.UPDATE,OperationKeys.ON,t),[e,...r]}async delete(e){throw new Error("Child classes must implement this")}async deleteSuffix(e){return await enforceDBDecorators(this,e,OperationKeys.DELETE,OperationKeys.AFTER),e}async deletePrefix(e,...r){var t=await this.read(e,...r);return await enforceDBDecorators(this,t,OperationKeys.DELETE,OperationKeys.ON),[e,...r]}toString(){return sf("[{0}] - Repository for {1}",this.constructor.name,this.class.name)}}export{BaseRepository};

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

@@ -0,0 +1,8 @@
+export declare class DataCache {
+    private cache;
+    get(key: string): Promise<any>;
+    push(key: string, value: any): Promise<void>;
+    put(key: string, value: any): Promise<void>;
+    pop(key: string): Promise<any>;
+    purge(key?: string): Promise<void>;
+}

package/lib/esm/repository/DataCache.js

@@ -0,0 +1 @@
+import{ConflictError,NotFoundError}from"./errors";class DataCache{constructor(){this.cache={}}async get(t){if(t in this.cache)return this.cache[t];throw new NotFoundError(`Key ${t} not in dataStore`)}async push(t,r){if(t in this.cache)throw new ConflictError(`Key ${t} already in dataStore`);this.cache[t]=r}async put(t,r){this.cache[t]=r}async pop(t){var r=this.get(t);return delete this.cache[t],r}async purge(t){t?await this.pop(t):this.cache={}}}export{DataCache};

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

@@ -0,0 +1,12 @@
+import { DBModel } from "../model/DBModel";
+import { BaseRepository } from "./BaseRepository";
+export declare abstract class Repository<T extends DBModel> extends BaseRepository<T> {
+    protected constructor();
+    create(model: T): Promise<T>;
+    protected createPrefix(model: T, ...args: any[]): Promise<[T, ...any[]]>;
+    delete(key: string | number): Promise<T>;
+    protected deletePrefix(key: string | number, ...args: any[]): Promise<[string | number, ...any[]]>;
+    read(key: string | number): Promise<T>;
+    update(model: T): Promise<T>;
+    protected updatePrefix(model: T, ...args: any[]): Promise<[T, ...args: any[]]>;
+}

package/lib/esm/repository/Repository.js

@@ -0,0 +1 @@
+import{sf}from"@decaf-ts/decorator-validation";import{enforceDBDecorators}from"./utils";import{OperationKeys}from"../operations/constants";import{ConflictError,NotFoundError,ValidationError}from"./errors";import{BaseRepository}from"./BaseRepository";import{findModelId}from"../identity";class Repository extends BaseRepository{constructor(){super()}async create(r){throw new Error("Child classes must implement this.")}async createPrefix(t,...e){t=new this.class(t),await enforceDBDecorators(this,t,OperationKeys.CREATE,OperationKeys.ON);var r=t.hasErrors();if(r)throw new ValidationError(r.toString());let o;try{if(!(o=findModelId(t,!0)))return[t,...e];o&&await this.read(o.toString())}catch(r){if(r instanceof NotFoundError)return[t,...e];throw r}throw new ConflictError(sf("Model with id {0} already exists",o))}async delete(r){throw new Error("Child classes must implement this.")}async deletePrefix(r,...t){var e=new this.class;return await enforceDBDecorators(this,e,OperationKeys.DELETE,OperationKeys.ON),await this.read(r),[r,...t]}async read(r){throw new Error("Child classes must implement this.")}async update(r){throw new Error("Child classes must implement this.")}async updatePrefix(r,...t){r=new this.class(r);var e=findModelId(r),e=await this.read(e),e=(await enforceDBDecorators(this,r,OperationKeys.UPDATE,OperationKeys.ON,e),r.hasErrors(e));if(e)throw new ValidationError(e.toString());return[r,...t]}}export{Repository};

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

@@ -0,0 +1,6 @@
+import { CascadeMetadata } from "./types";
+export declare enum Cascade {
+    CASCADE = "cascade",
+    NONE = "none"
+}
+export declare const DefaultCascade: CascadeMetadata;

package/lib/esm/repository/constants.js

@@ -0,0 +1 @@
+var Cascade;!function(a){a.CASCADE="cascade",a.NONE="none"}(Cascade=Cascade||{});const DefaultCascade={update:Cascade.CASCADE,delete:Cascade.NONE};export{Cascade,DefaultCascade};

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

@@ -0,0 +1,3 @@
+import { Constructor } from "@decaf-ts/decorator-validation";
+import { DBModel } from "../model/DBModel";
+export declare function repository<T extends DBModel>(model: Constructor<T>, nameOverride?: string): (original: any, propertyKey?: string) => any;

package/lib/esm/repository/decorators.js

@@ -0,0 +1 @@
+import{inject,injectable}from"@decaf-ts/injectable-decorators";import{metadata}from"@decaf-ts/reflection";import{getDBKey}from"../model/decorators";import{DBKeys}from"../model/constants";import{InternalError}from"./errors";function repository(o,a){return(e,r)=>{if(r){var t=Reflect.getMetadata(getDBKey(DBKeys.REPOSITORY),o);if(t)return inject(t)(e,r);throw new InternalError("Could not find repository for "+o.name)}return metadata(getDBKey(DBKeys.REPOSITORY),a||e.name)(o),injectable(a,!0,e=>{Object.defineProperty(e,DBKeys.CLASS,{enumerable:!1,configurable:!1,writable:!1,value:o})})(e)}}export{repository};

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

@@ -0,0 +1,69 @@
+/**
+ * @summary Base Error
+ *
+ * @param {string} msg the error message
+ *
+ * @class BaseDLTError
+ * @extends Error
+ */
+export declare abstract class BaseError extends Error {
+    protected constructor(name: string, msg: string | Error);
+}
+/**
+ * @summary Represents a failure in the Model details
+ *
+ * @param {string} msg the error message
+ *
+ * @class ValidationError
+ * @extends BaseError
+ */
+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
+ *
+ * @class InternalError
+ * @extends BaseError
+ */
+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
+ *
+ * @class SerializationError
+ * @extends BaseError
+ *
+ */
+export declare class SerializationError extends BaseError {
+    constructor(msg: string | Error);
+}
+/**
+ * @summary Represents a failure in finding a model
+ *
+ * @param {string} msg the error message
+ *
+ * @class NotFoundError
+ * @extends BaseError
+ *
+ */
+export declare class NotFoundError extends BaseError {
+    constructor(msg: string | Error);
+}
+/**
+ * @summary Represents a conflict in the storage
+ *
+ * @param {string} msg the error message
+ *
+ * @class ConflictError
+ * @extends BaseError
+ *
+ */
+export declare class ConflictError extends BaseError {
+    constructor(msg: string | Error);
+}

package/lib/esm/repository/errors.js

@@ -0,0 +1 @@
+class BaseError extends Error{constructor(r,o){if(o instanceof BaseError)return o;super(`[${r}] `+(o instanceof Error?o.message:o)),o instanceof Error&&(this.stack=o.stack)}}class ValidationError extends BaseError{constructor(r){super(ValidationError.name,r)}}class InternalError extends BaseError{constructor(r){super(InternalError.name,r)}}class SerializationError extends BaseError{constructor(r){super(SerializationError.name,r)}}class NotFoundError extends BaseError{constructor(r){super(NotFoundError.name,r)}}class ConflictError extends BaseError{constructor(r){super(ConflictError.name,r)}}export{BaseError,ValidationError,InternalError,SerializationError,NotFoundError,ConflictError};

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

@@ -0,0 +1,9 @@
+export * from "./BaseRepository";
+export * from "./constants";
+export * from "./DataCache";
+export * from "./decorators";
+export * from "./errors";
+export * from "./Repository";
+export * from "./types";
+export * from "./utils";
+export * from "./wrappers";

package/lib/esm/repository/index.js

@@ -0,0 +1 @@
+export*from"./BaseRepository";export*from"./constants";export*from"./DataCache";export*from"./decorators";export*from"./errors";export*from"./Repository";export*from"./types";export*from"./utils";export*from"./wrappers";

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

@@ -0,0 +1,13 @@
+import { Cascade } from "./constants";
+import { OrderDirection } from "../validation/constants";
+/**
+ * @summary defines the cascading behaviour
+ */
+export type CascadeMetadata = {
+    update: Cascade;
+    delete: Cascade;
+};
+export type IndexMetadata = {
+    directions?: OrderDirection[2];
+    compositions?: string[];
+};

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

@@ -0,0 +1,57 @@
+import { DBModel } from "../model/DBModel";
+import { IRepository } from "../interfaces/IRepository";
+import { DecoratorMetadata } from "@decaf-ts/reflection";
+import { Constructor } from "@decaf-ts/decorator-validation";
+/**
+ * @summary retrieves the arguments for the handler
+ * @param {any} dec the decorator
+ * @param {string} prop the property name
+ * @param {{}} m the model
+ * @param {{}} [accum] accumulator used for internal recursiveness
+ *
+ * @function getHandlerArgs
+ * @memberOf module:db-decorators.Repository
+ */
+export declare const getHandlerArgs: (dec: any, prop: string, m: Constructor<any>, accum?: Record<string, {
+    args: string[];
+}>) => Record<string, {
+    args: string[];
+}> | void;
+/**
+ *
+ * @param {IRepository<T>} repo
+ * @param {T} model
+ * @param operation
+ * @param prefix
+ *
+ * @param oldModel
+ * @function enforceDBPropertyDecoratorsAsync
+ *
+ * @memberOf db-decorators.utils
+ */
+export declare function enforceDBDecorators<T extends DBModel, Y extends IRepository<T>, V>(repo: Y, model: T, operation: string, prefix: string, oldModel?: T): Promise<void>;
+/**
+ * Specific for DB Decorators
+ * @param {T} model
+ * @param {string} operation CRUD {@link OperationKeys}
+ * @param {string} [extraPrefix]
+ *
+ * @function getDbPropertyDecorators
+ *
+ * @memberOf db-decorators.utils
+ */
+export declare function getDbDecorators<T extends DBModel>(model: T, operation: string, extraPrefix?: string): Record<string, DecoratorMetadata[]> | undefined;
+/**
+ * @summary Retrieves the decorators for an object's properties prefixed by {@param prefixes} recursively
+ * @param model
+ * @param accum
+ * @param prefixes
+ *
+ * @function getAllPropertyDecoratorsRecursive
+ * @memberOf module:db-decorators.Repository
+ */
+export declare const getAllPropertyDecoratorsRecursive: <T extends DBModel>(model: T, accum: {
+    [indexer: string]: any[];
+} | undefined, ...prefixes: string[]) => {
+    [indexer: string]: any[];
+} | undefined;

package/lib/esm/repository/utils.js

@@ -0,0 +1 @@
+import{Operations}from"../operations/Operations";import{OperationKeys}from"../operations/constants";import{getAllPropertyDecorators}from"@decaf-ts/reflection";import{InternalError}from"./errors";import{ModelKeys,sf}from"@decaf-ts/decorator-validation";const getHandlerArgs=function(e,r,t,o){var n=t.constructor.name;if(!n)throw new InternalError("Could not determine model class");o=o||{},e.props.handlers[n]&&e.props.handlers[n][r]&&(o={...e.props.handlers[n][r],...o});let a=Object.getPrototypeOf(t);return a===Object.prototype?o:(a.constructor.name===n&&(a=Object.getPrototypeOf(a)),getHandlerArgs(e,r,a,o))};async function enforceDBDecorators(r,t,o,e,n){var a=getDbDecorators(t,o,e);if(a)for(const f in a)for(const d of a[f]){var s=d["key"],i=Operations.get(t,f,e+s);if(!i||!i.length)throw new InternalError(`Could not find registered handler for the operation ${e+s} under property `+f);var p=getHandlerArgs(d,f,t);if(!p||Object.values(p).length!==i.length)throw new InternalError(sf("Args and handlers length do not match"));for(let e=0;e<i.length;e++){var c=i[e],l=[Object.values(p)[e].data,f,t];if(o===OperationKeys.UPDATE){if(!n)throw new InternalError("Missing old model for update operation");l.push(n)}await c.apply(r,l)}}}function getDbDecorators(e,o,r){const n=getAllPropertyDecorators(e,OperationKeys.REFLECT+(r||""));if(n)return Object.keys(n).reduce((e,r)=>{var t=n[r].filter(e=>e.key===o);return t&&t.length&&((e=e||{})[r]=t),e},void 0)}const getAllPropertyDecoratorsRecursive=function(e,r,...t){const s=r||{};function o(e){Object.entries(e).forEach(([e,r])=>{var a;s[e]=s[e]||[],[a,...e]=[e,...r],e.forEach(r=>{var e;if((e=s[a].find(e=>e.key===r.key))&&e.props.operation===r.props.operation){if(r.key!==ModelKeys.TYPE){var{handlers:t,operation:o}=r.props;if(o&&o.match(new RegExp(`^(:?${OperationKeys.ON}|${OperationKeys.AFTER})(:?${OperationKeys.CREATE}|${OperationKeys.READ}|${OperationKeys.UPDATE}|${OperationKeys.DELETE})$`))){const n=e.props.handlers;Object.entries(t).forEach(([o,e])=>{o in n?Object.entries(e).forEach(([t,e])=>{t in n[o]?Object.entries(e).forEach(([e,r])=>{e in n[o][t]?console.warn(sf("Skipping handler registration for {0} under prop {0} because handler is the same",o,t)):n[o][t][e]=r}):n[o][t]=e}):n[o]=e})}else s[a].push(r)}}else s[a].push(r)})})}var r=getAllPropertyDecorators(e,...t);return r&&o(r),Object.getPrototypeOf(e)!==Object.prototype&&(r=Object.getPrototypeOf(e))?getAllPropertyDecoratorsRecursive(r,s,...t):s};export{getHandlerArgs,enforceDBDecorators,getDbDecorators,getAllPropertyDecoratorsRecursive};

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

@@ -0,0 +1,38 @@
+/**
+ * @summary Util method to change a method of an object prefixing it with another
+ * @param {any} obj The Base Object
+ * @param {Function} after The original method
+ * @param {Function} prefix The Prefix method. The output will be used as arguments in the original method
+ * @param {string} [afterName] When the after function anme cannot be extracted, pass it here
+ *
+ * @function prefixMethod
+ *
+ * @memberOf module:db-decorators.Repository
+ */
+export declare function prefixMethod(obj: any, after: (...args: any[]) => any, prefix: (...args: any[]) => any, afterName?: string): void;
+/**
+ * @summary Util method to change a method of an object suffixing it with another
+ * @param {any} obj The Base Object
+ * @param {Function} before The original method
+ * @param {Function} suffix The Prefix method. The output will be used as arguments in the original method
+ * @param {string} [beforeName] When the after function anme cannot be extracted, pass it here
+ *
+ * @function suffixMethod
+ *
+ * @memberOf module:db-decorators.Repository
+ */
+export declare function suffixMethod(obj: any, before: (...args: any[]) => any, suffix: (...args: any[]) => any, beforeName?: string): void;
+/**
+ * @summary Util method to wrap a method of an object with additional logic
+ *
+ * @param {any} obj The Base Object
+ * @param {Function} before the method to be prefixed
+ * @param {Function} method the method to be wrapped
+ * @param {Function} after The method to be suffixed
+ * @param {string} [methodName] When the after function anme cannot be extracted, pass it here
+ *
+ * @function wrapMethod
+ *
+ * @memberOf module:db-decorators.Repository
+ */
+export declare function wrapMethod(obj: any, before: (...args: any[]) => any, method: (...args: any[]) => any, after: (...args: any[]) => any, methodName?: string): void;

package/lib/esm/repository/wrappers.js

@@ -0,0 +1 @@
+function prefixMethod(e,a,r,i){var n=async function(...e){return e=await Promise.resolve(r.call(this,...e)),Promise.resolve(a.apply(this,e))}.bind(e),i=i||a.name;Object.defineProperty(n,"name",{enumerable:!0,configurable:!0,writable:!1,value:i}),e[i]=n}function suffixMethod(e,a,r,i){var n=async function(...e){return e=await Promise.resolve(a.call(this,...e)),r.call(this,...e)}.bind(e),i=i||a.name;Object.defineProperty(n,"name",{enumerable:!0,configurable:!0,writable:!1,value:i}),e[i]=n}function wrapMethod(a,r,i,n,e){var t=async function(...e){return e=await Promise.resolve(r.call(a,...e)),e=await Promise.resolve(i.call(a,...e)),Promise.resolve(n.call(this,e))}.bind(a),e=e||i.name;Object.defineProperty(t,"name",{enumerable:!0,configurable:!0,writable:!1,value:e}),a[e]=t}export{prefixMethod,suffixMethod,wrapMethod};

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

@@ -0,0 +1 @@
+

package/lib/esm/validation/comparison.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,49 @@
+/**
+ * @summary holds the default error messages
+ * @const DEFAULT_ERROR_MESSAGES
+ *
+ * @memberOf module:db-decorators.Model
+ */
+export declare const DEFAULT_ERROR_MESSAGES: {
+    ID: {
+        INVALID: string;
+        REQUIRED: string;
+    };
+    READONLY: {
+        INVALID: string;
+    };
+    TIMESTAMP: {
+        REQUIRED: string;
+        DATE: string;
+        INVALID: string;
+    };
+};
+/**
+ * @summary Update reflection keys
+ * @const UpdateValidationKeys
+ * @memberOf module:db-decorators.Operations
+ */
+export declare const UpdateValidationKeys: {
+    REFLECT: string;
+    TIMESTAMP: string;
+    READONLY: string;
+};
+/**
+ * @summary defines order directions when sorting
+ *
+ * @constant OrderDirection
+ *
+ * @category Query
+ */
+export declare enum OrderDirection {
+    /**
+     * @summary Defines the sort order as ascending
+     * @prop ASC
+     */
+    ASC = "asc",
+    /**
+     * @summary Defines the sort order as descending
+     * @property {string} DSC
+     */
+    DSC = "desc"
+}

package/lib/esm/validation/constants.js

@@ -0,0 +1 @@
+import{DBKeys}from"../model/constants";const DEFAULT_ERROR_MESSAGES={ID:{INVALID:"This Id is invalid",REQUIRED:"The Id is mandatory"},READONLY:{INVALID:"This cannot be updated"},TIMESTAMP:{REQUIRED:"Timestamp is Mandatory",DATE:"The Timestamp must the a valid date",INVALID:"This value must always increase"}},UpdateValidationKeys={REFLECT:"db.update.validation.",TIMESTAMP:DBKeys.TIMESTAMP,READONLY:DBKeys.READONLY};var OrderDirection;!function(e){e.ASC="asc",e.DSC="desc"}(OrderDirection=OrderDirection||{});export{DEFAULT_ERROR_MESSAGES,UpdateValidationKeys,OrderDirection};