@punks/backend-entity-manager 0.0.324 → 0.0.326

package/dist/cjs/types/platforms/nest/pipelines/template/utils.d.ts

@@ -1,9 +1,9 @@
 import { PipelineCompletedStepState } from "../../../../types";
 export declare class PipelineUtils<TPipelineInput, TPipelineOutput, TContext> {
-    getStepByKey: (step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, key: string) => PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>;
-    getStepInputByKey: <TStepInput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, key: string) => TStepInput;
-    getStepOutputByKey: <TStepOutput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, key: string) => TStepOutput;
-    getStep: (step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>;
-    getStepInput: <TStepInput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepInput;
-    getStepOutput: <TStepOutput>(step: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepOutput;
+    getStepByKey: (state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, key: string) => PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>;
+    getStepInputByKey: <TStepInput>(state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, key: string) => TStepInput;
+    getStepOutputByKey: <TStepOutput>(state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, key: string) => TStepOutput;
+    getStep: (state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>;
+    getStepInput: <TStepInput>(state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepInput;
+    getStepOutput: <TStepOutput>(state: PipelineCompletedStepState<TPipelineInput, TContext, unknown, unknown>, index: number) => TStepOutput;
 }

package/dist/cjs/types/platforms/nest/services/operations/operation-lock.service.d.ts

@@ -1,10 +1,10 @@
 import { ILockRepository } from "../../../../abstractions";
-import { ExclusiveOperationResult, ExecuteExclusiveInput } from "./types";
+import { ExclusiveOperationResult, ExecuteExclusiveInput, ExecuteSequentialInput } from "./types";
 export declare class OperationLockService {
     private readonly operations;
     private readonly logger;
     constructor(operations: ILockRepository);
+    executeSequential: <T>(input: ExecuteSequentialInput<T>) => Promise<T>;
     executeExclusive: <T>(input: ExecuteExclusiveInput<T>) => Promise<ExclusiveOperationResult<T>>;
-    private executeOperation;
     private isLockExpired;
 }

package/dist/cjs/types/platforms/nest/services/operations/types.d.ts

@@ -10,3 +10,12 @@ export declare class ExclusiveOperationResult<T> {
     skipped: boolean;
     result?: T;
 }
+export interface ExecuteSequentialInput<T> {
+    lockUid: string;
+    requestedBy?: string;
+    lockTimeout?: number;
+    lockPolling?: number;
+    operation: () => Promise<T>;
+}
+export declare class ExecuteSequentialTimeoutError extends Error {
+}

package/dist/esm/index.js

@@ -1,4 +1,4 @@
-import { Log, csvParse, excelParse, excelBuild, csvBuild, isNullOrUndefined, addTime, newUuid as newUuid$1, buildObject, toDict, sort, byField, toArrayDict, toItemsDict, ensureTailingSlash, ensureStartSlash, removeUndefinedProps, sleep } from '@punks/backend-core';
+import { Log, csvParse, excelParse, excelBuild, csvBuild, isNullOrUndefined, addTime, newUuid as newUuid$1, buildObject, toDict, sleep, sort, byField, toArrayDict, toItemsDict, ensureTailingSlash, ensureStartSlash, removeUndefinedProps } from '@punks/backend-core';
 import { MoreThanOrEqual, Equal, Not, IsNull, And, MoreThan, LessThanOrEqual, LessThan, ILike, In, Or, Repository } from 'typeorm';
 import { applyDecorators, Injectable, SetMetadata, createParamDecorator, Global, Module, Scope, Inject, Logger, StreamableFile, HttpException, HttpStatus } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
@@ -21947,10 +21947,37 @@ function subDays(dirtyDate, dirtyAmount) {
 }
 
 var OperationLockService_1;
+const DEFAULT_LOCK_POLLING = 100;
 let OperationLockService = OperationLockService_1 = class OperationLockService {
     constructor(operations) {
         this.operations = operations;
         this.logger = Log.getLogger(OperationLockService_1.name);
+        this.executeSequential = async (input) => {
+            const lock = await this.operations.acquireLock({
+                lockUid: input.lockUid,
+                requestedBy: input.requestedBy,
+            });
+            if (!lock.available &&
+                input.lockTimeout &&
+                this.isLockExpired(lock.lockItem, new Date(), input.lockTimeout)) {
+                await this.operations.releaseLock({
+                    lockUid: input.lockUid,
+                });
+                return await this.executeSequential(input);
+            }
+            if (!lock.available) {
+                await sleep(input.lockPolling ?? DEFAULT_LOCK_POLLING);
+                return await this.executeSequential(input);
+            }
+            try {
+                return await input.operation();
+            }
+            finally {
+                await this.operations.releaseLock({
+                    lockUid: input.lockUid,
+                });
+            }
+        };
         this.executeExclusive = async (input) => {
             const lock = await this.operations.acquireLock({
                 lockUid: input.lockUid,
@@ -21973,7 +22000,7 @@ let OperationLockService = OperationLockService_1 = class OperationLockService {
             try {
                 return {
                     skipped: false,
-                    result: await this.executeOperation(input),
+                    result: await input.operation(),
                 };
             }
             finally {
@@ -21982,9 +22009,6 @@ let OperationLockService = OperationLockService_1 = class OperationLockService {
                 });
             }
         };
-        this.executeOperation = async (input) => {
-            return await input.operation();
-        };
         this.isLockExpired = (item, refDate, timeoutMinutes) => {
             return differenceInMinutes(refDate, item.createdOn) > timeoutMinutes;
         };
@@ -23531,6 +23555,7 @@ class PipelineStepOperationOptionsBuilder {
     }
     build() {
         return {
+            key: this.operation.key,
             name: this.operation.name,
             operation: this.operation,
             rollbackOperations: this.rollbackOperations,
@@ -34306,32 +34331,32 @@ const buildCompletedStepsSequence = (step) => {
 };
 class PipelineUtils {
     constructor() {
-        this.getStepByKey = (step, key) => {
-            const sequence = buildCompletedStepsSequence(step);
+        this.getStepByKey = (state, key) => {
+            const sequence = buildCompletedStepsSequence(state);
             const matchingStep = sequence.find((x) => x.reference.key === key);
             if (!matchingStep) {
                 throw new Error(`Step key ${key} not found`);
             }
             return matchingStep;
         };
-        this.getStepInputByKey = (step, key) => {
-            return this.getStepByKey(step, key).stepInput;
+        this.getStepInputByKey = (state, key) => {
+            return this.getStepByKey(state, key).stepInput;
         };
-        this.getStepOutputByKey = (step, key) => {
-            return this.getStepByKey(step, key).stepOutput;
+        this.getStepOutputByKey = (state, key) => {
+            return this.getStepByKey(state, key).stepOutput;
         };
-        this.getStep = (step, index) => {
-            const sequence = buildCompletedStepsSequence(step);
+        this.getStep = (state, index) => {
+            const sequence = buildCompletedStepsSequence(state);
             if (index >= sequence.length) {
                 throw new Error(`Step index ${index} is out of range`);
             }
             return sequence[index];
         };
-        this.getStepInput = (step, index) => {
-            return this.getStep(step, index).stepInput;
+        this.getStepInput = (state, index) => {
+            return this.getStep(state, index).stepInput;
         };
-        this.getStepOutput = (step, index) => {
-            return this.getStep(step, index).stepOutput;
+        this.getStepOutput = (state, index) => {
+            return this.getStep(state, index).stepOutput;
         };
     }
 }