@decaf-ts/core 0.17.0 → 0.19.0

package/lib/types/tasks/models/TaskEventModel.d.mts

@@ -0,0 +1,11 @@
+import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
+import { TaskEventType } from "../constants.js";
+export declare class TaskEventModel extends Model {
+    id: string;
+    uuid: string;
+    taskId: string;
+    ts: Date;
+    classification: TaskEventType;
+    payload?: any;
+    constructor(arg?: ModelArg<TaskEventModel>);
+}

package/lib/types/tasks/models/TaskIOSerializer.d.cts

@@ -0,0 +1,33 @@
+import { JSONSerializer, Model } from "@decaf-ts/decorator-validation";
+export declare class TaskIOSerializer<M extends Model> extends JSONSerializer<M> {
+    constructor();
+    /**
+     * @summary prepares the model for serialization
+     * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property
+     * so the object can be recognized upon deserialization
+     *
+     * @param {any} value
+     * @protected
+     */
+    protected preSerialize(value: any, ...args: any[]): any;
+    /**
+     * @summary Rebuilds a model from a serialization
+     * @param {string} str
+     *
+     * @throws {Error} If it fails to parse the string, or to build the model
+     */
+    deserialize(str: string, ...args: any[]): M;
+    private serializeValue;
+    private serializeModel;
+    private serializePlain;
+    private getMetadata;
+    private rebuildValue;
+    private rebuildObject;
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @throws {Error} if fails to serialize
+     */
+    serialize(model: M, ...args: any[]): string;
+}

package/lib/types/tasks/models/TaskIOSerializer.d.mts

@@ -0,0 +1,33 @@
+import { JSONSerializer, Model } from "@decaf-ts/decorator-validation";
+export declare class TaskIOSerializer<M extends Model> extends JSONSerializer<M> {
+    constructor();
+    /**
+     * @summary prepares the model for serialization
+     * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property
+     * so the object can be recognized upon deserialization
+     *
+     * @param {any} value
+     * @protected
+     */
+    protected preSerialize(value: any, ...args: any[]): any;
+    /**
+     * @summary Rebuilds a model from a serialization
+     * @param {string} str
+     *
+     * @throws {Error} If it fails to parse the string, or to build the model
+     */
+    deserialize(str: string, ...args: any[]): M;
+    private serializeValue;
+    private serializeModel;
+    private serializePlain;
+    private getMetadata;
+    private rebuildValue;
+    private rebuildObject;
+    /**
+     * @summary Serializes a model
+     * @param {T} model
+     *
+     * @throws {Error} if fails to serialize
+     */
+    serialize(model: M, ...args: any[]): string;
+}

package/lib/types/tasks/models/TaskLogEntryModel.d.cts

@@ -0,0 +1,10 @@
+import { LogLevel } from "@decaf-ts/logging";
+import { type ModelArg, Model } from "@decaf-ts/decorator-validation";
+export declare class TaskLogEntryModel extends Model {
+    ts: Date;
+    level: LogLevel;
+    step?: number;
+    msg: string;
+    meta?: any;
+    constructor(arg?: ModelArg<TaskLogEntryModel>);
+}

package/lib/types/tasks/models/TaskLogEntryModel.d.mts

@@ -0,0 +1,10 @@
+import { LogLevel } from "@decaf-ts/logging";
+import { type ModelArg, Model } from "@decaf-ts/decorator-validation";
+export declare class TaskLogEntryModel extends Model {
+    ts: Date;
+    level: LogLevel;
+    step?: number;
+    msg: string;
+    meta?: any;
+    constructor(arg?: ModelArg<TaskLogEntryModel>);
+}

package/lib/types/tasks/models/TaskModel.d.cts

