@bitblit/ratchet-epsilon-common/lib/lambda-event-handler/cron-epsilon-lambda-event-handler.js

Tiny adapter to simplify building API gateway Lambda APIS

import { Logger } from '@bitblit/ratchet-common/logger/logger';
import { AwsUtil } from '../util/aws-util.js';
import { CronUtil } from '../util/cron-util.js';
import { LambdaEventDetector } from '@bitblit/ratchet-aws/lambda/lambda-event-detector';
import { DateTime } from 'luxon';
export class CronEpsilonLambdaEventHandler {
    _epsilon;
    static CRON_EVENT_TIMESTAMP_MISMATCH_MAX_THRESHOLD_MINUTES = 5;
    constructor(_epsilon) {
        this._epsilon = _epsilon;
    }
    extractLabel(evt, _context) {
        return 'CronEvt:' + evt.source;
    }
    handlesEvent(evt) {
        return LambdaEventDetector.isValidCronEvent(evt);
    }
    async processEvent(evt, _context) {
        let rval = null;
        Logger.debug('Epsilon: CRON: %j', evt);
        if (!this._epsilon.config.cron) {
            Logger.debug('Skipping - CRON disabled');
            rval = {
                statusCode: 200,
                body: JSON.stringify({ message: 'CRON skipped - disabled' }),
                isBase64Encoded: false,
            };
        }
        else {
            const _output = await 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 async processCronEvent(evt, cronConfig, backgroundManager, background) {
        let rval = false;
        if (cronConfig && evt && evt.resources[0]) {
            if (cronConfig.entries) {
                if (background) {
                    const cronTimestampEpochMS = CronEpsilonLambdaEventHandler.getCronTimeToUse(evt);
                    const toEnqueue = [];
                    for (const smCronEntry of cronConfig.entries) {
                        if (CronUtil.eventMatchesEntry(evt, smCronEntry, cronConfig, cronTimestampEpochMS)) {
                            Logger.info('CRON Firing : %s', CronUtil.cronEntryName(smCronEntry));
                            const backgroundEntry = {
                                type: smCronEntry.backgroundTaskType,
                                data: AwsUtil.resolvePotentialFunctionToResult(smCronEntry.data, {}),
                            };
                            Logger.silly('Resolved entry : %j', backgroundEntry);
                            if (smCronEntry.fireImmediate) {
                                await backgroundManager.fireImmediateProcessRequest(backgroundEntry);
                                rval = true;
                            }
                            else {
                                toEnqueue.push(backgroundEntry);
                            }
                        }
                    }
                    if (toEnqueue.length > 0) {
                        await backgroundManager.addEntriesToQueue(toEnqueue, true);
                        rval = true;
                    }
                }
                else {
                    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?.time) {
            return rval;
        }
        try {
            const dateTimeOfEvent = 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) {
            Logger.warn('Could not parse event time : %s, using system time instead', evt.time, err);
            return rval;
        }
        if (Math.abs(rval - currentTimestampEpochMS) >
            CronEpsilonLambdaEventHandler.CRON_EVENT_TIMESTAMP_MISMATCH_MAX_THRESHOLD_MINUTES * 60 * 1000) {
            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;
    }
}
//# sourceMappingURL=cron-epsilon-lambda-event-handler.js.map