@decaf-ts/db-decorators 0.4.31 → 0.4.33

package/lib/index.d.ts

@@ -1,33 +0,0 @@
-/**
- * @module db-decorators
- */
-/**
- * @namespace Model
- * @memberOf module:db-decorators
- */
-/**
- * @namespace Operations
- * @memberOf module:db-decorators
- */
-/**
- * @namespace Repository
- * @memberOf module:db-decorators
- */
-/**
- * @namespace Validation
- * @memberOf module:db-decorators
- */
-/**
- * @namespace Validators
- * @memberOf module:db-decorators.Validation
- */
-/**
- * @namespace Utils
- * @memberOf module:db-decorators
- */
-export * from "./identity";
-export * from "./interfaces";
-export * from "./model";
-export * from "./operations";
-export * from "./repository";
-export * from "./validation";

package/lib/interfaces/BulkCrudOperator.d.ts

@@ -1,7 +0,0 @@
-import { CrudOperator } from "./CrudOperator";
-export interface BulkCrudOperator<M> extends CrudOperator<M> {
-    createAll(models: M[], ...args: any[]): Promise<M[]>;
-    readAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
-    updateAll(models: M[], ...args: any[]): Promise<M[]>;
-    deleteAll(keys: string[] | number[], ...args: any[]): Promise<M[]>;
-}

package/lib/interfaces/Contextual.d.ts

@@ -1,6 +0,0 @@
-import { OperationKeys } from "../operations";
-import { Model } from "@decaf-ts/decorator-validation";
-import { Context } from "../repository";
-export interface Contextual<M extends Model> {
-    context<C extends Context<M> = Context<M>>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, ...args: any[]): Promise<C>;
-}

package/lib/interfaces/CrudOperator.d.ts

@@ -1,42 +0,0 @@
-/**
- * @summary Crud API
- * @description Exposes a CRUD API
- *
- * @interface CrudOperator
- *
- * @category Managers
- */
-export interface CrudOperator<M> {
-    /**
-     * @summary Create a new model
-     * @param {T} model
-     * @param {any[]} [args]
-     *
-     * @method
-     */
-    create(model: M, ...args: any[]): Promise<M>;
-    /**
-     * @summary Read a model
-     * @param {string} key
-     * @param {any[]} [args]
-     *
-     * @method
-     */
-    read(key: string | number, ...args: any[]): Promise<M>;
-    /**
-     * @summary update a model
-     * @param {T} model
-     * @param {any[]} [args]
-     *
-     * @method
-     */
-    update(model: M, ...args: any[]): Promise<M>;
-    /**
-     * @summary delete a model
-     * @param {string} key
-     * @param {any[]} [args]
-     *
-     * @method
-     */
-    delete(key: string | number, ...args: any[]): Promise<M>;
-}

package/lib/interfaces/IRepository.d.ts

@@ -1,11 +0,0 @@
-import { Constructor, Model } from "@decaf-ts/decorator-validation";
-import { BulkCrudOperator } from "./BulkCrudOperator";
-/**
- * @summary Interface holding basic CRUD APIs
- * @typedef T extends {@link Model}
- * @interface IRepository
- */
-export interface IRepository<M extends Model> extends BulkCrudOperator<M> {
-    readonly class: Constructor<M>;
-    readonly pk: string;
-}

package/lib/interfaces/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./BulkCrudOperator";
-export * from "./Contextual";
-export * from "./CrudOperator";
-export * from "./IRepository";

package/lib/model/constants.d.ts

@@ -1,37 +0,0 @@
-/**
- * @summary Holds the Model reflection keys
- * @const DBKeys
- *
- * @memberOf module:db-decorators.Model
- */
-export declare const DBKeys: {
-    REFLECT: string;
-    REPOSITORY: string;
-    CLASS: string;
-    ID: string;
-    INDEX: string;
-    UNIQUE: string;
-    SERIALIZE: string;
-    READONLY: string;
-    TIMESTAMP: string;
-    HASH: string;
-    COMPOSED: string;
-    VERSION: string;
-    ORIGINAL: string;
-};
-/**
- * @summary The default separator when concatenating indexes
- *
- * @const DefaultIndexSeparator
- *
- * @category Managers
- * @subcategory Constants
- */
-export declare const DefaultSeparator = "_";
-/**
- * @summary Holds the default timestamp date format
- * @constant DEFAULT_TIMESTAMP_FORMAT
- *
- * @memberOf module:db-decorators.Model
- */
-export declare const DEFAULT_TIMESTAMP_FORMAT = "dd/MM/yyyy HH:mm:ss:S";

package/lib/model/decorators.d.ts

