@bitblit/ratchet-common 4.0.115-alpha → 4.0.119-alpha

package/lib/tx/transaction-ratchet.js

@@ -1,76 +0,0 @@
-import { Logger } from '../logger/logger.js';
-import { RequireRatchet } from '../lang/require-ratchet.js';
-import { LoggerLevelName } from '../logger/logger-level-name.js';
-import { TransactionFinalState } from './transaction-final-state.js';
-export class TransactionRatchet {
-    static async execute(steps, initialContext, inConfiguration) {
-        RequireRatchet.notNullOrUndefined(steps, 'steps');
-        RequireRatchet.notNullOrUndefined(initialContext, 'initialContext');
-        RequireRatchet.true(steps.length > 0, 'steps may not be empty');
-        const config = Object.assign({}, inConfiguration || {});
-        config.stepLogLevel = config.stepLogLevel || LoggerLevelName.info;
-        const rval = {
-            finalContext: initialContext,
-            finalState: null,
-        };
-        const stepNames = steps.map((s, idx) => s.name || 'Step ' + idx);
-        Logger.info('Beginning transaction of %d steps', steps.length);
-        let idx = 0;
-        do {
-            Logger.logByLevel(config.stepLogLevel, 'Processing step %d of %d (%s)', idx + 1, steps.length, stepNames[idx]);
-            try {
-                await steps[idx].execute(rval.finalContext, idx);
-                idx++;
-            }
-            catch (err) {
-                Logger.error('Failure detected on step %d : %s : %s : Rolling back', idx, stepNames[idx], err, err);
-                rval.error = err;
-                rval.errorStep = idx;
-            }
-        } while (!rval.error && idx < steps.length);
-        if (rval.error) {
-            do {
-                Logger.logByLevel(config.stepLogLevel, 'Rolling back step %d of %d (%s)', idx + 1, steps.length, stepNames[idx]);
-                try {
-                    if (steps[idx].rollback) {
-                        await steps[idx].rollback(rval.finalContext, idx);
-                    }
-                    else {
-                        Logger.info('Skipping - no rollback defined');
-                    }
-                }
-                catch (err) {
-                    Logger.error('Very bad - rollback code failed on step %d : %s : Aborting in invalid state: %s', idx, stepNames[idx], err, err);
-                    rval.rollbackError = err;
-                    rval.rollbackErrorStep = idx;
-                }
-                idx--;
-            } while (idx >= 0);
-        }
-        rval.finalState = rval.rollbackError
-            ? TransactionFinalState.RollbackFailed
-            : rval.error
-                ? TransactionFinalState.RolledBack
-                : TransactionFinalState.Success;
-        Logger.info('Transaction completed with status : %s', rval.finalState);
-        if (config?.executeAfterRollback && rval.finalState !== TransactionFinalState.Success) {
-            try {
-                Logger.info('Applying executeAfterRollback');
-                await config.executeAfterRollback(rval);
-            }
-            catch (err) {
-                Logger.error('Very bad - failure in executeAfterRollback : %s', err, err);
-            }
-        }
-        if (config?.executeAfterRollbackFailure && rval.finalState !== TransactionFinalState.Success) {
-            try {
-                Logger.info('Applying executeAfterRollbackFailure');
-                await config.executeAfterRollbackFailure(rval);
-            }
-            catch (err) {
-                Logger.error('Very bad - failure in executeAfterRollbackFailure : %s', err, err);
-            }
-        }
-        return rval;
-    }
-}

package/lib/tx/transaction-ratchet.spec.js