@@ -0,0 +1,43 @@
+import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
+import { TaskStatus, TaskType } from "../constants.cjs";
+import { TaskErrorModel } from "./TaskErrorModel.cjs";
+import { TaskBackoffModel } from "./TaskBackoffModel.cjs";
+import { TaskStepSpecModel } from "./TaskStepSpecModel.cjs";
+import { TaskStepResultModel } from "./TaskStepResultModel.cjs";
+import { TaskLogEntryModel } from "./TaskLogEntryModel.cjs";
+export declare class TaskModel<INPUT = any, OUTPUT = any> extends Model {
+    id: string;
+    atomicity: TaskType;
+    classification: string;
+    name?: string;
+    lock?: string;
+    status: TaskStatus;
+    input?: INPUT;
+    output?: OUTPUT;
+    error?: TaskErrorModel;
+    attempt: number;
+    maxAttempts: number;
+    backoff: TaskBackoffModel;
+    nextRunAt?: Date;
+    scheduledTo?: Date;
+    dependencies?: string[];
+    leaseOwner?: string;
+    leaseExpiry?: Date;
+    steps?: TaskStepSpecModel[];
+    currentStep?: number;
+    stepResults?: TaskStepResultModel[];
+    logTail?: TaskLogEntryModel[];
+    /**
+     * @description Creation timestamp for the model
+     * @summary Automatically set to the current date and time when the model is created
+     */
+    createdAt: Date;
+    /**
+     * @description Last update timestamp for the model
+     * @summary Automatically updated to the current date and time whenever the model is modified
+     */
+    updatedAt: Date;
+    createdBy: string;
+    updatedBy: string;
+    constructor(arg?: ModelArg<TaskModel>);
+}

package/lib/types/tasks/models/TaskModel.d.mts

@@ -0,0 +1,43 @@
+import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
+import { TaskStatus, TaskType } from "../constants.js";
+import { TaskErrorModel } from "./TaskErrorModel.js";
+import { TaskBackoffModel } from "./TaskBackoffModel.js";
+import { TaskStepSpecModel } from "./TaskStepSpecModel.js";
+import { TaskStepResultModel } from "./TaskStepResultModel.js";
+import { TaskLogEntryModel } from "./TaskLogEntryModel.js";
+export declare class TaskModel<INPUT = any, OUTPUT = any> extends Model {
+    id: string;
+    atomicity: TaskType;
+    classification: string;
+    name?: string;
+    lock?: string;
+    status: TaskStatus;
+    input?: INPUT;
+    output?: OUTPUT;
+    error?: TaskErrorModel;
+    attempt: number;
+    maxAttempts: number;
+    backoff: TaskBackoffModel;
+    nextRunAt?: Date;
+    scheduledTo?: Date;
+    dependencies?: string[];
+    leaseOwner?: string;
+    leaseExpiry?: Date;
+    steps?: TaskStepSpecModel[];
+    currentStep?: number;
+    stepResults?: TaskStepResultModel[];
+    logTail?: TaskLogEntryModel[];
+    /**
+     * @description Creation timestamp for the model
+     * @summary Automatically set to the current date and time when the model is created
+     */
+    createdAt: Date;
+    /**
+     * @description Last update timestamp for the model
+     * @summary Automatically updated to the current date and time whenever the model is modified
+     */
+    updatedAt: Date;
+    createdBy: string;
+    updatedBy: string;
+    constructor(arg?: ModelArg<TaskModel>);
+}

package/lib/types/tasks/models/TaskStepResultModel.d.cts

@@ -0,0 +1,9 @@
+import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
+import { TaskStatus } from "../constants.cjs";
+import { TaskErrorModel } from "./TaskErrorModel.cjs";
+export declare class TaskStepResultModel extends Model {
+    status: TaskStatus;
+    output?: any;
+    error?: TaskErrorModel;
+    constructor(arg?: ModelArg<TaskStepResultModel>);
+}

package/lib/types/tasks/models/TaskStepResultModel.d.mts

@@ -0,0 +1,9 @@
+import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
+import { TaskStatus } from "../constants.js";
+import { TaskErrorModel } from "./TaskErrorModel.js";
+export declare class TaskStepResultModel extends Model {
+    status: TaskStatus;
+    output?: any;
+    error?: TaskErrorModel;
+    constructor(arg?: ModelArg<TaskStepResultModel>);
+}

package/lib/types/tasks/models/TaskStepSpecModel.d.cts

@@ -0,0 +1,9 @@
+import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
+export declare class TaskStepSpecModel extends Model {
+    classification: string;
+    name?: string;
+    input?: any;
+    lock?: string;
+    dependsOn?: string[];
+    constructor(arg?: ModelArg<TaskStepSpecModel>);
+}

