@decaf-ts/core 0.17.0 → 0.19.0

package/lib/types/interfaces/RawExecutor.d.mts

@@ -0,0 +1,28 @@
+import { RawResult } from "../persistence/types.js";
+/**
+ * @description Interface for executing raw queries
+ * @summary Defines a contract for objects that can execute raw queries of a specific type and return results
+ * @template Q - The query type that this executor can process
+ * @interface RawExecutor
+ * @memberOf module:core
+ */
+export interface RawExecutor<Q> {
+    /**
+     * @description Executes a raw query
+     * @summary Processes a raw query input and returns a promise that resolves to the result
+     * @template R - The result type that will be returned
+     * @param {Q} rawInput - The raw query to execute
+     * @return {Promise<R>} A promise that resolves to the result of type R
+     */
+    raw<R>(rawInput: Q, ...args: any[]): Promise<R>;
+}
+export interface RawPagedExecutor<Q> {
+    /**
+     * @description Executes a raw query
+     * @summary Processes a raw query input and returns a promise that resolves to the result
+     * @template R - The result type that will be returned
+     * @param {Q} rawInput - The raw query to execute
+     * @return {Promise<R>} A promise that resolves to the result of type R
+     */
+    raw<R, D extends boolean>(rawInput: Q, docsOnly: D, ...args: any[]): Promise<RawResult<R, D>>;
+}

package/lib/types/interfaces/SequenceOptions.d.cts

@@ -0,0 +1,79 @@
+/**
+ * @description Type of the sequence configuration options type property
+ * @summary Type of the sequence configuration options type property
+ * @interface SequenceOptionsType
+ * @memberOf module:core
+ */
+export type SequenceOptionsType = "Number" | "BigInt" | "String" | string | "serial" | "uuid" | StringConstructor | NumberConstructor | BigIntConstructor | undefined;
+/**
+ * @description Interface for sequence configuration options
+ * @summary Defines the configuration options for creating and managing sequences
+ * @interface SequenceOptions
+ * @memberOf module:core
+ */
+export interface SequenceOptions<TYPE = SequenceOptionsType> {
+    /**
+     * @description Optional name for the sequence
+     * @summary A unique identifier for the sequence
+     */
+    name?: string;
+    generated?: boolean;
+    /**
+     * @description The data type of the sequence
+     * @summary Specifies whether the sequence generates Number or BigInt values
+     */
+    type: TYPE;
+    /**
+     * @description The initial value of the sequence
+     * @summary The value that the sequence starts with
+     */
+    startWith: number;
+    /**
+    * @description The increment value for each step in the sequence
+    * @summary The amount by which the sequence increases with each call
+    */
+    incrementBy: number;
+    /**
+     * @description Optional minimum value for the sequence
+     * @summary The lowest value that the sequence can generate
+     */
+    minValue?: number;
+    /**
+     * @description Optional maximum value for the sequence
+     * @summary The highest value that the sequence can generate
+     */
+    maxValue?: number;
+    /**
+     * @description Whether the sequence should cycle when reaching its limits
+     * @summary If true, the sequence will restart from minValue when reaching maxValue
+     */
+    cycle: boolean;
+}
+/**
+ * @description Default options for sequences
+ * @summary Provides a standard configuration for number sequences starting at 0 and incrementing by 1
+ * @const NoneSequenceOptions
+ * @memberOf module:core
+ */
+export declare const NoneSequenceOptions: SequenceOptions;
+/**
+ * @description Default options for sequences
+ * @summary Provides a standard configuration for number sequences starting at 0 and incrementing by 1
+ * @const DefaultSequenceOptions
+ * @memberOf module:core
+ */
+export declare const DefaultSequenceOptions: SequenceOptions;
+/**
+ * @description Predefined options for numeric sequences
+ * @summary Configuration for standard number sequences starting at 0 and incrementing by 1
+ * @const NumericSequence
+ * @memberOf module:core
+ */
+export declare const NumericSequence: SequenceOptions;
+/**
+ * @description Predefined options for BigInt sequences
+ * @summary Configuration for BigInt sequences starting at 0 and incrementing by 1
+ * @const BigIntSequence
+ * @memberOf module:core
+ */
+export declare const BigIntSequence: SequenceOptions;

