@bitblit/epsilon/lambda-event-handler/cron-epsilon-lambda-event-handler.js

Tiny adapter to simplify building API gateway Lambda APIS

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.CronEpsilonLambdaEventHandler = void 0;
const common_1 = require("@bitblit/ratchet/common");
const luxon_1 = require("luxon");
const aws_util_1 = require("../util/aws-util");
const cron_util_1 = require("../util/cron-util");
const aws_1 = require("@bitblit/ratchet/aws");
class CronEpsilonLambdaEventHandler {
    constructor(_epsilon) {
        this._epsilon = _epsilon;
    }
    extractLabel(evt, context) {
        return 'CronEvt:' + evt.source;
    }
    handlesEvent(evt) {
        return aws_1.LambdaEventDetector.isValidCronEvent(evt);
    }
    processEvent(evt, context) {
        return __awaiter(this, void 0, void 0, function* () {
            let rval = null;
            common_1.Logger.debug('Epsilon: CRON: %j', evt);
            if (!this._epsilon.config.cron) {
                common_1.Logger.debug('Skipping - CRON disabled');
                rval = {
                    statusCode: 200,
                    body: JSON.stringify({ message: 'CRON skipped - disabled' }),
                    isBase64Encoded: false,
                };
            }
            else {
                const output = yield CronEpsilonLambdaEventHandler.processCronEvent(evt, this._epsilon.config.cron, this._epsilon.backgroundManager, this._epsilon.backgroundHandler);
                rval = {
                    statusCode: 200,
                    body: JSON.stringify({ message: 'CRON complete' }),
                    isBase64Encoded: false,
                };
            }
            return rval;
        });
    }
    static processCronEvent(evt, cronConfig, backgroundManager, background) {
        return __awaiter(this, void 0, void 0, function* () {
            let rval = false;
            if (cronConfig && evt && evt.resources[0]) {
                // Run all the background ones
                if (!!cronConfig.entries) {
                    if (!!background) {
                        const cronTimestampEpochMS = CronEpsilonLambdaEventHandler.getCronTimeToUse(evt);
                        const toEnqueue = [];
                        for (let i = 0; i < cronConfig.entries.length; i++) {
                            const smCronEntry = cronConfig.entries[i];
                            if (cron_util_1.CronUtil.eventMatchesEntry(evt, smCronEntry, cronConfig, cronTimestampEpochMS)) {
                                common_1.Logger.info('CRON Firing : %s', cron_util_1.CronUtil.cronEntryName(smCronEntry));
                                const backgroundEntry = {
                                    type: smCronEntry.backgroundTaskType,
                                    data: aws_util_1.AwsUtil.resolvePotentialFunctionToResult(smCronEntry.data, {}),
                                };
                                common_1.Logger.silly('Resolved entry : %j', backgroundEntry);
                                if (smCronEntry.fireImmediate) {
                                    yield backgroundManager.fireImmediateProcessRequest(backgroundEntry);
                                    rval = true;
                                }
                                else {
                                    toEnqueue.push(backgroundEntry);
                                }
                            }
                        }
                        if (toEnqueue.length > 0) {
                            yield backgroundManager.addEntriesToQueue(toEnqueue, true);
                            rval = true;
                        }
                    }
                    else {
                        common_1.Logger.warn('Cron defines background tasks, but no background manager provided');
                    }
                }
            }
            return rval;
        });
    }
    static getCronTimeToUse(evt, currentTimestampEpochMS = new Date().getTime()) {
        let rval = currentTimestampEpochMS;
        if (!(evt === null || evt === void 0 ? void 0 : evt.time)) {
            return rval;
        }
        try {
            const dateTimeOfEvent = luxon_1.DateTime.fromISO(evt.time);
            if (!dateTimeOfEvent.isValid) {
                throw new Error('Invalid date');
            }
            rval = dateTimeOfEvent.toMillis();
            if (isNaN(rval)) {
                throw new Error('Invalid date');
            }
        }
        catch (err) {
            common_1.Logger.warn('Could not parse event time : %s, using system time instead', evt.time);
            return rval;
        }
        if (Math.abs(rval - currentTimestampEpochMS) >
            CronEpsilonLambdaEventHandler.CRON_EVENT_TIMESTAMP_MISMATCH_MAX_THRESHOLD_MINUTES * 60 * 1000) {
            common_1.Logger.warn('Event time and current time mismatch by more than %d minutes, using current time instead', CronEpsilonLambdaEventHandler.CRON_EVENT_TIMESTAMP_MISMATCH_MAX_THRESHOLD_MINUTES);
            rval = currentTimestampEpochMS;
        }
        return rval;
    }
}
exports.CronEpsilonLambdaEventHandler = CronEpsilonLambdaEventHandler;
CronEpsilonLambdaEventHandler.CRON_EVENT_TIMESTAMP_MISMATCH_MAX_THRESHOLD_MINUTES = 5;
//# sourceMappingURL=cron-epsilon-lambda-event-handler.js.map