@@ -1,50 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { IRepository } from "../interfaces/IRepository";
-import { Context } from "../repository/Context";
-import { CrudOperations } from "../operations";
-/**
- *
- * @param {str} str
- * @memberOf db-decorators.model
- */
-export declare function hashOnCreateUpdate<M extends Model, R extends IRepository<M>, Y = any>(this: R, data: Y, key: string, model: M, oldModel?: M): void;
-export declare function hash(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export type ComposedFromMetadata = {
-    args: string[];
-    separator: string;
-    hashResult: boolean;
-    type: "keys" | "values";
-    prefix?: string;
-    suffix?: string;
-};
-export declare function composedFromCreateUpdate<M extends Model, V extends IRepository<M>>(this: V, context: Context<M>, data: ComposedFromMetadata, key: string, model: M): void;
-export declare function composedFromKeys(args: string[], separator?: string, hash?: boolean, prefix?: string, suffix?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function composed(args: string[], separator?: string, hash?: boolean, prefix?: string, suffix?: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-/**
- * Creates a decorator function that updates the version of a model during create or update operations.
- *
- * @param {CrudOperations} operation - The type of operation being performed (CREATE or UPDATE).
- * @returns {function} A function that updates the version of the model based on the operation type.
- *
- * @template M - Type extending Model
- * @template V - Type extending IRepository<M>
- *
- * @this {V} - The repository instance
- * @param {Context<M>} context - The context of the operation
- * @param {unknown} data - Additional data for the operation (not used in this function)
- * @param {string} key - The key of the version property in the model
- * @param {M} model - The model being updated
- * @throws {InternalError} If an invalid operation is provided or if version update fails
- */
-export declare function versionCreateUpdate(operation: CrudOperations): <M extends Model, V extends IRepository<M>>(this: V, context: Context<M>, data: unknown, key: string, model: M) => void;
-/**
- * @description Creates a decorator for versioning a property in a model.
- * @summary This decorator applies multiple sub-decorators to handle version management during create and update operations.
- *
- * @returns {Function} A composite decorator that:
- *   - Sets the type of the property to Number
- *   - Applies a version update on create operations
- *   - Applies a version update on update operations
- *   - Adds metadata indicating this property is used for versioning
- */
-export declare function version(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;

package/lib/model/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./validation";
-export * from "./constants";
-export * from "./decorators";
-export * from "./model";

package/lib/model/model.d.ts

@@ -1,112 +0,0 @@
-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/model/validation.d.ts

@@ -1,14 +0,0 @@
-import { Model, ModelErrorDefinition } from "@decaf-ts/decorator-validation";
-/**
- * @summary Validates the update of a model
- *
- * @param {T} oldModel
- * @param {T} newModel
- * @param {string[]} [exceptions]
- *
- * @function validateCompare
- * @return {ModelErrorDefinition | undefined}
- *
- * @memberOf module:db-decorators.Model
- */
-export declare function validateCompare<T extends Model>(oldModel: T, newModel: T, ...exceptions: string[]): ModelErrorDefinition | undefined;

package/lib/operations/Operations.d.ts

@@ -1,19 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-import { OperationHandler } from "./types";
-import { OperationKeys } from "./constants";
-/**
- * @summary Static class holding common Operation Functionality
- *
- * @class Operations
- *
- * @category Operations
- */
-export declare class Operations {
-    private static registry;
-    private constructor();
-    static getHandlerName(handler: OperationHandler<any, any, any>): any;
-    static key(str: string): string;
-    static get(targetName: string | Record<string, any>, propKey: string, operation: string): OperationHandler<Model, import("..").IRepository<Model>, unknown>[] | undefined;
-    private static getOpRegistry;
-    static register<V extends Model>(handler: OperationHandler<V, any, any>, operation: OperationKeys, target: V, propKey: string | symbol): void;
-}

package/lib/operations/OperationsRegistry.d.ts

@@ -1,34 +0,0 @@
-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
- *
- * @class OperationsRegistry
- * @implements IRegistry<OperationHandler<any>>
- *
- * @see OperationHandler
- *
- * @category Operations
- */
-export declare class OperationsRegistry {
-    private readonly cache;
-    /**
-     * @summary retrieves an {@link OperationHandler} if it exists
-     * @param {string} target
-     * @param {string} propKey
-     * @param {string} operation
-     * @param accum
-     * @return {OperationHandler | undefined}
-     */
-    get<T extends Model, V extends IRepository<T>, Y>(target: string | Record<string, any>, propKey: string, operation: string, accum?: OperationHandler<T, V, Y>[]): OperationHandler<T, V, Y>[] | undefined;
-    /**
-     * @summary Registers an {@link OperationHandler}
-     * @param {OperationHandler} handler
-     * @param {string} operation
-     * @param {{}} target
-     * @param {string | symbol} propKey
-     */
-    register<T extends Model, V extends IRepository<T>, Y>(handler: OperationHandler<T, V, Y>, operation: OperationKeys, target: T, propKey: string | symbol): void;
-}

package/lib/operations/constants.d.ts

@@ -1,24 +0,0 @@
-/**
- * @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 = "decaf.model.db.operations.",
-    CREATE = "create",
-    READ = "read",
-    UPDATE = "update",
-    DELETE = "delete",
-    ON = "on.",
-    AFTER = "after."
-}
-export type CrudOperations = OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE;
-/**
- * @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, CrudOperations[]>;

package/lib/operations/decorators.d.ts

@@ -1,193 +0,0 @@
-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, any> | UpdateOperationHandler<any, any, T, any>, data?: T): (target: object, propertyKey?: any) => 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, any>, data?: T): (target: object, propertyKey?: any) => 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, any>, data?: T): (target: object, propertyKey?: any) => 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, any>, data: T): (target: object, propertyKey?: any) => 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: OperationHandler<any, any, T, any>, data: T): (target: object, propertyKey?: any) => 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, any>, data: T): (target: object, propertyKey?: any) => 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, any>, data?: T): (target: object, propertyKey?: any) => 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, any> | UpdateOperationHandler<any, any, T, any>, data: T): (target: object, propertyKey?: any) => 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, any>, data: T): (target: object, propertyKey?: any) => 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, any>, data: T): (target: object, propertyKey?: any) => 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, any>, data?: T): (target: object, propertyKey?: any) => 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, any>, data?: T): (target: object, propertyKey?: any) => 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, any>, data?: T): (target: object, propertyKey?: any) => 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, any>, data?: T): (target: object, propertyKey?: any) => void;
-export declare function operation<T>(baseOp: OperationKeys.ON | OperationKeys.AFTER, operation: OperationKeys[] | undefined, handler: OperationHandler<any, any, T, any>, dataToAdd?: T): (target: object, propertyKey?: any) => void;

package/lib/operations/index.d.ts

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

package/lib/operations/types.d.ts

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