package/lib/types/interfaces/SequenceOptions.d.mts

@@ -0,0 +1,79 @@
+/**
+ * @description Type of the sequence configuration options type property
+ * @summary Type of the sequence configuration options type property
+ * @interface SequenceOptionsType
+ * @memberOf module:core
+ */
+export type SequenceOptionsType = "Number" | "BigInt" | "String" | string | "serial" | "uuid" | StringConstructor | NumberConstructor | BigIntConstructor | undefined;
+/**
+ * @description Interface for sequence configuration options
+ * @summary Defines the configuration options for creating and managing sequences
+ * @interface SequenceOptions
+ * @memberOf module:core
+ */
+export interface SequenceOptions<TYPE = SequenceOptionsType> {
+    /**
+     * @description Optional name for the sequence
+     * @summary A unique identifier for the sequence
+     */
+    name?: string;
+    generated?: boolean;
+    /**
+     * @description The data type of the sequence
+     * @summary Specifies whether the sequence generates Number or BigInt values
+     */
+    type: TYPE;
+    /**
+     * @description The initial value of the sequence
+     * @summary The value that the sequence starts with
+     */
+    startWith: number;
+    /**
+    * @description The increment value for each step in the sequence
+    * @summary The amount by which the sequence increases with each call
+    */
+    incrementBy: number;
+    /**
+     * @description Optional minimum value for the sequence
+     * @summary The lowest value that the sequence can generate
+     */
+    minValue?: number;
+    /**
+     * @description Optional maximum value for the sequence
+     * @summary The highest value that the sequence can generate
+     */
+    maxValue?: number;
+    /**
+     * @description Whether the sequence should cycle when reaching its limits
+     * @summary If true, the sequence will restart from minValue when reaching maxValue
+     */
+    cycle: boolean;
+}
+/**
+ * @description Default options for sequences
+ * @summary Provides a standard configuration for number sequences starting at 0 and incrementing by 1
+ * @const NoneSequenceOptions
+ * @memberOf module:core
+ */
+export declare const NoneSequenceOptions: SequenceOptions;
+/**
+ * @description Default options for sequences
+ * @summary Provides a standard configuration for number sequences starting at 0 and incrementing by 1
+ * @const DefaultSequenceOptions
+ * @memberOf module:core
+ */
+export declare const DefaultSequenceOptions: SequenceOptions;
+/**
+ * @description Predefined options for numeric sequences
+ * @summary Configuration for standard number sequences starting at 0 and incrementing by 1
+ * @const NumericSequence
+ * @memberOf module:core
+ */
+export declare const NumericSequence: SequenceOptions;
+/**
+ * @description Predefined options for BigInt sequences
+ * @summary Configuration for BigInt sequences starting at 0 and incrementing by 1
+ * @const BigIntSequence
+ * @memberOf module:core
+ */
+export declare const BigIntSequence: SequenceOptions;

package/lib/types/interfaces/index.d.cts

@@ -0,0 +1,12 @@
+/**
+ * @description Exports for the interfaces module.
+ * @summary This file exports all the necessary components for the interfaces functionality, including ErrorParser, Executor, and more.
+ * @module core/interfaces
+ */
+export * from "./ErrorParser.cjs";
+export * from "./Executor.cjs";
+export * from "./Observable.cjs";
+export * from "./Observer.cjs";
+export * from "./Queriable.cjs";
+export * from "./RawExecutor.cjs";
+export * from "./SequenceOptions.cjs";

package/lib/types/interfaces/index.d.mts

