@decaf-ts/core 0.24.0 → 0.25.0

package/lib/types/tasks/TaskService.d.ts

@@ -1,65 +0,0 @@
-import { type ContextualArgs, type ContextualizedArgs, type MaybeContextualArg, type MethodOrOperation } from "../utils/ContextualLoggedClass";
-import { ClientBasedService } from "../services/services";
-import { TaskEngine } from "./TaskEngine";
-import { Adapter } from "../persistence/Adapter";
-import { type AllOperationKeys, type ContextOf, type EventIds, type ObserverFilter } from "../persistence/types";
-import { type PrimaryKeyType } from "@decaf-ts/db-decorators";
-import { OrderDirection } from "../repository/constants";
-import { type Repo } from "../repository/Repository";
-import { TaskModel } from "./models/TaskModel";
-import { type DirectionLimitOffset } from "../query/types";
-import type { Constructor } from "@decaf-ts/decoration";
-import type { Observer } from "../interfaces/Observer";
-import type { ArrayMode } from "../services/ModelService";
-import { TaskEngineConfig } from "./types";
-import { TaskTracker } from "./TaskTracker";
-import { TaskEventModel } from "./models/index";
-import { SelectSelector, WhereOption } from "../query/index";
-export type TaskServiceConfig<A extends Adapter<any, any, any, any>, T extends TaskEngine<A> = TaskEngine<A>, C extends TaskEngineConfig<A> = TaskEngineConfig<A>> = C & {
-    engine?: Constructor<T>;
-};
-export declare class TaskService<A extends Adapter<any, any, any, any>> extends ClientBasedService<TaskEngine<A>, TaskEngineConfig<A>> {
-    protected get adapter(): A;
-    protected get tasks(): Repo<TaskModel>;
-    protected get events(): Repo<TaskEventModel>;
-    constructor();
-    initialize(...args: MaybeContextualArg<ContextOf<A>>): Promise<{
-        config: TaskServiceConfig<A, any, any>;
-        client: TaskEngine<A>;
-    }>;
-    push<I, O>(task: TaskModel<I, O>, ...args: MaybeContextualArg<any>): Promise<TaskModel<I, O>>;
-    push<I, O>(task: TaskModel<I, O>, track: false, ...args: MaybeContextualArg<any>): Promise<TaskModel<I, O>>;
-    push<I, O>(task: TaskModel<I, O>, track: true, ...args: MaybeContextualArg<any>): Promise<{
-        task: TaskModel<I, O>;
-        tracker: TaskTracker<O>;
-    }>;
-    track(id: string, ...args: MaybeContextualArg<any>): Promise<{
-        task: TaskModel;
-        tracker: TaskTracker<any>;
-    }>;
-    select<S extends readonly SelectSelector<TaskModel>[]>(): WhereOption<TaskModel, TaskModel[]>;
-    select<S extends readonly SelectSelector<TaskModel>[]>(selector: readonly [...S]): WhereOption<TaskModel, Pick<TaskModel, S[number]>[]>;
-    create(model: TaskModel, ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel>;
-    createAll(models: TaskModel[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel[]>;
-    delete(key: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel>;
-    deleteAll(keys: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel[]>;
-    read(key: PrimaryKeyType, ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel>;
-    readAll(keys: PrimaryKeyType[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel[]>;
-    query<M, R extends ArrayMode = "one">(methodName: string, ...args: MaybeContextualArg<ContextOf<A>>): Promise<R extends "one" ? M : M[]>;
-    update(model: TaskModel, ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel>;
-    updateAll(models: TaskModel[], ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel[]>;
-    listBy(key: keyof TaskModel, order: OrderDirection, ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel<any, any>[]>;
-    paginateBy(key: keyof TaskModel, order: OrderDirection, ref: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<ContextOf<A>>): Promise<import("..").SerializedPage<TaskModel<any, any>>>;
-    findOneBy(key: keyof TaskModel, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel<any, any>>;
-    findBy(key: keyof TaskModel, value: any, ...args: MaybeContextualArg<ContextOf<A>>): Promise<TaskModel<any, any>[]>;
-    findByPaginate(key: keyof TaskModel, value: any, ref: DirectionLimitOffset, ...args: MaybeContextualArg<ContextOf<A>>): Promise<import("..").SerializedPage<TaskModel<any, any>>>;
-    statement(name: string, ...args: MaybeContextualArg<ContextOf<A>>): Promise<any>;
-    refresh(table: Constructor<any>, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<ContextOf<A>>): Promise<void>;
-    observe(observer: Observer, filter?: ObserverFilter): () => void;
-    unObserve(observer: Observer): void;
-    updateObservers(model: Constructor, operation: AllOperationKeys, ids: EventIds, ...args: ContextualArgs<ContextOf<A>>): Promise<void>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<ContextOf<A>, ARGS>, operation: METHOD): ContextualizedArgs<ContextOf<A>, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<ContextOf<A>, ARGS>, operation: METHOD, allowCreate: false): ContextualizedArgs<ContextOf<A>, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<ContextOf<A>, ARGS>, operation: METHOD, allowCreate: true): Promise<ContextualizedArgs<ContextOf<A>, ARGS, METHOD extends string ? true : false>>;
-    shutdown(...args: MaybeContextualArg<any>): Promise<void>;
-}

package/lib/types/tasks/TaskStateChangeError.d.ts

@@ -1,11 +0,0 @@
-import { TaskStatus } from "./constants";
-import { TaskErrorModel } from "./models/TaskErrorModel";
-export interface TaskStateChangeRequest {
-    status: TaskStatus;
-    error?: TaskErrorModel;
-    scheduledTo?: Date;
-}
-export declare class TaskStateChangeError extends Error {
-    readonly request: TaskStateChangeRequest;
-    constructor(request: TaskStateChangeRequest);
-}

package/lib/types/tasks/TaskTracker.d.ts

@@ -1,47 +0,0 @@
-import { Observer } from "../interfaces/Observer";
-import { TaskEventModel } from "./models/TaskEventModel";
-import { Logger } from "@decaf-ts/logging";
-import { TaskEventType, TaskStatus } from "./constants";
-import { EventPipe, LogPipe, LogPipeOptions } from "./types";
-import { TaskModel } from "./models/TaskModel";
-import { Context } from "../persistence/index";
-import { TaskEventBus } from "./TaskEventBus";
-import { TaskControlError } from "./TaskErrors";
-export declare class TaskTracker<O = any> implements Observer<[TaskEventModel, Context]> {
-    protected bus: TaskEventBus;
-    private readonly task;
-    protected unregistration: () => void;
-    protected pipes?: Record<TaskEventType, Set<EventPipe>>;
-    private resolved;
-    private terminalContext?;
-    constructor(bus: TaskEventBus, task: TaskModel);
-    resolve(): Promise<O>;
-    wait(): Promise<O>;
-    attach(log: Logger, opts?: LogPipeOptions): void;
-    logs(pipe: LogPipe): void;
-    pipe(pipe: EventPipe, type?: TaskEventType): void;
-    protected succeed(_result?: O): void;
-    protected fail(_error?: TaskControlError): void;
-    protected cancel(evt: TaskEventModel): void;
-    protected retry(): void;
-    protected reschedule(): void;
-    onSucceed(handler: EventPipe): () => void;
-    onFailure(handler: EventPipe): () => void;
-    onCancel(handler: EventPipe): () => void;
-    onUpdate(handler: EventPipe): () => void;
-    private awaitStatusTerminal;
-    private extractOutput;
-    private extractError;
-    private complete;
-    protected isTerminalStatus(status: TaskStatus): boolean;
-    protected track(evt: TaskEventModel, ctx: Context): Promise<void>;
-    private registerStatusHandler;
-    private getTerminalContext;
-    private buildTerminalEvent;
-    private createTaskControlError;
-    private assignNextAction;
-    private getNextAction;
-    private buildMeta;
-    private resolveTerminalState;
-    refresh(evt: TaskEventModel, ctx: Context): Promise<void>;
-}

package/lib/types/tasks/builder.d.ts

@@ -1,72 +0,0 @@
-import { TaskModel } from "./models/TaskModel";
-import { BackoffStrategy, JitterStrategy, TaskStatus, TaskType } from "./constants";
-import { TaskBackoffModel } from "./models/index";
-import { TaskStepSpecModel } from "./models/TaskStepSpecModel";
-import { Model, ModelArg } from "@decaf-ts/decorator-validation";
-export declare class TaskBackoffBuilder<NESTED extends boolean = false> extends Model {
-    baseMs: number;
-    jitter: JitterStrategy;
-    maxMs: number;
-    strategy: BackoffStrategy;
-    constructor(arg?: ModelArg<TaskBackoffBuilder>);
-    setBaseMs(value: number): this;
-    setJitter(value: JitterStrategy): this;
-    setMaxMs(value: number): this;
-    setStrategy(value: BackoffStrategy): this;
-    build(): NESTED extends false ? TaskBackoffModel : TaskBuilder;
-}
-export declare class TaskBuilder extends Model {
-    protected classification: string;
-    protected name?: string;
-    protected status: TaskStatus;
-    protected atomicity: TaskType;
-    protected backoff: TaskBackoffModel;
-    protected input?: any;
-    protected lock?: string;
-    protected dependencies?: string[];
-    protected maxAttempts: number;
-    setClassification(value: string): this;
-    setName(value: string): this;
-    setAtomicity(value: TaskType): this;
-    setBackoff<V extends TaskBackoffModel>(value?: TaskBackoffModel): V extends TaskBackoffModel ? this : TaskBackoffBuilder<true>;
-    setInput(value: any): this;
-    setLock(value?: string): this;
-    setDependencies(value?: string[]): this;
-    setDependsOn(value?: string[]): this;
-    setMaxAttempts(value: number): this;
-    constructor(arg?: ModelArg<TaskBuilder>);
-    build(): TaskModel<any, any>;
-}
-export declare class TaskStepSpecBuilder {
-    protected parent: CompositeTaskBuilder;
-    protected step: TaskStepSpecModel;
-    constructor(parent: CompositeTaskBuilder, step: TaskStepSpecModel);
-    setClassification(value: string): this;
-    setName(value?: string): this;
-    setInput(value: any): this;
-    setLock(value?: string): this;
-    setDependsOn(value?: string[]): this;
-    addStep(classification: string): TaskStepSpecBuilder;
-    addStep(classification: string, input: any): CompositeTaskBuilder;
-    addStep(classification: string, name: string, input?: any): CompositeTaskBuilder;
-    setSteps(value: TaskStepSpecModel[]): CompositeTaskBuilder;
-    build(): CompositeTaskBuilder;
-}
-export declare class CompositeTaskBuilder extends TaskBuilder {
-    protected steps?: TaskStepSpecModel[];
-    protected stepResults?: TaskStepSpecModel[];
-    constructor(arg?: ModelArg<CompositeTaskBuilder>);
-    setAtomicity(value: TaskType): this;
-    setSteps(value: TaskStepSpecModel[]): this;
-    /**
-     * Backwards compatible:
-     * - addStep(classification, input?)
-     * - addStep(classification, name, input?)
-     *
-     * When called with only `classification`, returns a TaskStepSpecBuilder so
-     * callers can configure the step and then `.build()` back to this builder.
-     */
-    addStep(classification: string): TaskStepSpecBuilder;
-    addStep(classification: string, input: any): this;
-    addStep(classification: string, name: string, input?: any): this;
-}

package/lib/types/tasks/constants.d.ts

@@ -1,31 +0,0 @@
-import { TaskEngineConfig } from "./types";
-export declare enum TaskStatus {
-    PENDING = "pending",
-    SCHEDULED = "scheduled",
-    RUNNING = "running",
-    FAILED = "failed",
-    SUCCEEDED = "succeeded",
-    CANCELED = "canceled",
-    WAITING_RETRY = "waiting_retry"
-}
-export declare enum BackoffStrategy {
-    EXPONENTIAL = "exponential",
-    FIXED = "fixed"
-}
-export declare enum JitterStrategy {
-    NONE = "none",
-    FULL = "full"
-}
-export declare enum TaskEventType {
-    STATUS = "status",
-    UPDATE = "update",
-    LOG = "log",
-    PROGRESS = "progress",
-    ALL = "all"
-}
-export declare enum TaskType {
-    ATOMIC = "atomic",
-    COMPOSITE = "composite"
-}
-export declare const TasksKey = "tasks";
-export declare const DefaultTaskEngineConfig: TaskEngineConfig<any>;

package/lib/types/tasks/decorators.d.ts

@@ -1,4 +0,0 @@
-export type TaskMetadata = {
-    type: string;
-};
-export declare function task(key: string): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/types/tasks/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * @description Exports for the tasks module.
- * @summary This file exports all the necessary components for the tasks functionality, including models, builder, and more.
- * @module core/tasks
- */
-import "../overrides";
-export * from "./models";
-export * from "./builder";
-export * from "./CleanUpTask";
-export * from "./constants";
-export * from "./decorators";
-export * from "./logging";
-export * from "./TaskContext";
-export * from "./TaskEngine";
-export * from "./TaskEventBus";
-export * from "./TaskEventService";
-export * from "./TaskHandler";
-export * from "./TaskHandlerRegistry";
-export * from "./TaskService";
-export * from "./TaskTracker";
-export * from "./types";
-export * from "./utils";
-export * from "./TaskErrors";

package/lib/types/tasks/logging.d.ts

@@ -1,31 +0,0 @@
-import { AnyFunction, Logger, LoggingConfig, LogLevel, LogMeta, StringLike } from "@decaf-ts/logging";
-import { EventPipe, LogPipe, LogPipeOptions } from "./types";
-export declare class TaskLogger<LOG extends Logger> implements Logger {
-    protected logger: Logger;
-    protected bufferSize: number;
-    protected maxBufferSize: number;
-    protected pipe?: LogPipe | undefined;
-    protected history: [LogLevel, string, any][];
-    constructor(logger: Logger, bufferSize?: number, maxBufferSize?: number, pipe?: LogPipe | undefined);
-    push(level: LogLevel, string: string, meta?: any): void;
-    flush<PIPE extends LogPipe>(pipe?: PIPE): PIPE extends LogPipe ? Promise<[LogLevel, string, any][]> : [LogLevel, string, any][];
-    readonly root: string[];
-    benchmark(msg: StringLike): void;
-    clear(): this;
-    debug(msg: StringLike, meta?: LogMeta): void;
-    error(msg: StringLike | Error, e?: Error | LogMeta, meta?: LogMeta): void;
-    for(config: Partial<LoggingConfig>): this;
-    for(context: string | {
-        new (...args: any[]): any;
-    } | AnyFunction | object): this;
-    for(method: string | {
-        new (...args: any[]): any;
-    } | AnyFunction | object | Partial<LoggingConfig>, config?: Partial<LoggingConfig>, ...args: any[]): this;
-    info(msg: StringLike, meta?: LogMeta): void;
-    setConfig(config: Partial<LoggingConfig>): void;
-    silly(msg: StringLike, meta?: LogMeta): void;
-    trace(msg: StringLike, meta?: LogMeta): void;
-    verbose(msg: StringLike, verbosity?: number | LogMeta, meta?: LogMeta): void;
-    warn(msg: StringLike, meta?: LogMeta): void;
-}
-export declare function getLogPipe<LOG extends Logger>(log: LOG, opts?: LogPipeOptions): EventPipe;

package/lib/types/tasks/models/TaskBackoffModel.d.ts

@@ -1,9 +0,0 @@
-import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
-import { BackoffStrategy, JitterStrategy } from "../constants";
-export declare class TaskBackoffModel extends Model {
-    strategy: BackoffStrategy;
-    baseMs: number;
-    maxMs: number;
-    jitter?: JitterStrategy;
-    constructor(arg?: ModelArg<TaskBackoffModel>);
-}

package/lib/types/tasks/models/TaskErrorModel.d.ts

@@ -1,8 +0,0 @@
-import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
-export declare class TaskErrorModel extends Model {
-    message: string;
-    stack?: string;
-    code?: string;
-    details?: any;
-    constructor(arg?: ModelArg<TaskErrorModel>);
-}

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

@@ -1,11 +0,0 @@
-import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
-import { TaskEventType } from "../constants";
-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.ts

@@ -1,33 +0,0 @@
-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.ts

@@ -1,10 +0,0 @@
-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.ts

@@ -1,43 +0,0 @@
-import { Model, type ModelArg } from "@decaf-ts/decorator-validation";
-import { TaskStatus, TaskType } from "../constants";
-import { TaskErrorModel } from "./TaskErrorModel";
-import { TaskBackoffModel } from "./TaskBackoffModel";
-import { TaskStepSpecModel } from "./TaskStepSpecModel";
-import { TaskStepResultModel } from "./TaskStepResultModel";
-import { TaskLogEntryModel } from "./TaskLogEntryModel";
-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.ts

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

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

@@ -1,9 +0,0 @@
-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.ts

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

package/lib/types/tasks/types.d.ts

@@ -1,71 +0,0 @@
-import { TaskContext } from "./TaskContext";
-import { TaskLogger } from "./logging";
-import { LogLevel } from "@decaf-ts/logging";
-import { Adapter, ContextFlags } from "../persistence/index";
-import { ConfOf } from "../persistence/types";
-import { TaskEventBus } from "./TaskEventBus";
-import { TaskHandlerRegistry } from "./TaskHandlerRegistry";
-import { TaskEventModel } from "./models/TaskEventModel";
-import { TaskStatus } from "./constants";
-import { TaskErrorModel } from "./models/TaskErrorModel";
-import { TaskStepSpecModel } from "./models/TaskStepSpecModel";
-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.ts

@@ -1,5 +0,0 @@
-import { TaskErrorModel } from "./models/TaskErrorModel";
-import { TaskBackoffModel } from "./models/TaskBackoffModel";
-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.ts

@@ -1,37 +0,0 @@
-import { LoggedClass, Logger } from "@decaf-ts/logging";
-import { BulkCrudOperationKeys, Contextual, OperationKeys } from "@decaf-ts/db-decorators";
-import { Context } from "../persistence/Context";
-import { FlagsOf, LoggerOf } from "../persistence/types";
-import type { Constructor } from "@decaf-ts/decoration";
-import { PersistenceKeys } from "../persistence/index";
-import { PreparedStatementKeys } from "../query/index";
-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.ts

@@ -1,27 +0,0 @@
-import { Constructor } from "@decaf-ts/decoration";
-import type { ModelConstructor } from "@decaf-ts/decorator-validation";
-import { HttpVerbs } from "./types";
-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.ts

@@ -1,56 +0,0 @@
-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);
-}