@etohq/workflow-engine-redis 1.5.1-alpha.4 → 1.5.1-alpha.8

package/dist/utils/workflow-orchestrator-storage.js

@@ -10,12 +10,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _RedisDistributedTransactionStorage_instances, _RedisDistributedTransactionStorage_isWorkerMode, _RedisDistributedTransactionStorage_preventRaceConditionExecutionIfNecessary;
+var _RedisDistributedTransactionStorage_instances, _RedisDistributedTransactionStorage_isWorkerMode, _RedisDistributedTransactionStorage_getLockKey, _RedisDistributedTransactionStorage_acquireLock, _RedisDistributedTransactionStorage_releaseLock, _RedisDistributedTransactionStorage_preventRaceConditionExecutionIfNecessary;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisDistributedTransactionStorage = void 0;
+const core_1 = require("@etohq/framework/mikro-orm/core");
 const orchestration_1 = require("@etohq/framework/orchestration");
 const utils_1 = require("@etohq/framework/utils");
-const core_1 = require("@mikro-orm/core");
 const bullmq_1 = require("bullmq");
 var JobType;
 (function (JobType) {
@@ -24,10 +24,27 @@ var JobType;
     JobType["STEP_TIMEOUT"] = "step_timeout";
     JobType["TRANSACTION_TIMEOUT"] = "transaction_timeout";
 })(JobType || (JobType = {}));
-const ONE_HOUR_IN_MS = 1000 * 60 * 60;
+const THIRTY_MINUTES_IN_MS = 1000 * 60 * 30;
 const REPEATABLE_CLEARER_JOB_ID = "clear-expired-executions";