@@ -0,0 +1,12 @@
+/**
+ * @description Exports for the interfaces module.
+ * @summary This file exports all the necessary components for the interfaces functionality, including ErrorParser, Executor, and more.
+ * @module core/interfaces
+ */
+export * from "./ErrorParser.js";
+export * from "./Executor.js";
+export * from "./Observable.js";
+export * from "./Observer.js";
+export * from "./Queriable.js";
+export * from "./RawExecutor.js";
+export * from "./SequenceOptions.js";

package/lib/types/migrations/Migration.d.cts

@@ -0,0 +1,19 @@
+import { ConnectionForAdapter, Migration } from "./types.cjs";
+import { AbsContextual, ContextualArgs } from "../utils/ContextualLoggedClass.cjs";
+import { Adapter } from "../persistence/Adapter.cjs";
+import { ContextOf } from "../persistence/types.cjs";
+export declare abstract class AbsMigration<A extends Adapter<any, any, any, any>, R = void> extends AbsContextual<ContextOf<A>> implements Migration<A, R> {
+    private _reference?;
+    private _precedence?;
+    transaction: boolean;
+    get reference(): string;
+    get precedence(): string | Migration<any, any>;
+    protected constructor();
+    protected get adapter(): A;
+    protected abstract getQueryRunner(conn: ConnectionForAdapter<A>): ConnectionForAdapter<A>;
+    private enforceRules;
+    private prefix;
+    abstract down(qr: ConnectionForAdapter<A>, adapter: A, ...args: ContextualArgs<ContextOf<A>>): Promise<void>;
+    abstract migrate(qr: ConnectionForAdapter<A>, adapter: A, ...args: ContextualArgs<ContextOf<A>>): Promise<R>;
+    abstract up(qr: ConnectionForAdapter<A>, adapter: A, ctx: ContextOf<A>): Promise<void>;
+}

package/lib/types/migrations/Migration.d.mts

@@ -0,0 +1,19 @@
+import { ConnectionForAdapter, Migration } from "./types.js";
+import { AbsContextual, ContextualArgs } from "../utils/ContextualLoggedClass.js";
+import { Adapter } from "../persistence/Adapter.js";
+import { ContextOf } from "../persistence/types.js";
+export declare abstract class AbsMigration<A extends Adapter<any, any, any, any>, R = void> extends AbsContextual<ContextOf<A>> implements Migration<A, R> {
+    private _reference?;
+    private _precedence?;
+    transaction: boolean;
+    get reference(): string;
+    get precedence(): string | Migration<any, any>;
+    protected constructor();
+    protected get adapter(): A;
+    protected abstract getQueryRunner(conn: ConnectionForAdapter<A>): ConnectionForAdapter<A>;
+    private enforceRules;
+    private prefix;
+    abstract down(qr: ConnectionForAdapter<A>, adapter: A, ...args: ContextualArgs<ContextOf<A>>): Promise<void>;
+    abstract migrate(qr: ConnectionForAdapter<A>, adapter: A, ...args: ContextualArgs<ContextOf<A>>): Promise<R>;
+    abstract up(qr: ConnectionForAdapter<A>, adapter: A, ctx: ContextOf<A>): Promise<void>;
+}

package/lib/types/migrations/MigrationService.d.cts