package/lib/types/tasks/models/TaskStepSpecModel.d.mts

@@ -0,0 +1,9 @@
+import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
+export declare class TaskStepSpecModel extends Model {
+    classification: string;
+    name?: string;
+    input?: any;
+    lock?: string;
+    dependsOn?: string[];
+    constructor(arg?: ModelArg<TaskStepSpecModel>);
+}

package/lib/types/tasks/models/index.d.cts

@@ -0,0 +1,8 @@
+export * from "./TaskBackoffModel.cjs";
+export * from "./TaskErrorModel.cjs";
+export * from "./TaskEventModel.cjs";
+export * from "./TaskIOSerializer.cjs";
+export * from "./TaskLogEntryModel.cjs";
+export * from "./TaskModel.cjs";
+export * from "./TaskStepResultModel.cjs";
+export * from "./TaskStepSpecModel.cjs";

package/lib/types/tasks/models/index.d.mts

@@ -0,0 +1,8 @@
+export * from "./TaskBackoffModel.js";
+export * from "./TaskErrorModel.js";
+export * from "./TaskEventModel.js";
+export * from "./TaskIOSerializer.js";
+export * from "./TaskLogEntryModel.js";
+export * from "./TaskModel.js";
+export * from "./TaskStepResultModel.js";
+export * from "./TaskStepSpecModel.js";

package/lib/types/tasks/types.d.cts

@@ -0,0 +1,71 @@
+import { TaskContext } from "./TaskContext.cjs";
+import { TaskLogger } from "./logging.cjs";
+import { LogLevel } from "@decaf-ts/logging";
+import { Adapter, ContextFlags } from "../persistence/index.cjs";
+import { ConfOf } from "../persistence/types.cjs";
+import { TaskEventBus } from "./TaskEventBus.cjs";
+import { TaskHandlerRegistry } from "./TaskHandlerRegistry.cjs";
+import { TaskEventModel } from "./models/TaskEventModel.cjs";
+import { TaskStatus } from "./constants.cjs";
+import { TaskErrorModel } from "./models/TaskErrorModel.cjs";
+import { TaskStepSpecModel } from "./models/TaskStepSpecModel.cjs";
+export interface ITaskHandler<I = any, O = any> {
+    type: string;
+    run(input: I, ctx: TaskContext): Promise<O>;
+    catch?(input: I, error: unknown, ctx: TaskContext): Promise<void>;
+}
+export type TaskDependencySpec = {
+    dependencies?: string[];
+};
+export type LogPipeOptions = {
+    style: boolean;
+    logProgress: boolean;
+    logStatus: boolean;
+};
+export type EventPipe = (evt: TaskEventModel, ...args: any[]) => Promise<void>;
+export interface LogPipe {
+    (logs: [LogLevel, string, any][]): Promise<void>;
+    (entry: [LogLevel, string] | [LogLevel, string, any]): Promise<void>;
+    (level: LogLevel, msg: string, meta?: any): Promise<void>;
+}
+export interface TaskFlags<LOG extends TaskLogger<any> = TaskLogger<any>> extends ContextFlags<LOG> {
+    taskId: string;
+    attempt: number;
+    pipe: LogPipe;
+    flush: () => Promise<void>;
+    progress: (data: any) => Promise<void>;
+    heartbeat: () => Promise<void>;
+    scheduleCompositeSteps?: (steps: TaskStepSpecModel[]) => Promise<void>;
+    resultCache?: Record<string, any>;
+}
+export type TaskEngineConfig<A extends Adapter<any, any, any, any>> = {
+    adapter: A;
+    overrides?: Partial<ConfOf<A>>;
+    bus?: TaskEventBus;
+    registry?: TaskHandlerRegistry;
+    workerId: string;
+    concurrency: number;
+    leaseMs: number;
+    pollMsIdle: number;
+    pollMsBusy: number;
+    logTailMax: number;
+    streamBufferSize: number;
+    maxLoggingBuffer: number;
+    loggingBufferTruncation: number;
+    gracefulShutdownMsTimeout: number;
+    autoShutdown?: TaskEngineAutoShutdownConfig;
+};
+export type TaskProgressPayload = {
+    status: TaskStatus | "update";
+    currentStep?: number;
+    totalSteps?: number;
+    output?: any;
+    error?: TaskErrorModel;
+    nextRunAt?: Date;
+    scheduledTo?: Date;
+};
+export interface TaskEngineAutoShutdownConfig {
+    enabled?: boolean;
+    backoffStepMs?: number;
+    maxIdleDelayMs?: number;
+}

