@devcycle/js-cloud-server-sdk/src/hooks/EvalHooksRunner.js

The DevCycle JS Cloud Bucketing Server SDK used for feature management.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EvalHooksRunner = void 0;
const HookContext_1 = require("./HookContext");
class EvalHooksRunner {
    constructor(hooks = [], logger) {
        this.hooks = hooks;
        this.logger = logger;
    }
    async runHooksForEvaluation(user, key, defaultValue, metadata, resolver) {
        const context = new HookContext_1.HookContext(user, key, defaultValue, metadata);
        const savedHooks = [...this.hooks];
        const reversedHooks = [...savedHooks].reverse();
        let beforeContext = context;
        let variableDetails;
        try {
            beforeContext = await this.runBefore(savedHooks, context);
            variableDetails = await resolver(beforeContext);
            await this.runAfter(reversedHooks, beforeContext, variableDetails);
        }
        catch (error) {
            await this.runError(reversedHooks, context, error);
            await this.runFinally(reversedHooks, context, undefined);
            if (error.name === 'BeforeHookError' ||
                error.name === 'AfterHookError') {
                // make sure to return with a variable if before or after hook errors
                return await resolver(context);
            }
            throw error;
        }
        await this.runFinally(reversedHooks, context, variableDetails);
        return variableDetails;
    }
    async runBefore(hooks, context) {
        var _a;
        const contextCopy = { ...context };
        try {
            for (const hook of hooks) {
                const newContext = await hook.before(contextCopy);
                if (newContext) {
                    Object.assign(contextCopy, {
                        ...contextCopy,
                        ...newContext,
                    });
                }
            }
        }
        catch (error) {
            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error('Error running before hooks', error);
            throw new BeforeHookError(error);
        }
        return contextCopy;
    }
    async runAfter(hooks, context, variableDetails) {
        var _a;
        try {
            for (const hook of hooks) {
                await hook.after(context, variableDetails);
            }
        }
        catch (error) {
            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error('Error running after hooks', error);
            throw new AfterHookError(error);
        }
    }
    async runFinally(hooks, context, variableDetails) {
        var _a;
        try {
            for (const hook of hooks) {
                await hook.onFinally(context, variableDetails);
            }
        }
        catch (error) {
            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error('Error running finally hooks', error);
        }
    }
    async runError(hooks, context, error) {
        var _a;
        try {
            for (const hook of hooks) {
                await hook.error(context, error);
            }
        }
        catch (error) {
            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error('Error running error hooks', error);
        }
    }
    enqueue(hook) {
        this.hooks.push(hook);
    }
    clear() {
        this.hooks = [];
    }
}
exports.EvalHooksRunner = EvalHooksRunner;
class BeforeHookError extends Error {
    constructor(error) {
        super(error.message);
        this.name = 'BeforeHookError';
        this.stack = error.stack;
    }
}
class AfterHookError extends Error {
    constructor(error) {
        super(error.message);
        this.name = 'AfterHookError';
        this.stack = error.stack;
    }
}
//# sourceMappingURL=EvalHooksRunner.js.map