@@ -0,0 +1,63 @@
+import { Migration, MigrationConfig, PersistenceMigrationConfig } from "./types.cjs";
+import { ClientBasedService } from "../services/services.cjs";
+import { Adapter } from "../persistence/Adapter.cjs";
+import { ContextOf } from "../persistence/types.cjs";
+import { ContextualArgs, MaybeContextualArg } from "../utils/ContextualLoggedClass.cjs";
+import { TaskModel } from "../tasks/models/TaskModel.cjs";
+import { MigrationVersioning } from "./MigrationVersioning.cjs";
+type ResolvedMigration = {
+    migration: Migration<any, any>;
+    flavour: string;
+    reference: string;
+    version: string;
+};
+type VersionTask = {
+    version: string;
+    task: TaskModel;
+};
+export declare class MigrationService<PERSIST extends boolean, A extends Adapter<any, any, any, any> = any, R = void> extends ClientBasedService<PERSIST extends boolean ? A : void, MigrationConfig<PERSIST>> implements Migration<A, R> {
+    protected versioning: MigrationVersioning;
+    protected queuedTaskChain: Array<{
+        id: string;
+        version: string;
+    }>;
+    flavour?: string;
+    readonly reference: string;
+    readonly precedence: Migration<any, any> | Migration<any, any>[] | null;
+    transaction: boolean;
+    constructor();
+    static migrateAdapters<AD extends Adapter<any, any, any, any> = Adapter<any, any, any, any>>(adapters: AD[], cfg?: PersistenceMigrationConfig<AD>, ...args: MaybeContextualArg<ContextOf<AD>>): Promise<MigrationService<true, AD>[]>;
+    initialize(...args: MaybeContextualArg<ContextOf<A>>): Promise<{
+        config: MigrationConfig<PERSIST>;
+        client: PERSIST extends boolean ? A : void;
+    }>;
+    down(qr: any, adapter: any, ...args: ContextualArgs<ContextOf<any>>): Promise<void>;
+    protected normalizeVersion(raw: string, precedenceHint?: string): string;
+    protected extractPrecedenceTokens(migration: Migration<any, any>): string[];
+    protected referencesMigration(candidate: Migration<any, any>, target: ResolvedMigration): boolean;
+    protected precedenceHint(migration: Migration<any, any>): string | undefined;
+    protected compareByPrecedence(migration1: ResolvedMigration, migration2: ResolvedMigration): number;
+    protected sort(migrations: ResolvedMigration[]): ResolvedMigration[];
+    protected resolveMigration(migration: Migration<any, any>): ResolvedMigration;
+    protected shouldIncludeMigration(migration: ResolvedMigration, targetFlavour?: string, includeGeneric?: boolean): boolean;
+    protected collectMigrations(targetFlavour?: string, includeGeneric?: boolean): ResolvedMigration[];
+    protected buildExecutionPlan(options?: {
+        fromVersion?: string;
+        toVersion?: string;
+        targetFlavour?: string;
+        includeGeneric?: boolean;
+    }): ResolvedMigration[];
+    protected executeMigration(migration: ResolvedMigration, ...args: ContextualArgs<ContextOf<any>>): Promise<void>;
+    protected buildMigrationTaskForPlan(plan: ResolvedMigration[], ...args: ContextualArgs<ContextOf<any>>): TaskModel;
+    protected buildMigrationTasksForPlan(plan: ResolvedMigration[], ...args: ContextualArgs<ContextOf<any>>): VersionTask[];
+    createMigrationTask(targetVersion?: string, fromVersion?: string, ...args: ContextualArgs<ContextOf<any>>): TaskModel;
+    createMigrationTasks(targetVersion?: string, fromVersion?: string, ...args: ContextualArgs<ContextOf<any>>): VersionTask[];
+    protected migrationTaskIdsFromContext(taskKey: string, args: ContextualArgs<ContextOf<any>>): string[];
+    migrate(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    migrateNormally(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    migrateViaTasks(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    track(taskIds?: string[] | string, ...args: MaybeContextualArg<ContextOf<any>>): Promise<void>;
+    retry(taskIds?: string[] | string, ...args: MaybeContextualArg<ContextOf<any>>): Promise<void>;
+    up(qr: any, adapter: any, ...args: ContextualArgs<ContextOf<any>>): Promise<void>;
+}
+export {};

package/lib/types/migrations/MigrationService.d.mts

@@ -0,0 +1,63 @@
+import { Migration, MigrationConfig, PersistenceMigrationConfig } from "./types.js";
+import { ClientBasedService } from "../services/services.js";
+import { Adapter } from "../persistence/Adapter.js";
+import { ContextOf } from "../persistence/types.js";
+import { ContextualArgs, MaybeContextualArg } from "../utils/ContextualLoggedClass.js";
+import { TaskModel } from "../tasks/models/TaskModel.js";
+import { MigrationVersioning } from "./MigrationVersioning.js";
+type ResolvedMigration = {
+    migration: Migration<any, any>;
+    flavour: string;
+    reference: string;
+    version: string;
+};
+type VersionTask = {
+    version: string;
+    task: TaskModel;
+};
+export declare class MigrationService<PERSIST extends boolean, A extends Adapter<any, any, any, any> = any, R = void> extends ClientBasedService<PERSIST extends boolean ? A : void, MigrationConfig<PERSIST>> implements Migration<A, R> {
+    protected versioning: MigrationVersioning;
+    protected queuedTaskChain: Array<{
+        id: string;
+        version: string;
+    }>;
+    flavour?: string;
+    readonly reference: string;
+    readonly precedence: Migration<any, any> | Migration<any, any>[] | null;
+    transaction: boolean;
+    constructor();
+    static migrateAdapters<AD extends Adapter<any, any, any, any> = Adapter<any, any, any, any>>(adapters: AD[], cfg?: PersistenceMigrationConfig<AD>, ...args: MaybeContextualArg<ContextOf<AD>>): Promise<MigrationService<true, AD>[]>;
+    initialize(...args: MaybeContextualArg<ContextOf<A>>): Promise<{
+        config: MigrationConfig<PERSIST>;
+        client: PERSIST extends boolean ? A : void;
+    }>;
+    down(qr: any, adapter: any, ...args: ContextualArgs<ContextOf<any>>): Promise<void>;
+    protected normalizeVersion(raw: string, precedenceHint?: string): string;
+    protected extractPrecedenceTokens(migration: Migration<any, any>): string[];
+    protected referencesMigration(candidate: Migration<any, any>, target: ResolvedMigration): boolean;
+    protected precedenceHint(migration: Migration<any, any>): string | undefined;
+    protected compareByPrecedence(migration1: ResolvedMigration, migration2: ResolvedMigration): number;
+    protected sort(migrations: ResolvedMigration[]): ResolvedMigration[];
+    protected resolveMigration(migration: Migration<any, any>): ResolvedMigration;
+    protected shouldIncludeMigration(migration: ResolvedMigration, targetFlavour?: string, includeGeneric?: boolean): boolean;
+    protected collectMigrations(targetFlavour?: string, includeGeneric?: boolean): ResolvedMigration[];
+    protected buildExecutionPlan(options?: {
+        fromVersion?: string;
+        toVersion?: string;
+        targetFlavour?: string;
+        includeGeneric?: boolean;
+    }): ResolvedMigration[];
+    protected executeMigration(migration: ResolvedMigration, ...args: ContextualArgs<ContextOf<any>>): Promise<void>;
+    protected buildMigrationTaskForPlan(plan: ResolvedMigration[], ...args: ContextualArgs<ContextOf<any>>): TaskModel;
+    protected buildMigrationTasksForPlan(plan: ResolvedMigration[], ...args: ContextualArgs<ContextOf<any>>): VersionTask[];
+    createMigrationTask(targetVersion?: string, fromVersion?: string, ...args: ContextualArgs<ContextOf<any>>): TaskModel;
+    createMigrationTasks(targetVersion?: string, fromVersion?: string, ...args: ContextualArgs<ContextOf<any>>): VersionTask[];
+    protected migrationTaskIdsFromContext(taskKey: string, args: ContextualArgs<ContextOf<any>>): string[];
+    migrate(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    migrateNormally(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    migrateViaTasks(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    track(taskIds?: string[] | string, ...args: MaybeContextualArg<ContextOf<any>>): Promise<void>;
+    retry(taskIds?: string[] | string, ...args: MaybeContextualArg<ContextOf<any>>): Promise<void>;
+    up(qr: any, adapter: any, ...args: ContextualArgs<ContextOf<any>>): Promise<void>;
+}
+export {};

package/lib/types/migrations/MigrationTaskBuilder.d.cts

@@ -0,0 +1,10 @@
+import { CompositeTaskBuilder } from "../tasks/builder.cjs";
+import { TaskModel } from "../tasks/models/TaskModel.cjs";
+import { MigrationStepInput } from "./MigrationTasks.cjs";
+export declare class MigrationTaskBuilder {
+    protected readonly builder: CompositeTaskBuilder;
+    constructor(name?: string);
+    addMigrationStep(step: MigrationStepInput): this;
+    addStep(classification: string, input?: any): this;
+    build(): TaskModel;
+}

package/lib/types/migrations/MigrationTaskBuilder.d.mts

@@ -0,0 +1,10 @@
+import { CompositeTaskBuilder } from "../tasks/builder.js";
+import { TaskModel } from "../tasks/models/TaskModel.js";
+import { MigrationStepInput } from "./MigrationTasks.js";
+export declare class MigrationTaskBuilder {
+    protected readonly builder: CompositeTaskBuilder;
+    constructor(name?: string);
+    addMigrationStep(step: MigrationStepInput): this;
+    addStep(classification: string, input?: any): this;
+    build(): TaskModel;
+}

package/lib/types/migrations/MigrationTasks.d.cts

@@ -0,0 +1,9 @@
+import { TaskHandler } from "../tasks/TaskHandler.cjs";
+import { TaskContext } from "../tasks/TaskContext.cjs";
+export interface MigrationStepInput {
+    reference: string;
+    args?: any[];
+}
+export declare class MigrationTask extends TaskHandler<MigrationStepInput, void> {
+    run(input: MigrationStepInput, ctx: TaskContext): Promise<void>;
+}

package/lib/types/migrations/MigrationTasks.d.mts

@@ -0,0 +1,9 @@
+import { TaskHandler } from "../tasks/TaskHandler.js";
+import { TaskContext } from "../tasks/TaskContext.js";
+export interface MigrationStepInput {
+    reference: string;
+    args?: any[];
+}
+export declare class MigrationTask extends TaskHandler<MigrationStepInput, void> {
+    run(input: MigrationStepInput, ctx: TaskContext): Promise<void>;
+}

package/lib/types/migrations/MigrationVersioning.d.cts

@@ -0,0 +1,7 @@
+export interface MigrationVersioning {
+    isVersionHint(value: string): boolean;
+    normalize(reference: string, precedenceHint?: string): string;
+    compare(a: string, b: string): number;
+    gt(a: string, b: string): boolean;
+    lte(a: string, b: string): boolean;
+}

package/lib/types/migrations/MigrationVersioning.d.mts

@@ -0,0 +1,7 @@
+export interface MigrationVersioning {
+    isVersionHint(value: string): boolean;
+    normalize(reference: string, precedenceHint?: string): string;
+    compare(a: string, b: string): number;
+    gt(a: string, b: string): boolean;
+    lte(a: string, b: string): boolean;
+}

package/lib/types/migrations/SemverMigrationVersioning.d.cts

@@ -0,0 +1,10 @@
+import { MigrationVersioning } from "./MigrationVersioning.cjs";
+export declare class SemverMigrationVersioning implements MigrationVersioning {
+    private coerce;
+    private slug;
+    isVersionHint(value: string): boolean;
+    normalize(reference: string, precedenceHint?: string): string;
+    compare(a: string, b: string): number;
+    gt(a: string, b: string): boolean;
+    lte(a: string, b: string): boolean;
+}

package/lib/types/migrations/SemverMigrationVersioning.d.mts

@@ -0,0 +1,10 @@
+import { MigrationVersioning } from "./MigrationVersioning.js";
+export declare class SemverMigrationVersioning implements MigrationVersioning {
+    private coerce;
+    private slug;
+    isVersionHint(value: string): boolean;
+    normalize(reference: string, precedenceHint?: string): string;
+    compare(a: string, b: string): number;
+    gt(a: string, b: string): boolean;
+    lte(a: string, b: string): boolean;
+}

package/lib/types/migrations/StandardMigrationVersioning.d.cts

@@ -0,0 +1,12 @@
+import { MigrationVersioning } from "./MigrationVersioning.cjs";
+/**
+ * Legacy non-semver migration ordering strategy.
+ * Keeps references as-is and compares using lexical order.
+ */
+export declare class StandardMigrationVersioning implements MigrationVersioning {
+    isVersionHint(value: string): boolean;
+    normalize(reference: string, precedenceHint?: string): string;
+    compare(a: string, b: string): number;
+    gt(a: string, b: string): boolean;
+    lte(a: string, b: string): boolean;
+}

package/lib/types/migrations/StandardMigrationVersioning.d.mts

@@ -0,0 +1,12 @@
+import { MigrationVersioning } from "./MigrationVersioning.js";
+/**
+ * Legacy non-semver migration ordering strategy.
+ * Keeps references as-is and compares using lexical order.
+ */
+export declare class StandardMigrationVersioning implements MigrationVersioning {
+    isVersionHint(value: string): boolean;
+    normalize(reference: string, precedenceHint?: string): string;
+    compare(a: string, b: string): number;
+    gt(a: string, b: string): boolean;
+    lte(a: string, b: string): boolean;
+}

package/lib/types/migrations/constants.d.cts

@@ -0,0 +1,2 @@
+import { MigrationConfig } from "./types.cjs";
+export declare const DefaultMigrationConfig: MigrationConfig<true>;

package/lib/types/migrations/constants.d.mts

@@ -0,0 +1,2 @@
+import { MigrationConfig } from "./types.js";
+export declare const DefaultMigrationConfig: MigrationConfig<true>;

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

@@ -0,0 +1,12 @@
+import { Constructor } from "@decaf-ts/decoration";
+import { Migration, MigrationRule } from "./types.cjs";
+export declare function migration(reference: string): (target: object) => any;
+export declare function migration(reference: string, precedence: Constructor<Migration<any, any>> | null): (target: object) => any;
+export declare function migration(reference: string, flavour: string, rules?: MigrationRule[]): (target: object) => any;
+export declare function migration(reference: string, precedence: Constructor<Migration<any, any>>, flavour: string): (target: object) => any;
+export declare function migration(reference: string, precedence?: Constructor<Migration<any, any>> | string | null, flavour?: string | MigrationRule[], rules?: MigrationRule[]): (target: object) => any;
+export declare function migration(reference: string, opts?: {
+    precedence?: Constructor<Migration<any, any>> | string | null;
+    flavour?: string;
+    rules?: MigrationRule[];
+}): (target: object) => any;

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

@@ -0,0 +1,12 @@
+import { Constructor } from "@decaf-ts/decoration";
+import { Migration, MigrationRule } from "./types.js";
+export declare function migration(reference: string): (target: object) => any;
+export declare function migration(reference: string, precedence: Constructor<Migration<any, any>> | null): (target: object) => any;
+export declare function migration(reference: string, flavour: string, rules?: MigrationRule[]): (target: object) => any;
+export declare function migration(reference: string, precedence: Constructor<Migration<any, any>>, flavour: string): (target: object) => any;
+export declare function migration(reference: string, precedence?: Constructor<Migration<any, any>> | string | null, flavour?: string | MigrationRule[], rules?: MigrationRule[]): (target: object) => any;
+export declare function migration(reference: string, opts?: {
+    precedence?: Constructor<Migration<any, any>> | string | null;
+    flavour?: string;
+    rules?: MigrationRule[];
+}): (target: object) => any;

package/lib/types/migrations/index.d.cts

@@ -0,0 +1,15 @@
+/**
+ * @description Exports for the migrations module.
+ * @summary This file exports all the necessary components for the migrations functionality, including constants, decorators, and more.
+ * @module core/migrations
+ */
+import "../overrides";
+export * from "./constants.cjs";
+export * from "./decorators.cjs";
+export * from "./Migration.cjs";
+export * from "./MigrationService.cjs";
+export * from "./MigrationTaskBuilder.cjs";
+export * from "./MigrationTasks.cjs";
+export * from "./StandardMigrationVersioning.cjs";
+export * from "./MigrationVersioning.cjs";
+export * from "./types.cjs";

package/lib/types/migrations/index.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @description Exports for the migrations module.
+ * @summary This file exports all the necessary components for the migrations functionality, including constants, decorators, and more.
+ * @module core/migrations
+ */
+import "../overrides";
+export * from "./constants.js";
+export * from "./decorators.js";
+export * from "./Migration.js";
+export * from "./MigrationService.js";
+export * from "./MigrationTaskBuilder.js";
+export * from "./MigrationTasks.js";
+export * from "./StandardMigrationVersioning.js";
+export * from "./MigrationVersioning.js";
+export * from "./types.js";

package/lib/types/migrations/types.d.cts

@@ -0,0 +1,46 @@
+import { Adapter } from "../persistence/Adapter.cjs";
+import { AdapterFlags, ContextOf } from "../persistence/types.cjs";
+import { ContextualArgs } from "../utils/ContextualLoggedClass.cjs";
+import { TaskService } from "../tasks/TaskService.cjs";
+import type { MigrationVersioning } from "./MigrationVersioning.cjs";
+export interface Migration<A extends Adapter<any, any, any, any>, R = void> {
+    flavour?: string;
+    precedence: Migration<any, any> | Migration<any, any>[] | string | null;
+    reference: string;
+    transaction: boolean;
+    up(qr: ConnectionForAdapter<A>, adapter: A, ...args: ContextualArgs<ContextOf<A>>): Promise<void>;
+    migrate(qr: ConnectionForAdapter<A>, adapter: A, ...args: ContextualArgs<ContextOf<A>>): Promise<R>;
+    down(qr: ConnectionForAdapter<A>, adapter: A, ...args: ContextualArgs<ContextOf<A>>): Promise<void>;
+}
+export type ConnectionForAdapter<A extends Adapter<any, any, any, any>> = A extends Adapter<any, any, infer CONN, any> ? CONN : never;
+export type MigrationRule<A extends Adapter<any, any, any, any> = any, QUERYRUNNER = ConnectionForAdapter<A>> = (qr: QUERYRUNNER, adapter: A, ctx: ContextOf<A>) => Promise<boolean>;
+export type MigrationMetadata = {
+    precedence?: Migration<any, any> | string;
+    flavour: string;
+    rules?: MigrationRule[];
+};
+export type RetrieveLastVersionHandler<A extends Adapter<any, any, any, any> = Adapter<any, any, any, any>> = (adapter: A, ...args: ContextualArgs<ContextOf<A>>) => Promise<string | undefined | null>;
+export type SetCurrentVersionHandler<A extends Adapter<any, any, any, any> = Adapter<any, any, any, any>> = (version: string, adapter: A, ...args: ContextualArgs<ContextOf<A>>) => Promise<void>;
+export type AdapterMigrationHandlers<AD extends Adapter<any, any, any, any> = Adapter<any, any, any, any>> = {
+    retrieveLastVersion?: RetrieveLastVersionHandler<AD>;
+    setCurrentVersion?: SetCurrentVersionHandler<AD>;
+};
+export type PersistenceMigrationConfig<AD extends Adapter<any, any, any, any> = Adapter<any, any, any, any>> = {
+    toVersion?: string;
+    taskMode?: boolean;
+    dryRun?: boolean;
+    flavours?: string[];
+    taskService?: TaskService<any>;
+    handlers?: Partial<Record<string, AdapterMigrationHandlers<AD>>>;
+};
+export type MigrationConfig<PERSIST extends boolean> = AdapterFlags<any> & {
+    persistMigrationSteps: PERSIST;
+    persistenceFlavour?: string;
+    targetVersion?: string;
+    taskMode?: boolean;
+    includeGenericInTaskMode?: boolean;
+    retrieveLastVersion?: RetrieveLastVersionHandler;
+    setCurrentVersion?: SetCurrentVersionHandler;
+    taskService?: TaskService<any>;
+    versioning?: MigrationVersioning;
+};