package/lib/types/tasks/types.d.mts

@@ -0,0 +1,71 @@
+import { TaskContext } from "./TaskContext.js";
+import { TaskLogger } from "./logging.js";
+import { LogLevel } from "@decaf-ts/logging";
+import { Adapter, ContextFlags } from "../persistence/index.js";
+import { ConfOf } from "../persistence/types.js";
+import { TaskEventBus } from "./TaskEventBus.js";
+import { TaskHandlerRegistry } from "./TaskHandlerRegistry.js";
+import { TaskEventModel } from "./models/TaskEventModel.js";
+import { TaskStatus } from "./constants.js";
+import { TaskErrorModel } from "./models/TaskErrorModel.js";
+import { TaskStepSpecModel } from "./models/TaskStepSpecModel.js";
+export interface ITaskHandler<I = any, O = any> {
+    type: string;
+    run(input: I, ctx: TaskContext): Promise<O>;
+    catch?(input: I, error: unknown, ctx: TaskContext): Promise<void>;
+}
+export type TaskDependencySpec = {
+    dependencies?: string[];
+};
+export type LogPipeOptions = {
+    style: boolean;
+    logProgress: boolean;
+    logStatus: boolean;
+};
+export type EventPipe = (evt: TaskEventModel, ...args: any[]) => Promise<void>;
+export interface LogPipe {
+    (logs: [LogLevel, string, any][]): Promise<void>;
+    (entry: [LogLevel, string] | [LogLevel, string, any]): Promise<void>;
+    (level: LogLevel, msg: string, meta?: any): Promise<void>;
+}
+export interface TaskFlags<LOG extends TaskLogger<any> = TaskLogger<any>> extends ContextFlags<LOG> {
+    taskId: string;
+    attempt: number;
+    pipe: LogPipe;
+    flush: () => Promise<void>;
+    progress: (data: any) => Promise<void>;
+    heartbeat: () => Promise<void>;
+    scheduleCompositeSteps?: (steps: TaskStepSpecModel[]) => Promise<void>;
+    resultCache?: Record<string, any>;
+}
+export type TaskEngineConfig<A extends Adapter<any, any, any, any>> = {
+    adapter: A;
+    overrides?: Partial<ConfOf<A>>;
+    bus?: TaskEventBus;
+    registry?: TaskHandlerRegistry;
+    workerId: string;
+    concurrency: number;
+    leaseMs: number;
+    pollMsIdle: number;
+    pollMsBusy: number;
+    logTailMax: number;
+    streamBufferSize: number;
+    maxLoggingBuffer: number;
+    loggingBufferTruncation: number;
+    gracefulShutdownMsTimeout: number;
+    autoShutdown?: TaskEngineAutoShutdownConfig;
+};
+export type TaskProgressPayload = {
+    status: TaskStatus | "update";
+    currentStep?: number;
+    totalSteps?: number;
+    output?: any;
+    error?: TaskErrorModel;
+    nextRunAt?: Date;
+    scheduledTo?: Date;
+};
+export interface TaskEngineAutoShutdownConfig {
+    enabled?: boolean;
+    backoffStepMs?: number;
+    maxIdleDelayMs?: number;
+}

package/lib/types/tasks/utils.d.cts

@@ -0,0 +1,5 @@
+import { TaskErrorModel } from "./models/TaskErrorModel.cjs";
+import { TaskBackoffModel } from "./models/TaskBackoffModel.cjs";
+export declare function computeBackoffMs(attempt: number, cfg: TaskBackoffModel): number;
+export declare function serializeError(err: any): TaskErrorModel;
+export declare function sleep(ms: number): Promise<unknown>;

package/lib/types/tasks/utils.d.mts