+const doneStates = new Set([
+    utils_1.TransactionStepState.DONE,
+    utils_1.TransactionStepState.REVERTED,
+    utils_1.TransactionStepState.FAILED,
+    utils_1.TransactionStepState.SKIPPED,
+    utils_1.TransactionStepState.SKIPPED_FAILURE,
+    utils_1.TransactionStepState.TIMEOUT,
+]);
+const finishedStates = new Set([
+    utils_1.TransactionState.DONE,
+    utils_1.TransactionState.FAILED,
+    utils_1.TransactionState.REVERTED,
+]);
+const failedStates = new Set([
+    utils_1.TransactionState.FAILED,
+    utils_1.TransactionState.REVERTED,
+]);
 class RedisDistributedTransactionStorage {
-    constructor({ workflowExecutionService, redisConnection, redisWorkerConnection, redisQueueName, redisJobQueueName, logger, isWorkerMode, }) {
+    constructor({ workflowExecutionService, redisConnection, redisWorkerConnection, redisQueueName, redisJobQueueName, redisMainQueueOptions, redisMainWorkerOptions, redisJobQueueOptions, redisJobWorkerOptions, redisCleanerQueueOptions, redisCleanerWorkerOptions, logger, isWorkerMode, }) {
         _RedisDistributedTransactionStorage_instances.add(this);
         _RedisDistributedTransactionStorage_isWorkerMode.set(this, false);
         this.workflowExecutionService_ = workflowExecutionService;
@@ -37,14 +54,27 @@ class RedisDistributedTransactionStorage {
         this.cleanerQueueName = "workflows-cleaner";
         this.queueName = redisQueueName;
         this.jobQueueName = redisJobQueueName;
-        this.queue = new bullmq_1.Queue(redisQueueName, { connection: this.redisClient });
+        // Store per-queue options
+        this.mainQueueOptions_ = redisMainQueueOptions ?? {};
+        this.mainWorkerOptions_ = redisMainWorkerOptions ?? {};
+        this.jobQueueOptions_ = redisJobQueueOptions ?? {};
+        this.jobWorkerOptions_ = redisJobWorkerOptions ?? {};
+        this.cleanerQueueOptions_ = redisCleanerQueueOptions ?? {};
+        this.cleanerWorkerOptions_ = redisCleanerWorkerOptions ?? {};
+        // Create queues with their respective options
+        this.queue = new bullmq_1.Queue(redisQueueName, {
+            ...this.mainQueueOptions_,
+            connection: this.redisClient,
+        });
         this.jobQueue = isWorkerMode
             ? new bullmq_1.Queue(redisJobQueueName, {
+                ...this.jobQueueOptions_,
                 connection: this.redisClient,
             })
             : undefined;
         this.cleanerQueue_ = isWorkerMode
             ? new bullmq_1.Queue(this.cleanerQueueName, {
+                ...this.cleanerQueueOptions_,
                 connection: this.redisClient,
             })
             : undefined;
@@ -54,12 +84,6 @@ class RedisDistributedTransactionStorage {
         // Close worker gracefully, i.e. wait for the current jobs to finish
         await this.worker?.close();
         await this.jobWorker?.close();
-        const repeatableJobs = (await this.cleanerQueue_?.getRepeatableJobs()) ?? [];
-        for (const job of repeatableJobs) {
-            if (job.id === REPEATABLE_CLEARER_JOB_ID) {
-                await this.cleanerQueue_?.removeRepeatableByKey(job.key);
-            }
-        }
         await this.cleanerWorker_?.close();
     }
     async onApplicationShutdown() {
@@ -68,38 +92,56 @@ class RedisDistributedTransactionStorage {
         await this.cleanerQueue_?.close();
     }
     async onApplicationStart() {
+        await this.ensureRedisConnection();
         const allowedJobs = [
             JobType.RETRY,
             JobType.STEP_TIMEOUT,
             JobType.TRANSACTION_TIMEOUT,
         ];
-        const workerOptions = {
+        // Per-worker options with their respective configurations
+        const mainWorkerOptions = {
+            ...this.mainWorkerOptions_,
+            connection: this.redisWorkerConnection,
+        };
+        const jobWorkerOptions = {
+            ...this.jobWorkerOptions_,
+            connection: this.redisWorkerConnection,
+        };
+        const cleanerWorkerOptions = {
+            ...this.cleanerWorkerOptions_,
             connection: this.redisWorkerConnection,
         };
         // TODO: Remove this once we have released to all clients (Added: v2.6+)
         // Remove all repeatable jobs from the old queue since now we have a queue dedicated to scheduled jobs
         await this.removeAllRepeatableJobs(this.queue);
-        this.worker = new bullmq_1.Worker(this.queueName, async (job) => {
-            this.logger_.debug(`executing job ${job.name} from queue ${this.queueName} with the following data: ${JSON.stringify(job.data)}`);
-            if (allowedJobs.includes(job.name)) {
-                await this.executeTransaction(job.data.workflowId, job.data.transactionId, job.data.transactionMetadata);
-            }
-            if (job.name === JobType.SCHEDULE) {
-                // Remove repeatable job from the old queue since now we have a queue dedicated to scheduled jobs
-                await this.remove(job.data.jobId);
-            }
-        }, workerOptions);
         if (__classPrivateFieldGet(this, _RedisDistributedTransactionStorage_isWorkerMode, "f")) {
+            this.worker = new bullmq_1.Worker(this.queueName, async (job) => {
+                this.logger_.debug(`executing job ${job.name} from queue ${this.queueName} with the following data: ${JSON.stringify(job.data)}`);
+                if (allowedJobs.includes(job.name)) {
+                    try {
+                        await this.executeTransaction(job.data.workflowId, job.data.transactionId, job.data.transactionMetadata);
+                    }
+                    catch (error) {
+                        if (!orchestration_1.SkipExecutionError.isSkipExecutionError(error)) {
+                            throw error;
+                        }
+                    }
+                }
+                if (job.name === JobType.SCHEDULE) {
+                    // Remove repeatable job from the old queue since now we have a queue dedicated to scheduled jobs
+                    await this.remove(job.data.jobId);
+                }
+            }, mainWorkerOptions);
             this.jobWorker = new bullmq_1.Worker(this.jobQueueName, async (job) => {
                 this.logger_.debug(`executing scheduled job ${job.data.jobId} from queue ${this.jobQueueName} with the following options: ${JSON.stringify(job.data.schedulerOptions)}`);
                 return await this.executeScheduledJob(job.data.jobId, job.data.schedulerOptions);
-            }, workerOptions);
+            }, jobWorkerOptions);
             this.cleanerWorker_ = new bullmq_1.Worker(this.cleanerQueueName, async () => {
                 await this.clearExpiredExecutions();
-            }, { connection: this.redisClient });
+            }, cleanerWorkerOptions);
             await this.cleanerQueue_?.add("cleaner", {}, {
                 repeat: {
-                    every: ONE_HOUR_IN_MS,
+                    every: THIRTY_MINUTES_IN_MS,
                 },
                 jobId: REPEATABLE_CLEARER_JOB_ID,
                 removeOnComplete: true,
@@ -110,7 +152,80 @@ class RedisDistributedTransactionStorage {
     setWorkflowOrchestratorService(workflowOrchestratorService) {
         this.workflowOrchestratorService_ = workflowOrchestratorService;
     }
+    async ensureRedisConnection() {
+        const reconnectTasks = [];
+        if (this.redisClient.status !== "ready") {
+            this.logger_.warn(`[Workflow-engine-redis] Redis connection is not ready (status: ${this.redisClient.status}). Attempting to reconnect...`);
+            reconnectTasks.push(this.redisClient
+                .connect()
+                .then(() => {
+                this.logger_.info("[Workflow-engine-redis] Redis connection reestablished successfully");
+            })
+                .catch((error) => {
+                this.logger_.error("[Workflow-engine-redis] Failed to reconnect to Redis", error);
+                throw new utils_1.EtoError(utils_1.EtoError.Types.DB_ERROR, `Redis connection failed: ${error.message}`);
+            }));
+        }
+        if (this.redisWorkerConnection.status !== "ready") {
+            this.logger_.warn(`[Workflow-engine-redis] Redis worker connection is not ready (status: ${this.redisWorkerConnection.status}). Attempting to reconnect...`);
+            reconnectTasks.push(this.redisWorkerConnection
+                .connect()
+                .then(() => {
+                this.logger_.info("[Workflow-engine-redis] Redis worker connection reestablished successfully");
+            })
+                .catch((error) => {
+                this.logger_.error("[Workflow-engine-redis] Failed to reconnect to Redis worker connection", error);
+                throw new utils_1.EtoError(utils_1.EtoError.Types.DB_ERROR, `Redis worker connection failed: ${error.message}`);
+            }));
+        }
+        if (reconnectTasks.length > 0) {
+            await (0, utils_1.promiseAll)(reconnectTasks);
+        }
+    }
     async saveToDb(data, retentionTime) {
+        const isNotStarted = data.flow.state === utils_1.TransactionState.NOT_STARTED;
+        const asyncVersion = data.flow._v;
+        const isFinished = finishedStates.has(data.flow.state);
+        const isWaitingToCompensate = data.flow.state === utils_1.TransactionState.WAITING_TO_COMPENSATE;
+        const isFlowInvoking = data.flow.state === utils_1.TransactionState.INVOKING;
+        const stepsArray = Object.values(data.flow.steps);
+        let currentStep;
+        const targetStates = isFlowInvoking
+            ? new Set([
+                utils_1.TransactionStepState.INVOKING,
+                utils_1.TransactionStepState.DONE,
+                utils_1.TransactionStepState.FAILED,
+            ])
+            : new Set([utils_1.TransactionStepState.COMPENSATING]);
+        for (let i = stepsArray.length - 1; i >= 0; i--) {
+            const step = stepsArray[i];
+            if (step.id === "_root") {
+                break;
+            }
+            const isTargetState = targetStates.has(step.invoke?.state);
+            if (isTargetState && !currentStep) {
+                currentStep = step;
+                break;
+            }
+        }
+        let shouldStoreCurrentSteps = false;
+        if (currentStep) {
+            for (const step of stepsArray) {
+                if (step.id === "_root") {
+                    continue;
+                }
+                if (step.depth === currentStep.depth &&
+                    step?.definition?.store === true) {
+                    shouldStoreCurrentSteps = true;
+                    break;
+                }
+            }
+        }
+        if (!(isNotStarted || isFinished || isWaitingToCompensate) &&
+            !shouldStoreCurrentSteps &&
+            !asyncVersion) {
+            return;
+        }
         await this.workflowExecutionService_.upsert([
             {
                 workflow_id: data.flow.modelId,
@@ -129,8 +244,6 @@ class RedisDistributedTransactionStorage {
     async deleteFromDb(data) {
         await this.workflowExecutionService_.delete([
             {
-                workflow_id: data.flow.modelId,
-                transaction_id: data.flow.transactionId,
                 run_id: data.flow.runId,
             },
         ]);
@@ -166,21 +279,25 @@ class RedisDistributedTransactionStorage {
     }
     async get(key, options) {
         const [_, workflowId, transactionId] = key.split(":");
-        const trx = await this.workflowExecutionService_
-            .list({
-            workflow_id: workflowId,
-            transaction_id: transactionId,
-        }, {
-            select: ["execution", "context"],
-            order: {
-                id: "desc",
-            },
-            take: 1,
-        })
-            .then((trx) => trx[0])
-            .catch(() => undefined);
+        const [trx, rawData] = await (0, utils_1.promiseAll)([
+            this.workflowExecutionService_
+                .list({
+                workflow_id: workflowId,
+                transaction_id: transactionId,
+            }, {
+                select: ["execution", "context"],
+                order: {
+                    id: "desc",
+                },
+                take: 1,
+            })
+                .then((trx) => trx[0])
+                .catch(() => undefined),
+            options?._cachedRawData !== undefined
+                ? Promise.resolve(options._cachedRawData)
+                : this.redisClient.get(key),
+        ]);
         if (trx) {
-            const rawData = await this.redisClient.get(key);
             let flow, errors;
             if (rawData) {
                 const data = JSON.parse(rawData);
@@ -190,10 +307,7 @@ class RedisDistributedTransactionStorage {
             const { idempotent } = options ?? {};
             const execution = trx.execution;
             if (!idempotent) {
-                const isFailedOrReverted = [
-                    utils_1.TransactionState.REVERTED,
-                    utils_1.TransactionState.FAILED,
-                ].includes(execution.state);
+                const isFailedOrReverted = failedStates.has(execution.state);
                 const isDone = execution.state === utils_1.TransactionState.DONE;
                 const isCancellingAndFailedOrReverted = options?.isCancelling && isFailedOrReverted;
                 const isNotCancellingAndDoneOrFailedOrReverted = !options?.isCancelling && (isDone || isFailedOrReverted);
@@ -202,86 +316,101 @@ class RedisDistributedTransactionStorage {
                     return;
                 }
             }
-            return {
-                flow: flow ?? trx.execution,
-                context: trx.context?.data,
-                errors: errors ?? trx.context?.errors,
-            };
+            return new orchestration_1.TransactionCheckpoint(flow ?? trx.execution, trx.context?.data, errors ?? trx.context?.errors);
         }
         return;
     }
     async save(key, data, ttl, options) {
         /**
          * Store the retention time only if the transaction is done, failed or reverted.
-         * From that moment, this tuple can be later on archived or deleted after the retention time.
          */
-        const hasFinished = [
-            utils_1.TransactionState.DONE,
-            utils_1.TransactionState.FAILED,
-            utils_1.TransactionState.REVERTED,
-        ].includes(data.flow.state);
-        const { retentionTime, idempotent } = options ?? {};
-        await __classPrivateFieldGet(this, _RedisDistributedTransactionStorage_instances, "m", _RedisDistributedTransactionStorage_preventRaceConditionExecutionIfNecessary).call(this, {
-            data,
-            key,
-            options,
-        });
-        if (hasFinished && retentionTime) {
-            Object.assign(data, {
-                retention_time: retentionTime,
+        const { retentionTime } = options ?? {};
+        let lockAcquired = false;
+        let storedData;
+        if (data.flow._v) {
+            lockAcquired = await __classPrivateFieldGet(this, _RedisDistributedTransactionStorage_instances, "m", _RedisDistributedTransactionStorage_acquireLock).call(this, key);
+            if (!lockAcquired) {
+                throw new Error("Lock not acquired");
+            }
+            storedData = await this.get(key, {
+                isCancelling: !!data.flow.cancelledAt,
             });
+            orchestration_1.TransactionCheckpoint.mergeCheckpoints(data, storedData);
         }
-        const isNotStarted = data.flow.state === utils_1.TransactionState.NOT_STARTED;
-        const isManualTransactionId = !data.flow.transactionId.startsWith("auto-");
-        // Only set if not exists
-        const shouldSetNX = isNotStarted && isManualTransactionId;
-        // Prepare operations to be executed in batch or pipeline
-        const data_ = {
-            errors: data.errors,
-            flow: data.flow,
-        };
-        const stringifiedData = JSON.stringify(data_);
-        const pipeline = this.redisClient.pipeline();
-        // Execute Redis operations
-        if (!hasFinished) {
-            if (ttl) {
-                if (shouldSetNX) {
-                    pipeline.set(key, stringifiedData, "EX", ttl, "NX");
+        try {
+            const hasFinished = finishedStates.has(data.flow.state);
+            await __classPrivateFieldGet(this, _RedisDistributedTransactionStorage_instances, "m", _RedisDistributedTransactionStorage_preventRaceConditionExecutionIfNecessary).call(this, {
+                data: data,
+                key,
+                options,
+                storedData,
+            });
+            // Only set if not exists
+            const shouldSetNX = data.flow.state === utils_1.TransactionState.NOT_STARTED &&
+                !data.flow.transactionId.startsWith("auto-");
+            if (retentionTime) {
+                Object.assign(data, {
+                    retention_time: retentionTime,
+                });
+            }
+            const execPipeline = () => {
+                const stringifiedData = JSON.stringify({
+                    errors: data.errors,
+                    flow: data.flow,
+                });
+                const pipeline = this.redisClient.pipeline();
+                if (!hasFinished) {
+                    if (ttl) {
+                        if (shouldSetNX) {
+                            pipeline.set(key, stringifiedData, "EX", ttl, "NX");
+                        }
+                        else {
+                            pipeline.set(key, stringifiedData, "EX", ttl);
+                        }
+                    }
+                    else {
+                        if (shouldSetNX) {
+                            pipeline.set(key, stringifiedData, "NX");
+                        }
+                        else {
+                            pipeline.set(key, stringifiedData);
+                        }
+                    }
                 }
                 else {
-                    pipeline.set(key, stringifiedData, "EX", ttl);
+                    pipeline.unlink(key);
                 }
-            }
-            else {
-                if (shouldSetNX) {
-                    pipeline.set(key, stringifiedData, "NX");
+                return pipeline.exec().then((result) => {
+                    if (!shouldSetNX) {
+                        return result;
+                    }
+                    const actionResult = result?.pop();
+                    const isOk = !!actionResult?.pop();
+                    if (!isOk) {
+                        throw new orchestration_1.SkipExecutionError("Transaction already started for transactionId: " +
+                            data.flow.transactionId);
+                    }
+                    return result;
+                });
+            };
+            // Parallelize DB and Redis operations for better performance
+            if (hasFinished && !retentionTime) {
+                if (!data.flow.metadata?.parentStepIdempotencyKey) {
+                    await (0, utils_1.promiseAll)([this.deleteFromDb(data), execPipeline()]);
                 }
                 else {
-                    pipeline.set(key, stringifiedData);
+                    await (0, utils_1.promiseAll)([this.saveToDb(data, retentionTime), execPipeline()]);
                 }
             }
-        }
-        else {
-            pipeline.unlink(key);
-        }
-        const pipelinePromise = pipeline.exec().then((result) => {
-            if (!shouldSetNX) {
-                return result;
-            }
-            const actionResult = result?.pop();
-            const isOk = !!actionResult?.pop();
-            if (!isOk) {
-                throw new utils_1.EtoError(utils_1.EtoError.Types.INVALID_ARGUMENT, "Transaction already started for transactionId: " +
-                    data.flow.transactionId);
+            else {
+                await (0, utils_1.promiseAll)([this.saveToDb(data, retentionTime), execPipeline()]);
             }
-            return result;
-        });
-        // Database operations
-        if (hasFinished && !retentionTime && !idempotent) {
-            await (0, utils_1.promiseAll)([pipelinePromise, this.deleteFromDb(data)]);
+            return data;
         }
-        else {
-            await (0, utils_1.promiseAll)([pipelinePromise, this.saveToDb(data, retentionTime)]);
+        finally {
+            if (lockAcquired) {
+                await __classPrivateFieldGet(this, _RedisDistributedTransactionStorage_instances, "m", _RedisDistributedTransactionStorage_releaseLock).call(this, key);
+            }
         }
     }
     async scheduleRetry(transaction, step, timestamp, interval) {
@@ -292,12 +421,16 @@ class RedisDistributedTransactionStorage {
             stepId: step.id,
         }, {
             delay: interval > 0 ? interval * 1000 : undefined,
-            jobId: this.getJobId(JobType.RETRY, transaction, step),
+            jobId: this.getJobId(JobType.RETRY, transaction, step, interval),
             removeOnComplete: true,
         });
     }
     async clearRetry(transaction, step) {
-        await this.removeJob(JobType.RETRY, transaction, step);
+        // Pass retry interval to ensure we remove the correct job (with -retry suffix if interval > 0)
+        const interval = step.definition.retryInterval ||
+            step.definition.retryIntervalAwaiting ||
+            0;
+        await this.removeJob(JobType.RETRY, transaction, step, interval);
     }
     async scheduleTransactionTimeout(transaction, _, interval) {
         await this.queue.add(JobType.TRANSACTION_TIMEOUT, {
@@ -328,18 +461,26 @@ class RedisDistributedTransactionStorage {
     async clearStepTimeout(transaction, step) {
         await this.removeJob(JobType.STEP_TIMEOUT, transaction, step);
     }
-    getJobId(type, transaction, step) {
+    getJobId(type, transaction, step, interval) {
         const key = [type, transaction.modelId, transaction.transactionId];
         if (step) {
-            key.push(step.id, step.attempts + "");
+            key.push(step.id);
+            // Step timeout has a single job per step
+            if (type !== JobType.STEP_TIMEOUT) {
+                key.push(step.attempts + "");
+            }
+            // Add suffix for retry scheduling (interval > 0) to avoid collision with async execution (interval = 0)
+            if (type === JobType.RETRY && (0, utils_1.isDefined)(interval) && interval > 0) {
+                key.push("retry");
+            }
             if (step.isCompensating()) {
                 key.push("compensate");
             }
         }
         return key.join(":");
     }
-    async removeJob(type, transaction, step) {
-        const jobId = this.getJobId(type, transaction, step);
+    async removeJob(type, transaction, step, interval) {
+        const jobId = this.getJobId(type, transaction, step, interval);
         if (type === JobType.SCHEDULE) {
             const job = await this.jobQueue?.getJob(jobId);
             if (job) {
@@ -401,7 +542,7 @@ class RedisDistributedTransactionStorage {
                 $ne: null,
             },
             updated_at: {
-                $lte: (0, core_1.raw)((alias) => `CURRENT_TIMESTAMP - (INTERVAL '1 second' * "retention_time")`),
+                $lte: (0, core_1.raw)((_alias) => `CURRENT_TIMESTAMP - (INTERVAL '1 second' * "retention_time")`),
             },
             state: {
                 $in: [
@@ -414,29 +555,59 @@ class RedisDistributedTransactionStorage {
     }
 }
 exports.RedisDistributedTransactionStorage = RedisDistributedTransactionStorage;
-_RedisDistributedTransactionStorage_isWorkerMode = new WeakMap(), _RedisDistributedTransactionStorage_instances = new WeakSet(), _RedisDistributedTransactionStorage_preventRaceConditionExecutionIfNecessary = async function _RedisDistributedTransactionStorage_preventRaceConditionExecutionIfNecessary({ data, key, options, }) {
+_RedisDistributedTransactionStorage_isWorkerMode = new WeakMap(), _RedisDistributedTransactionStorage_instances = new WeakSet(), _RedisDistributedTransactionStorage_getLockKey = function _RedisDistributedTransactionStorage_getLockKey(key) {
+    return `${key}:lock`;
+}, _RedisDistributedTransactionStorage_acquireLock = async function _RedisDistributedTransactionStorage_acquireLock(key, ttlSeconds = 2) {
+    const lockKey = __classPrivateFieldGet(this, _RedisDistributedTransactionStorage_instances, "m", _RedisDistributedTransactionStorage_getLockKey).call(this, key);
+    const result = await this.redisClient.set(lockKey, 1, "EX", ttlSeconds, "NX");
+    return result === "OK";
+}, _RedisDistributedTransactionStorage_releaseLock = async function _RedisDistributedTransactionStorage_releaseLock(key) {
+    const lockKey = __classPrivateFieldGet(this, _RedisDistributedTransactionStorage_instances, "m", _RedisDistributedTransactionStorage_getLockKey).call(this, key);
+    await this.redisClient.del(lockKey);
+}, _RedisDistributedTransactionStorage_preventRaceConditionExecutionIfNecessary = async function _RedisDistributedTransactionStorage_preventRaceConditionExecutionIfNecessary({ data, key, options, storedData, }) {
     const isInitialCheckpoint = [utils_1.TransactionState.NOT_STARTED].includes(data.flow.state);
     /**
      * In case many execution can succeed simultaneously, we need to ensure that the latest
      * execution does continue if a previous execution is considered finished
      */
     const currentFlow = data.flow;
-    const rawData = await this.redisClient.get(key);
-    let data_ = {};
-    if (rawData) {
-        data_ = JSON.parse(rawData);
-    }
-    else {
-        const getOptions = {
-            ...options,
-            isCancelling: !!data.flow.cancelledAt,
-        };
-        data_ =
-            (await this.get(key, getOptions)) ??
-                { flow: {} };
+    let data_ = storedData ?? {};
+    if (!storedData) {
+        const rawData = await this.redisClient.get(key);
+        if (rawData) {
+            data_ = JSON.parse(rawData);
+        }
+        else {
+            // Pass cached raw data to avoid redundant Redis fetch
+            const getOptions = {
+                ...options,
+                isCancelling: !!data.flow.cancelledAt,
+                _cachedRawData: rawData,
+            };
+            data_ =
+                (await this.get(key, getOptions)) ??
+                    { flow: {} };
+        }
     }
     const { flow: latestUpdatedFlow } = data_;
-    if (!isInitialCheckpoint && !(0, utils_1.isPresent)(latestUpdatedFlow)) {
+    if (options?.stepId) {
+        const stepId = options.stepId;
+        const currentStep = data.flow.steps[stepId];
+        const latestStep = latestUpdatedFlow.steps?.[stepId];
+        if (latestStep && currentStep) {
+            const isCompensating = data.flow.state === utils_1.TransactionState.COMPENSATING;
+            const latestState = isCompensating
+                ? latestStep.compensate?.state
+                : latestStep.invoke?.state;
+            const shouldSkip = doneStates.has(latestState);
+            if (shouldSkip) {
+                throw new orchestration_1.SkipStepAlreadyFinishedError(`Step ${stepId} already finished by another execution`);
+            }
+        }
+    }
+    if (!isInitialCheckpoint &&
+        !(0, utils_1.isPresent)(latestUpdatedFlow) &&
+        !data.flow.metadata?.parentStepIdempotencyKey) {
         /**
          * the initial checkpoint expect no other checkpoint to have been stored.
          * In case it is not the initial one and another checkpoint is trying to
@@ -445,64 +616,12 @@ _RedisDistributedTransactionStorage_isWorkerMode = new WeakMap(), _RedisDistribu
          */
         throw new orchestration_1.SkipExecutionError("Already finished by another execution");
     }
-    // First ensure that the latest execution was not cancelled, otherwise we skip the execution
+    // Ensure that the latest execution was not cancelled, otherwise we skip the execution
     const latestTransactionCancelledAt = latestUpdatedFlow.cancelledAt;
     const currentTransactionCancelledAt = currentFlow.cancelledAt;
     if (!!latestTransactionCancelledAt &&
         currentTransactionCancelledAt == null) {
         throw new orchestration_1.SkipCancelledExecutionError("Workflow execution has been cancelled during the execution");
     }
-    const currentFlowSteps = Object.values(currentFlow.steps || {});
-    const latestUpdatedFlowSteps = latestUpdatedFlow.steps
-        ? Object.values(latestUpdatedFlow.steps)
-        : [];
-    // Predefined states for quick lookup
-    const invokingStates = [
-        utils_1.TransactionStepState.INVOKING,
-        utils_1.TransactionStepState.NOT_STARTED,
-    ];
-    const compensatingStates = [
-        utils_1.TransactionStepState.COMPENSATING,
-        utils_1.TransactionStepState.NOT_STARTED,
-    ];
-    const isInvokingState = (step) => invokingStates.includes(step.invoke?.state);
-    const isCompensatingState = (step) => compensatingStates.includes(step.compensate?.state);
-    const currentFlowLastInvokingStepIndex = currentFlowSteps.findIndex(isInvokingState);
-    const latestUpdatedFlowLastInvokingStepIndex = !latestUpdatedFlow.steps
-        ? 1 // There is no other execution, so the current execution is the latest
-        : latestUpdatedFlowSteps.findIndex(isInvokingState);
-    const reversedCurrentFlowSteps = [...currentFlowSteps].reverse();
-    const currentFlowLastCompensatingStepIndex = reversedCurrentFlowSteps.findIndex(isCompensatingState);
-    const reversedLatestUpdatedFlowSteps = [...latestUpdatedFlowSteps].reverse();
-    const latestUpdatedFlowLastCompensatingStepIndex = !latestUpdatedFlow.steps
-        ? -1
-        : reversedLatestUpdatedFlowSteps.findIndex(isCompensatingState);
-    const isLatestExecutionFinishedIndex = -1;
-    const invokeShouldBeSkipped = (latestUpdatedFlowLastInvokingStepIndex ===
-        isLatestExecutionFinishedIndex ||
-        currentFlowLastInvokingStepIndex <
-            latestUpdatedFlowLastInvokingStepIndex) &&
-        currentFlowLastInvokingStepIndex !== isLatestExecutionFinishedIndex;
-    const compensateShouldBeSkipped = currentFlowLastCompensatingStepIndex <
-        latestUpdatedFlowLastCompensatingStepIndex &&
-        currentFlowLastCompensatingStepIndex !== isLatestExecutionFinishedIndex &&
-        latestUpdatedFlowLastCompensatingStepIndex !==
-            isLatestExecutionFinishedIndex;
-    const isCompensatingMismatch = latestUpdatedFlow.state === utils_1.TransactionState.COMPENSATING &&
-        ![utils_1.TransactionState.REVERTED, utils_1.TransactionState.FAILED].includes(currentFlow.state) &&
-        currentFlow.state !== latestUpdatedFlow.state;
-    const isRevertedMismatch = latestUpdatedFlow.state === utils_1.TransactionState.REVERTED &&
-        currentFlow.state !== utils_1.TransactionState.REVERTED;
-    const isFailedMismatch = latestUpdatedFlow.state === utils_1.TransactionState.FAILED &&
-        currentFlow.state !== utils_1.TransactionState.FAILED;
-    if ((data.flow.state !== utils_1.TransactionState.COMPENSATING &&
-        invokeShouldBeSkipped) ||
-        (data.flow.state === utils_1.TransactionState.COMPENSATING &&
-            compensateShouldBeSkipped) ||
-        isCompensatingMismatch ||
-        isRevertedMismatch ||
-        isFailedMismatch) {
-        throw new orchestration_1.SkipExecutionError("Already finished by another execution");
-    }
 };
 //# sourceMappingURL=workflow-orchestrator-storage.js.map