@decaf-ts/core 0.28.0 → 0.29.0

package/lib/types/index.d.cts

@@ -24,21 +24,21 @@ export * from "./persistence/index.d.cts";
  * @const VERSION
  * @memberOf module:core
  */
-export declare const VERSION = "0.27.5";
+export declare const VERSION = "0.28.1";
 /**
  * @description Represents the current commit hash of the module build.
  * @summary Stores the current git commit hash for the package. The build replaces
  * the placeholder with the actual commit hash at publish time.
  * @const COMMIT
  */
-export declare const COMMIT = "63a97aa";
+export declare const COMMIT = "49b1386";
 /**
  * @description Represents the full version string of the module.
  * @summary Stores the semver version and commit hash for the package.
  * The build replaces the placeholder with the actual `<version>-<commit>` value at publish time.
  * @const FULL_VERSION
  */
-export declare const FULL_VERSION = "0.27.5-63a97aa";
+export declare const FULL_VERSION = "0.28.1-49b1386";
 /**
  * @description Stores the current package version
  * @summary A constant representing the version of the core package

package/lib/types/index.d.mts

@@ -24,21 +24,21 @@ export * from "./persistence/index.d.mts";
  * @const VERSION
  * @memberOf module:core
  */
-export declare const VERSION = "0.27.5";
+export declare const VERSION = "0.28.1";
 /**
  * @description Represents the current commit hash of the module build.
  * @summary Stores the current git commit hash for the package. The build replaces
  * the placeholder with the actual commit hash at publish time.
  * @const COMMIT
  */
-export declare const COMMIT = "63a97aa";
+export declare const COMMIT = "49b1386";
 /**
  * @description Represents the full version string of the module.
  * @summary Stores the semver version and commit hash for the package.
  * The build replaces the placeholder with the actual `<version>-<commit>` value at publish time.
  * @const FULL_VERSION
  */