@@ -0,0 +1,5 @@
+import { TaskErrorModel } from "./models/TaskErrorModel.js";
+import { TaskBackoffModel } from "./models/TaskBackoffModel.js";
+export declare function computeBackoffMs(attempt: number, cfg: TaskBackoffModel): number;
+export declare function serializeError(err: any): TaskErrorModel;
+export declare function sleep(ms: number): Promise<unknown>;

package/lib/types/utils/ContextualLoggedClass.d.cts

@@ -0,0 +1,37 @@
+import { LoggedClass, Logger } from "@decaf-ts/logging";
+import { BulkCrudOperationKeys, Contextual, OperationKeys } from "@decaf-ts/db-decorators";
+import { Context } from "../persistence/Context.cjs";
+import { FlagsOf, LoggerOf } from "../persistence/types.cjs";
+import type { Constructor } from "@decaf-ts/decoration";
+import { PersistenceKeys } from "../persistence/index.cjs";
+import { PreparedStatementKeys } from "../query/index.cjs";
+export type ContextualArgs<C extends Context<any>, ARGS extends any[] = any[]> = [...ARGS, C];
+export type MethodOrOperation = ((...args: any[]) => any) | string | OperationKeys | PersistenceKeys | BulkCrudOperationKeys | PreparedStatementKeys;
+export type MaybeContextualArg<C extends Context<any>, ARGS extends any[] = any[]> = any[] | ContextualArgs<C, ARGS>;
+export type ContextualizedArgs<C extends Context<any>, ARGS extends any[] = any[], EXTEND extends boolean = false> = EXTEND extends true ? {
+    ctx: C;
+    log: LoggerOf<C>;
+    ctxArgs: ContextualArgs<C, ARGS>;
+    for: (...any: any[]) => ContextualizedArgs<C, ARGS, false>;
+} : {
+    ctx: C;
+    log: LoggerOf<C>;
+    ctxArgs: ContextualArgs<C, ARGS>;
+};
+export declare abstract class ContextualLoggedClass<C extends Context<any>> extends LoggedClass {
+    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
+    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FlagsOf<CONTEXT>>): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
+    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FlagsOf<CONTEXT>>): Promise<ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>>;
+    static logFrom<CONTEXT extends Context<any>, A = any | Contextual<CONTEXT>, METHOD extends MethodOrOperation = MethodOrOperation>(obj: A, logger: LoggerOf<any>, ctx: CONTEXT, method?: METHOD | keyof A): Logger;
+    static logCtx<CONTEXT extends Context<any>, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(this: any, operation: METHOD, ...args: MaybeContextualArg<CONTEXT, ARGS>): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
+}
+export declare abstract class AbsContextual<C extends Context<any>> extends ContextualLoggedClass<C> implements Contextual<C> {
+    protected constructor();
+    /**
+     * @description The context constructor for this adapter
+     * @summary Reference to the context class constructor used by this adapter
+     */
+    private readonly _Context;
+    protected get Context(): Constructor<C>;
+    context(operation: ((...args: any[]) => any) | OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE | string, overrides: Partial<FlagsOf<C>>, ...args: MaybeContextualArg<Context<any>, any[]>): Promise<C>;
+}

package/lib/types/utils/ContextualLoggedClass.d.mts