@@ -1,130 +0,0 @@
-import { TransactionRatchet } from './transaction-ratchet.js';
-import { TransactionFinalState } from './transaction-final-state.js';
-import { LoggerLevelName } from '../logger/logger-level-name.js';
-class TestTransactionStep {
-    async execute(context, stepNumber) {
-        context.runningTotal += stepNumber;
-        if (stepNumber === context?.failStep) {
-            throw new Error('Forced error at step ' + stepNumber);
-        }
-    }
-    async rollback(context, stepNumber) {
-        context.runningTotal -= stepNumber;
-        if (stepNumber === context?.failRollbackStep) {
-            throw new Error('Forced rollback error at step ' + stepNumber);
-        }
-    }
-}
-describe('#TransactionRatchet.execute', function () {
-    it('should return the right value when it executes successfully', async () => {
-        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
-        const ctx = { runningTotal: 0 };
-        const result = await TransactionRatchet.execute(steps, ctx);
-        expect(result).not.toBeNull();
-        expect(result.error).toBeUndefined();
-        expect(result.finalState).toEqual(TransactionFinalState.Success);
-        expect(result.finalContext.runningTotal).toEqual(3);
-    });
-    it('should return the right value when it rolls back successfully fail step 2', async () => {
-        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
-        const ctx = { runningTotal: 0, failStep: 2 };
-        const result = await TransactionRatchet.execute(steps, ctx);
-        expect(result).not.toBeUndefined();
-        expect(result.finalState).toEqual(TransactionFinalState.RolledBack);
-        expect(result.errorStep).toEqual(2);
-        expect(result.error).not.toBeUndefined();
-        expect(result.finalContext.runningTotal).toEqual(0);
-    });
-    it('should return the right value when it rolls back successfully fail step 1', async () => {
-        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
-        const ctx = { runningTotal: 0, failStep: 2 };
-        const result = await TransactionRatchet.execute(steps, ctx);
-        expect(result).not.toBeUndefined();
-        expect(result.finalState).toEqual(TransactionFinalState.RolledBack);
-        expect(result.errorStep).toEqual(2);
-        expect(result.error).not.toBeUndefined();
-        expect(result.finalContext.runningTotal).toEqual(0);
-    });
-    it('should return the right value the rollback fails', async () => {
-        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
-        const ctx = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
-        const result = await TransactionRatchet.execute(steps, ctx);
-        expect(result).not.toBeUndefined();
-        expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
-        expect(result.finalContext.runningTotal).toEqual(0);
-        expect(result.errorStep).toEqual(2);
-        expect(result.rollbackErrorStep).toEqual(1);
-        expect(result.error).not.toBeUndefined();
-        expect(result.rollbackError).not.toBeUndefined();
-    });
-    it('should run the post-error handler when a failure happens', async () => {
-        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
-        const ctx = { runningTotal: 0, failStep: 2 };
-        const result = await TransactionRatchet.execute(steps, ctx, {
-            executeAfterRollback: async (res) => {
-                res.finalContext.postTxTracker = 1;
-            },
-        });
-        expect(result).not.toBeUndefined();
-        expect(result.finalState).toEqual(TransactionFinalState.RolledBack);
-        expect(result.errorStep).toEqual(2);
-        expect(result.error).not.toBeUndefined();
-        expect(result.finalContext.postTxTracker).toEqual(1);
-    });
-    it('should run both post-error handler when a failure happens in both error and rollback', async () => {
-        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
-        const ctx = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
-        const result = await TransactionRatchet.execute(steps, ctx, {
-            executeAfterRollback: async (res) => {
-                res.finalContext.postTxTracker = 1;
-            },
-            executeAfterRollbackFailure: async (res) => {
-                res.finalContext.postTxTracker += 1;
-            },
-        });
-        expect(result).not.toBeUndefined();
-        expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
-        expect(result.errorStep).toEqual(2);
-        expect(result.error).not.toBeUndefined();
-        expect(result.finalContext.postTxTracker).toEqual(2);
-    });
-    it('should still return if a post-tx executor fails', async () => {
-        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
-        const ctx = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
-        const result = await TransactionRatchet.execute(steps, ctx, {
-            executeAfterRollback: async (res) => {
-                res.finalContext.postTxTracker = 1;
-            },
-            executeAfterRollbackFailure: async (res) => {
-                res.finalContext.postTxTracker += 1;
-                throw new Error('Forced tracker failure');
-            },
-        });
-        expect(result).not.toBeUndefined();
-        expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
-        expect(result.errorStep).toEqual(2);
-        expect(result.error).not.toBeUndefined();
-        expect(result.finalContext.postTxTracker).toEqual(2);
-    });
-    it('should work with transaction configuration that only provides read log level access', async () => {
-        const steps = [new TestTransactionStep(), new TestTransactionStep(), new TestTransactionStep()];
-        const ctx = { runningTotal: 0, failStep: 2, failRollbackStep: 1 };
-        const result = await TransactionRatchet.execute(steps, ctx, {
-            get stepLogLevel() {
-                return LoggerLevelName.info;
-            },
-            executeAfterRollback: async (res) => {
-                res.finalContext.postTxTracker = 1;
-            },
-            executeAfterRollbackFailure: async (res) => {
-                res.finalContext.postTxTracker += 1;
-                throw new Error('Forced tracker failure');
-            },
-        });
-        expect(result).not.toBeUndefined();
-        expect(result.finalState).toEqual(TransactionFinalState.RollbackFailed);
-        expect(result.errorStep).toEqual(2);
-        expect(result.error).not.toBeUndefined();
-        expect(result.finalContext.postTxTracker).toEqual(2);
-    });
-});

package/lib/tx/transaction-result.js

@@ -1 +0,0 @@
-export {};

package/lib/tx/transaction-step.js

@@ -1 +0,0 @@
-export {};