-export declare const FULL_VERSION = "0.27.5-63a97aa";
+export declare const FULL_VERSION = "0.28.1-49b1386";
 /**
  * @description Stores the current package version
  * @summary A constant representing the version of the core package

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

@@ -1,7 +1,8 @@
 import { ConnectionForAdapter, Migration } from "./types.d.cts";
-import { AbsContextual, ContextualArgs } from "../utils/ContextualLoggedClass.d.cts";
+import { AbsContextual, ContextualArgs, ContextualizedArgs, MaybeContextualArg, MethodOrOperation } from "../utils/ContextualLoggedClass.d.cts";
 import { Adapter } from "../persistence/Adapter.d.cts";
-import { ContextOf } from "../persistence/types.d.cts";
+import { ContextOf, FlagsOf } from "../persistence/types.d.cts";
+import { Context } from "../persistence/Context.d.cts";
 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?;
@@ -16,4 +17,7 @@ export declare abstract class AbsMigration<A extends Adapter<any, any, any, any>
     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>;
+    protected logCtx<CONTEXT extends Context<any> = ContextOf<A>, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD): ContextualizedArgs<ContextOf<A>, ARGS, METHOD extends string ? true : false>;
+    protected logCtx<CONTEXT extends Context<any> = ContextOf<A>, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FlagsOf<ContextOf<A>>>): ContextualizedArgs<ContextOf<A>, ARGS, METHOD extends string ? true : false>;
+    protected logCtx<CONTEXT extends Context<any> = ContextOf<A>, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FlagsOf<ContextOf<any>>>): Promise<ContextualizedArgs<ContextOf<A>, ARGS, METHOD extends string ? true : false>>;
 }

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

@@ -1,7 +1,8 @@
 import { ConnectionForAdapter, Migration } from "./types.d.mts";
-import { AbsContextual, ContextualArgs } from "../utils/ContextualLoggedClass.d.mts";
+import { AbsContextual, ContextualArgs, ContextualizedArgs, MaybeContextualArg, MethodOrOperation } from "../utils/ContextualLoggedClass.d.mts";
 import { Adapter } from "../persistence/Adapter.d.mts";
-import { ContextOf } from "../persistence/types.d.mts";
+import { ContextOf, FlagsOf } from "../persistence/types.d.mts";
+import { Context } from "../persistence/Context.d.mts";
 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?;
@@ -16,4 +17,7 @@ export declare abstract class AbsMigration<A extends Adapter<any, any, any, any>
     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>;
+    protected logCtx<CONTEXT extends Context<any> = ContextOf<A>, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD): ContextualizedArgs<ContextOf<A>, ARGS, METHOD extends string ? true : false>;
+    protected logCtx<CONTEXT extends Context<any> = ContextOf<A>, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FlagsOf<ContextOf<A>>>): ContextualizedArgs<ContextOf<A>, ARGS, METHOD extends string ? true : false>;
+    protected logCtx<CONTEXT extends Context<any> = ContextOf<A>, ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FlagsOf<ContextOf<any>>>): Promise<ContextualizedArgs<ContextOf<A>, ARGS, METHOD extends string ? true : false>>;
 }

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

@@ -15,19 +15,25 @@ type VersionTask = {
     version: string;
     task: TaskModel;
 };
+type QueuedMigrationTask<A extends Adapter<any, any, any, any>> = {
+    id: string;
+    version: string;
+    adapter?: A;
+    setCurrentVersion?: MigrationConfig<boolean>["setCurrentVersion"];
+};
 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> {
+    private static defaultSingleton?;
     protected versioning: MigrationVersioning;
     protected allowedReferences: Set<string> | undefined;
-    protected queuedTaskChain: Array<{
-        id: string;
-        version: string;
-    }>;
+    protected queuedTaskChain: QueuedMigrationTask<A>[];
+    protected orchestrationConfig?: MigrationConfig<true>;
     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>[]>;
+    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>>;
+    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;
@@ -56,7 +62,9 @@ export declare class MigrationService<PERSIST extends boolean, A extends Adapter
     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>;
+    protected migrateNormallyWithConfig(cfg: MigrationConfig<boolean>, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
     migrateViaTasks(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    protected migrateViaTasksWithConfig(cfg: MigrationConfig<boolean>, ...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>;

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

@@ -15,19 +15,25 @@ type VersionTask = {
     version: string;
     task: TaskModel;
 };
+type QueuedMigrationTask<A extends Adapter<any, any, any, any>> = {
+    id: string;
+    version: string;
+    adapter?: A;
+    setCurrentVersion?: MigrationConfig<boolean>["setCurrentVersion"];
+};
 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> {
+    private static defaultSingleton?;
     protected versioning: MigrationVersioning;
     protected allowedReferences: Set<string> | undefined;
-    protected queuedTaskChain: Array<{
-        id: string;
-        version: string;
-    }>;
+    protected queuedTaskChain: QueuedMigrationTask<A>[];
+    protected orchestrationConfig?: MigrationConfig<true>;
     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>[]>;
+    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>>;
+    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;
@@ -56,7 +62,9 @@ export declare class MigrationService<PERSIST extends boolean, A extends Adapter
     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>;
+    protected migrateNormallyWithConfig(cfg: MigrationConfig<boolean>, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
     migrateViaTasks(qr?: any, adapter?: any, ...args: MaybeContextualArg<ContextOf<any>>): Promise<R>;
+    protected migrateViaTasksWithConfig(cfg: MigrationConfig<boolean>, ...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>;

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

@@ -28,6 +28,7 @@ export type AdapterMigrationHandlers<AD extends Adapter<any, any, any, any> = Ad
 export type PersistenceMigrationConfig<AD extends Adapter<any, any, any, any> = Adapter<any, any, any, any>> = {
     toVersion?: string;
     taskMode?: boolean;
+    includeGenericInTaskMode?: boolean;
     dryRun?: boolean;
     flavours?: string[];
     taskService?: TaskService<any>;

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

@@ -28,6 +28,7 @@ export type AdapterMigrationHandlers<AD extends Adapter<any, any, any, any> = Ad
 export type PersistenceMigrationConfig<AD extends Adapter<any, any, any, any> = Adapter<any, any, any, any>> = {
     toVersion?: string;
     taskMode?: boolean;
+    includeGenericInTaskMode?: boolean;
     dryRun?: boolean;
     flavours?: string[];
     taskService?: TaskService<any>;

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

@@ -6,6 +6,7 @@ import { TaskErrorModel } from "./models/TaskErrorModel.d.cts";
 import { TaskStatus } from "./constants.d.cts";
 import { TaskStateChangeRequest } from "./TaskStateChangeError.d.cts";
 import { TaskStepSpecModel } from "./models/TaskStepSpecModel.d.cts";
+import { Lock } from "@decaf-ts/transactional-decorators";
 export declare class TaskContext extends Context<TaskFlags> {
     get taskId(): string;
     get logger(): TaskLogger<any>;
@@ -16,6 +17,7 @@ export declare class TaskContext extends Context<TaskFlags> {
     get attempt(): number;
     get progress(): (data: any) => Promise<void>;
     get heartbeat(): () => Promise<void>;
+    get stepWriteLock(): Lock;
     cacheResult(taskId: string, payload: any): void;
     protected changeState(status: TaskStatus, payload?: Partial<TaskStateChangeRequest>): never;
     cancel(reason?: string | Error | TaskErrorModel, details?: any): never;

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

@@ -6,6 +6,7 @@ import { TaskErrorModel } from "./models/TaskErrorModel.d.mts";
 import { TaskStatus } from "./constants.d.mts";
 import { TaskStateChangeRequest } from "./TaskStateChangeError.d.mts";
 import { TaskStepSpecModel } from "./models/TaskStepSpecModel.d.mts";
+import { Lock } from "@decaf-ts/transactional-decorators";
 export declare class TaskContext extends Context<TaskFlags> {
     get taskId(): string;
     get logger(): TaskLogger<any>;
@@ -16,6 +17,7 @@ export declare class TaskContext extends Context<TaskFlags> {
     get attempt(): number;
     get progress(): (data: any) => Promise<void>;
     get heartbeat(): () => Promise<void>;
+    get stepWriteLock(): Lock;
     cacheResult(taskId: string, payload: any): void;
     protected changeState(status: TaskStatus, payload?: Partial<TaskStateChangeRequest>): never;
     cancel(reason?: string | Error | TaskErrorModel, details?: any): never;

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

@@ -79,6 +79,11 @@ export declare class TaskEngine<A extends Adapter<any, any, any, any>, C extends
     protected getStepLock(task: TaskModel, stepIndex: number | undefined): string | undefined;
     protected hasLockConflict(task: TaskModel, stepIndex: number | undefined, ctx: Context): Promise<boolean>;
     protected isRunnable(task: TaskModel, ctx: Context): Promise<boolean>;
+    protected getCompositeStepConcurrencyLimit(): number;
+    protected isConcurrentCompositeStep(step: TaskStepSpecModel): boolean;
+    protected createCompositeStepContext(context: TaskContext, stepIndex: number): TaskContext;
+    protected withStepWriteLock<T>(ctx: TaskContext, fn: () => Promise<T>): Promise<T>;
+    protected recalculateCompositeCurrentStep(steps: TaskStepSpecModel[], results: TaskStepResultModel[]): number;
     protected executeClaimed(task: TaskModel): Promise<void>;
     protected handleTaskStateChange(request: TaskStateChangeRequest, task: TaskModel, ctx: TaskContext): Promise<void>;
     protected runComposite(task: TaskModel, context: TaskContext): Promise<any>;

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

@@ -79,6 +79,11 @@ export declare class TaskEngine<A extends Adapter<any, any, any, any>, C extends
     protected getStepLock(task: TaskModel, stepIndex: number | undefined): string | undefined;
     protected hasLockConflict(task: TaskModel, stepIndex: number | undefined, ctx: Context): Promise<boolean>;
     protected isRunnable(task: TaskModel, ctx: Context): Promise<boolean>;
+    protected getCompositeStepConcurrencyLimit(): number;
+    protected isConcurrentCompositeStep(step: TaskStepSpecModel): boolean;
+    protected createCompositeStepContext(context: TaskContext, stepIndex: number): TaskContext;
+    protected withStepWriteLock<T>(ctx: TaskContext, fn: () => Promise<T>): Promise<T>;
+    protected recalculateCompositeCurrentStep(steps: TaskStepSpecModel[], results: TaskStepResultModel[]): number;
     protected executeClaimed(task: TaskModel): Promise<void>;
     protected handleTaskStateChange(request: TaskStateChangeRequest, task: TaskModel, ctx: TaskContext): Promise<void>;
     protected runComposite(task: TaskModel, context: TaskContext): Promise<any>;

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

@@ -45,6 +45,7 @@ export declare class TaskStepSpecBuilder {
     setName(value?: string): this;
     setInput(value: any): this;
     setLock(value?: string): this;
+    setAllowConcurrent(value?: boolean): this;
     setDependsOn(value?: string[]): this;
     setCanFail(value: boolean): this;
     setMaxAttempts(value?: number): this;

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

@@ -45,6 +45,7 @@ export declare class TaskStepSpecBuilder {
     setName(value?: string): this;
     setInput(value: any): this;
     setLock(value?: string): this;
+    setAllowConcurrent(value?: boolean): this;
     setDependsOn(value?: string[]): this;
     setCanFail(value: boolean): this;
     setMaxAttempts(value?: number): this;

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

@@ -5,6 +5,7 @@ export declare class TaskStepSpecModel extends Model {
     name?: string;
     input?: any;
     lock?: string;
+    allowConcurrent: boolean;
     dependsOn?: string[];
     canFail: boolean;
     maxAttempts?: number;

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

@@ -5,6 +5,7 @@ export declare class TaskStepSpecModel extends Model {
     name?: string;
     input?: any;
     lock?: string;
+    allowConcurrent: boolean;
     dependsOn?: string[];
     canFail: boolean;
     maxAttempts?: number;

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

@@ -9,6 +9,7 @@ import { TaskEventModel } from "./models/TaskEventModel.d.cts";
 import { TaskStatus } from "./constants.d.cts";
 import { TaskErrorModel } from "./models/TaskErrorModel.d.cts";
 import { TaskStepSpecModel } from "./models/TaskStepSpecModel.d.cts";
+import { Lock } from "@decaf-ts/transactional-decorators";
 export interface ITaskHandler<I = any, O = any> {
     type: string;
     run(input: I, ctx: TaskContext): Promise<O>;
@@ -31,6 +32,8 @@ export interface LogPipe {
 export interface TaskFlags<LOG extends TaskLogger<any> = TaskLogger<any>> extends ContextFlags<LOG> {
     taskId: string;
     attempt: number;
+    step?: number;
+    stepWriteLock?: Lock;
     pipe: LogPipe;
     flush: () => Promise<void>;
     progress: (data: any) => Promise<void>;
@@ -47,6 +50,7 @@ export type TaskEngineConfig<A extends Adapter<any, any, any, any>> = {
     registry?: TaskHandlerRegistry;
     workerId: string;
     concurrency: number;
+    maxConcurrentCompositeSteps?: number;
     leaseMs: number;
     pollMsIdle: number;
     pollMsBusy: number;

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

@@ -9,6 +9,7 @@ import { TaskEventModel } from "./models/TaskEventModel.d.mts";
 import { TaskStatus } from "./constants.d.mts";
 import { TaskErrorModel } from "./models/TaskErrorModel.d.mts";
 import { TaskStepSpecModel } from "./models/TaskStepSpecModel.d.mts";
+import { Lock } from "@decaf-ts/transactional-decorators";
 export interface ITaskHandler<I = any, O = any> {
     type: string;
     run(input: I, ctx: TaskContext): Promise<O>;
@@ -31,6 +32,8 @@ export interface LogPipe {
 export interface TaskFlags<LOG extends TaskLogger<any> = TaskLogger<any>> extends ContextFlags<LOG> {
     taskId: string;
     attempt: number;
+    step?: number;
+    stepWriteLock?: Lock;
     pipe: LogPipe;
     flush: () => Promise<void>;
     progress: (data: any) => Promise<void>;
@@ -47,6 +50,7 @@ export type TaskEngineConfig<A extends Adapter<any, any, any, any>> = {
     registry?: TaskHandlerRegistry;
     workerId: string;
     concurrency: number;
+    maxConcurrentCompositeSteps?: number;
     leaseMs: number;
     pollMsIdle: number;
     pollMsBusy: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/core",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Core persistence module for the decaf framework",
   "type": "module",
   "exports": {