@@ -0,0 +1,37 @@
+import { LoggedClass, Logger } from "@decaf-ts/logging";
+import { BulkCrudOperationKeys, Contextual, OperationKeys } from "@decaf-ts/db-decorators";
+import { Context } from "../persistence/Context.js";
+import { FlagsOf, LoggerOf } from "../persistence/types.js";
+import type { Constructor } from "@decaf-ts/decoration";
+import { PersistenceKeys } from "../persistence/index.js";
+import { PreparedStatementKeys } from "../query/index.js";
+export type ContextualArgs<C extends Context<any>, ARGS extends any[] = any[]> = [...ARGS, C];
+export type MethodOrOperation = ((...args: any[]) => any) | string | OperationKeys | PersistenceKeys | BulkCrudOperationKeys | PreparedStatementKeys;
+export type MaybeContextualArg<C extends Context<any>, ARGS extends any[] = any[]> = any[] | ContextualArgs<C, ARGS>;
+export type ContextualizedArgs<C extends Context<any>, ARGS extends any[] = any[], EXTEND extends boolean = false> = EXTEND extends true ? {
+    ctx: C;
+    log: LoggerOf<C>;
+    ctxArgs: ContextualArgs<C, ARGS>;
+    for: (...any: any[]) => ContextualizedArgs<C, ARGS, false>;
+} : {
+    ctx: C;
+    log: LoggerOf<C>;
+    ctxArgs: ContextualArgs<C, ARGS>;
+};
+export declare abstract class ContextualLoggedClass<C extends Context<any>> extends LoggedClass {
+    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
+    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FlagsOf<CONTEXT>>): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
+    protected logCtx<CONTEXT extends Context<any> = C, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FlagsOf<CONTEXT>>): Promise<ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>>;
+    static logFrom<CONTEXT extends Context<any>, A = any | Contextual<CONTEXT>, METHOD extends MethodOrOperation = MethodOrOperation>(obj: A, logger: LoggerOf<any>, ctx: CONTEXT, method?: METHOD | keyof A): Logger;
+    static logCtx<CONTEXT extends Context<any>, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(this: any, operation: METHOD, ...args: MaybeContextualArg<CONTEXT, ARGS>): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
+}
+export declare abstract class AbsContextual<C extends Context<any>> extends ContextualLoggedClass<C> implements Contextual<C> {
+    protected constructor();
+    /**
+     * @description The context constructor for this adapter
+     * @summary Reference to the context class constructor used by this adapter
+     */
+    private readonly _Context;
+    protected get Context(): Constructor<C>;
+    context(operation: ((...args: any[]) => any) | OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE | string, overrides: Partial<FlagsOf<C>>, ...args: MaybeContextualArg<Context<any>, any[]>): Promise<C>;
+}

package/lib/types/utils/decorators.d.cts

@@ -0,0 +1,27 @@
+import { Constructor } from "@decaf-ts/decoration";
+import type { ModelConstructor } from "@decaf-ts/decorator-validation";
+import { HttpVerbs } from "./types.cjs";
+export declare const create: () => (target: any, _propertyKey?: any, descriptor?: any) => any;
+export declare const read: () => (target: any, _propertyKey?: any, descriptor?: any) => any;
+export declare const update: () => (target: any, _propertyKey?: any, descriptor?: any) => any;
+export declare const del: () => (target: any, _propertyKey?: any, descriptor?: any) => any;
+export declare function service(key?: string | ModelConstructor<any>): (target: any, prop?: any, descriptor?: any) => void;
+export declare function auth(model: string | Constructor): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * A decorator function that sets the roles required for authentication and authorization to the model in NestJS.
+ *
+ * @param roles - An array of role names required for access.
+ *
+ * @returns - A function that applies the role decorators to the target.
+ *
+ * @example
+ * ```typescript
+ * @model('users')
+ * @Roles(['admin'])
+ * export class UserModel {
+ *  //...
+ * }
+ *
+ */
+export declare const roles: (roles: string[]) => (model: any, prop?: any, descriptor?: PropertyDescriptor | number) => void;
+export declare function route(httpMethod: HttpVerbs, path: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/utils/decorators.d.mts

@@ -0,0 +1,27 @@
+import { Constructor } from "@decaf-ts/decoration";
+import type { ModelConstructor } from "@decaf-ts/decorator-validation";
+import { HttpVerbs } from "./types.js";
+export declare const create: () => (target: any, _propertyKey?: any, descriptor?: any) => any;
+export declare const read: () => (target: any, _propertyKey?: any, descriptor?: any) => any;
+export declare const update: () => (target: any, _propertyKey?: any, descriptor?: any) => any;
+export declare const del: () => (target: any, _propertyKey?: any, descriptor?: any) => any;
+export declare function service(key?: string | ModelConstructor<any>): (target: any, prop?: any, descriptor?: any) => void;
+export declare function auth(model: string | Constructor): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * A decorator function that sets the roles required for authentication and authorization to the model in NestJS.
+ *
+ * @param roles - An array of role names required for access.
+ *
+ * @returns - A function that applies the role decorators to the target.
+ *
+ * @example
+ * ```typescript
+ * @model('users')
+ * @Roles(['admin'])
+ * export class UserModel {
+ *  //...
+ * }
+ *
+ */
+export declare const roles: (roles: string[]) => (model: any, prop?: any, descriptor?: PropertyDescriptor | number) => void;
+export declare function route(httpMethod: HttpVerbs, path: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/utils/errors.d.cts

@@ -0,0 +1,56 @@
+import { BadRequestError, InternalError } from "@decaf-ts/db-decorators";
+/**
+ * @description Error thrown when a user is not authorized to perform an action
+ * @summary This error is thrown when a user attempts to access a resource or perform an action without proper authentication
+ * @param {string|Error} msg - The error message or Error object
+ * @class AuthorizationError
+ * @category Errors
+ * @example
+ * ```typescript
+ * // Example of throwing an AuthorizationError
+ * if (!user.isAuthenticated()) {
+ *   throw new AuthorizationError('User not authenticated');
+ * }
+ * ```
+ */
+export declare class AuthorizationError extends BadRequestError {
+    constructor(msg: string | Error, name?: string, code?: number);
+}
+/**
+ * @description Error thrown when a user is forbidden from accessing a resource
+ * @summary This error is thrown when an authenticated user attempts to access a resource or perform an action they don't have permission for
+ * @param {string|Error} msg - The error message or Error object
+ * @return {void}
+ * @class ForbiddenError
+ * @category Errors
+ * @example
+ * ```typescript
+ * // Example of throwing a ForbiddenError
+ * if (!user.hasPermission('admin')) {
+ *   throw new ForbiddenError('User does not have admin permissions');
+ * }
+ * ```
+ */
+export declare class ForbiddenError extends AuthorizationError {
+    constructor(msg: string | Error, name?: string);
+}
+/**
+ * @description Error thrown when a connection to a service fails
+ * @summary This error is thrown when the application fails to establish a connection to a required service or resource
+ * @param {string|Error} msg - The error message or Error object
+ * @return {void}
+ * @class ConnectionError
+ * @category Errors
+ * @example
+ * ```typescript
+ * // Example of throwing a ConnectionError
+ * try {
+ *   await database.connect();
+ * } catch (error) {
+ *   throw new ConnectionError('Failed to connect to database');
+ * }
+ * ```
+ */
+export declare class ConnectionError extends InternalError {
+    constructor(msg: string | Error);
+}

package/lib/types/utils/errors.d.mts

@@ -0,0 +1,56 @@
+import { BadRequestError, InternalError } from "@decaf-ts/db-decorators";
+/**
+ * @description Error thrown when a user is not authorized to perform an action
+ * @summary This error is thrown when a user attempts to access a resource or perform an action without proper authentication
+ * @param {string|Error} msg - The error message or Error object
+ * @class AuthorizationError
+ * @category Errors
+ * @example
+ * ```typescript
+ * // Example of throwing an AuthorizationError
+ * if (!user.isAuthenticated()) {
+ *   throw new AuthorizationError('User not authenticated');
+ * }
+ * ```
+ */
+export declare class AuthorizationError extends BadRequestError {
+    constructor(msg: string | Error, name?: string, code?: number);
+}
+/**
+ * @description Error thrown when a user is forbidden from accessing a resource
+ * @summary This error is thrown when an authenticated user attempts to access a resource or perform an action they don't have permission for
+ * @param {string|Error} msg - The error message or Error object
+ * @return {void}
+ * @class ForbiddenError
+ * @category Errors
+ * @example
+ * ```typescript
+ * // Example of throwing a ForbiddenError
+ * if (!user.hasPermission('admin')) {
+ *   throw new ForbiddenError('User does not have admin permissions');
+ * }
+ * ```
+ */
+export declare class ForbiddenError extends AuthorizationError {
+    constructor(msg: string | Error, name?: string);
+}
+/**
+ * @description Error thrown when a connection to a service fails
+ * @summary This error is thrown when the application fails to establish a connection to a required service or resource
+ * @param {string|Error} msg - The error message or Error object
+ * @return {void}
+ * @class ConnectionError
+ * @category Errors
+ * @example
+ * ```typescript
+ * // Example of throwing a ConnectionError
+ * try {
+ *   await database.connect();
+ * } catch (error) {
+ *   throw new ConnectionError('Failed to connect to database');
+ * }
+ * ```
+ */
+export declare class ConnectionError extends InternalError {
+    constructor(msg: string | Error);
+}