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

package/lib/http/web-handler.js

@@ -1,117 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import Route from 'route-parser';
-import { ResponseUtil } from './response-util.js';
-import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
-import { EpsilonHttpError } from './error/epsilon-http-error.js';
-import { BuiltInFilters } from '../built-in/http/built-in-filters.js';
-import { RunHandlerAsFilter } from '../built-in/http/run-handler-as-filter.js';
-import { ContextUtil } from '../util/context-util.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { LambdaEventDetector } from '@bitblit/ratchet-aws/lib/lambda/lambda-event-detector.js';
-export class WebHandler {
-    routerConfig;
-    static MAXIMUM_LAMBDA_BODY_SIZE_BYTES = 1024 * 1024 * 5 - 1024 * 100;
-    constructor(routerConfig) {
-        this.routerConfig = routerConfig;
-        RequireRatchet.notNullOrUndefined(routerConfig);
-    }
-    get router() {
-        return this.routerConfig;
-    }
-    extractLabel(evt, context) {
-        return 'WEB:' + StringRatchet.trimToEmpty(evt.httpMethod).toUpperCase() + ':' + evt.path;
-    }
-    handlesEvent(evt) {
-        return LambdaEventDetector.isValidApiGatewayEvent(evt);
-    }
-    async processEvent(event, context) {
-        if (!this.routerConfig) {
-            throw new Error('Router config not found');
-        }
-        const asExtended = Object.assign({}, { parsedBody: null, authorization: null, convertedFromV2Event: false }, event);
-        const rval = await this.openApiLambdaHandler(asExtended, context);
-        ContextUtil.addTraceToProxyResult(rval);
-        Logger.updateTracePrefix(null);
-        return rval;
-    }
-    async openApiLambdaHandler(evt, context) {
-        const rm = this.findBestMatchingRoute(evt);
-        const procConfig = rm?.mapping?.metaProcessingConfig
-            ? rm.mapping.metaProcessingConfig
-            : this.routerConfig.config.defaultMetaHandling;
-        const fCtx = {
-            event: evt,
-            context: context,
-            result: null,
-            rawResult: null,
-            routeAndParse: rm,
-            modelValidator: this.routerConfig.config.overrideModelValidator || this.routerConfig.openApiModelValidator,
-            authenticators: this.routerConfig.config.authorizers,
-        };
-        try {
-            let filterChain = Object.assign([], procConfig.preFilters || []);
-            RunHandlerAsFilter.addRunHandlerAsFilterToList(filterChain, rm);
-            filterChain = filterChain.concat(procConfig.postFilters || []);
-            await BuiltInFilters.combineFilters(fCtx, filterChain);
-        }
-        catch (err) {
-            const wrapper = EpsilonHttpError.wrapError(err);
-            fCtx.result = ResponseUtil.errorResponse(wrapper);
-            try {
-                await BuiltInFilters.combineFilters(fCtx, procConfig.errorFilters);
-            }
-            catch (convErr) {
-                Logger.error('REALLY BAD - FAILED WHILE PROCESSING ERROR FILTERS : %s', convErr);
-            }
-        }
-        return fCtx.result;
-    }
-    findBestMatchingRoute(event) {
-        let rval = null;
-        const cleanPath = this.cleanPath(event);
-        const methodLower = event.httpMethod.toLowerCase();
-        const matchRoutes = this.routerConfig.routes
-            .map((r) => {
-            let rval = null;
-            if (r.method && r.method.toLowerCase() === methodLower) {
-                const routeParser = new Route(r.path);
-                const parsed = routeParser.match(cleanPath);
-                if (parsed !== false) {
-                    rval = {
-                        mapping: r,
-                        route: routeParser,
-                        parsed: parsed,
-                    };
-                }
-            }
-            return rval;
-        })
-            .filter((r) => r != null);
-        matchRoutes.sort((a, b) => {
-            return Object.keys(a.parsed).length - Object.keys(b.parsed).length;
-        });
-        rval = matchRoutes && matchRoutes.length > 0 ? matchRoutes[0] : null;
-        if (!rval) {
-            Logger.debug('Failed to find handler for %s (cleaned path was %s, strip prefixes were %j)', event.path, cleanPath, this.routerConfig.config.prefixesToStripBeforeRouteMatch);
-        }
-        return rval;
-    }
-    cleanPath(event) {
-        let rval = event.path;
-        while (rval.startsWith('/')) {
-            rval = rval.substring(1);
-        }
-        if (this.routerConfig.config.prefixesToStripBeforeRouteMatch) {
-            this.routerConfig.config.prefixesToStripBeforeRouteMatch.forEach((prefix) => {
-                if (rval.toLowerCase().startsWith(prefix.toLowerCase() + '/')) {
-                    rval = rval.substring(prefix.length);
-                }
-            });
-        }
-        while (rval.startsWith('/')) {
-            rval = rval.substring(1);
-        }
-        rval = '/' + rval;
-        return rval;
-    }
-}

package/lib/http/web-handler.spec.js

@@ -1,32 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { SampleServerComponents } from '../sample/sample-server-components.js';
-import { LoggerLevelName } from '@bitblit/ratchet-common/lib/logger/logger-level-name.js';
-describe('#errorToProxyResult', function () {
-    it('should gzip responses correctly', async () => {
-        const inst = await SampleServerComponents.createSampleEpsilonGlobalHandler('jest-gzip');
-        expect(inst.epsilon.modelValidator).toBeTruthy();
-        const evt = {
-            httpMethod: 'get',
-            multiValueHeaders: {},
-            multiValueQueryStringParameters: {},
-            path: '/meta/server',
-            pathParameters: null,
-            queryStringParameters: null,
-            stageVariables: null,
-            requestContext: {},
-            resource: '/meta/server',
-            headers: {
-                'content-type': 'application/json; charset=UTF-8',
-                'accept-encoding': 'gzip, deflate, br',
-            },
-            isBase64Encoded: true,
-            body: null,
-        };
-        Logger.setLevel(LoggerLevelName.silly);
-        const result = await inst.epsilon.webHandler.processEvent(evt, {});
-        expect(result).toBeTruthy();
-        expect(result.isBase64Encoded).toEqual(true);
-        expect(result.headers).toBeTruthy();
-        expect(result.headers['Content-Encoding']).toEqual('gzip');
-    });
-});

package/lib/http/web-v2-handler.js

@@ -1,22 +0,0 @@
-import { AwsUtil } from '../util/aws-util.js';
-import { LambdaEventDetector } from '@bitblit/ratchet-aws/lib/lambda/lambda-event-detector.js';
-export class WebV2Handler {
-    webHandler;
-    constructor(webHandler) {
-        this.webHandler = webHandler;
-    }
-    extractLabel(evt, context) {
-        let rval = this.webHandler.extractLabel(AwsUtil.apiGatewayV2ToApiGatewayV1(evt), context);
-        rval = rval.replace('WEB:', 'WEB2:');
-        return rval;
-    }
-    handlesEvent(evt) {
-        return LambdaEventDetector.isValidApiGatewayV2WithRequestContextEvent(evt);
-    }
-    async processEvent(evt, context) {
-        const conv = AwsUtil.apiGatewayV2ToApiGatewayV1(evt);
-        const asExtended = Object.assign({}, { parsedBody: null, authorization: null, convertedFromV2Event: true }, conv);
-        const rval = await this.webHandler.openApiLambdaHandler(asExtended, context);
-        return rval;
-    }
-}

package/lib/index.js

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

package/lib/inter-api/inter-api-entry.js

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

package/lib/inter-api/inter-api-util.js

@@ -1,59 +0,0 @@
-import { LambdaEventDetector } from '@bitblit/ratchet-aws/lib/lambda/lambda-event-detector.js';
-import { EpsilonConstants } from '../epsilon-constants.js';
-import { RequireRatchet } from '@bitblit/ratchet-common/lib/lang/require-ratchet.js';
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { StringRatchet } from '@bitblit/ratchet-common/lib/lang/string-ratchet.js';
-import { ContextUtil } from '../util/context-util.js';
-export class InterApiUtil {
-    static isInterApiSnsEvent(event) {
-        return !!InterApiUtil.extractEntryFromEvent(event);
-    }
-    static extractEntryFromEvent(evt) {
-        let rval = null;
-        if (!!evt) {
-            if (LambdaEventDetector.isSingleSnsEvent(evt)) {
-                const cast = evt;
-                const msg = cast.Records[0].Sns.Message;
-                if (!!StringRatchet.trimToNull(msg)) {
-                    const parsed = JSON.parse(msg);
-                    if (!!parsed && parsed['type'] === EpsilonConstants.INTER_API_SNS_EVENT) {
-                        rval = parsed['interApiEvent'];
-                    }
-                }
-            }
-        }
-        return rval;
-    }
-    static async processInterApiEvent(evt, cfg, mgr) {
-        let rval = [];
-        RequireRatchet.notNullOrUndefined(evt, 'InterApiEntry');
-        RequireRatchet.notNullOrUndefined(mgr, 'BackgroundManager');
-        const interApiEntry = InterApiUtil.extractEntryFromEvent(evt);
-        ContextUtil.setOverrideTraceFromInterApiEntry(interApiEntry);
-        Logger.info('Processing inter-api event : %j', evt);
-        const backgroundEntries = [];
-        cfg.processMappings.forEach((map) => {
-            if (!map.disabled && interApiEntry.source.match(map.sourceRegex) && interApiEntry.type.match(map.typeRegex)) {
-                map.backgroundProcessTypes.forEach((taskName) => {
-                    const entry = mgr.createEntry(taskName, interApiEntry.data);
-                    backgroundEntries.push(entry);
-                });
-            }
-        });
-        if (backgroundEntries.length > 0) {
-            Logger.info('Adding %d entries to queue', backgroundEntries.length);
-            rval = await mgr.addEntriesToQueue(backgroundEntries, true);
-        }
-        else {
-            Logger.info('No entries mapped for this event');
-        }
-        return rval;
-    }
-    static addTraceToInterApiEntry(ent) {
-        if (ent) {
-            ent.traceId = ent.traceId || ContextUtil.currentTraceId();
-            ent.traceDepth = ent.traceDepth || ContextUtil.currentTraceDepth() + 1;
-        }
-        return ent;
-    }
-}

package/lib/inter-api/inter-api-util.spec.js

@@ -1,61 +0,0 @@
-import { InterApiUtil } from './inter-api-util.js';
-import { JestRatchet } from '@bitblit/ratchet-jest/lib/jest/jest-ratchet.js';
-import { jest } from '@jest/globals';
-describe('#interApiUtil', function () {
-    let mockSns;
-    let mockSqs;
-    let mockBgMgr;
-    const evt = {
-        Records: [
-            {
-                EventSource: 'aws:sns',
-                EventVersion: '1.0',
-                EventSubscriptionArn: 'arn:aws:sns:us-east-1:012345678901:GenericApiEventTopicDev:6efec6a5-1f02-4fc5-b0f7-fa7c013cf8bb',
-                Sns: {
-                    Type: 'Notification',
-                    MessageId: '205de1e8-7ba6-52f5-b706-b815f442c512',
-                    TopicArn: 'arn:aws:sns:us-east-1:012345678901:GenericApiEventTopicDev',
-                    Subject: null,
-                    Message: '{"type":"EPSILON_INTER_API_EVENT","interApiEvent":{"source":"OriginalApi","type":"Sample","data":{"notes":"SOURCE API: OriginalApi","timestampEpochMS":1636011428200}}}',
-                    Timestamp: '2021-11-04T07:37:08.241Z',
-                    SignatureVersion: '1',
-                    Signature: 'LyS2ybM/Epsq5sFqPJd==',
-                    SigningCertUrl: 'https://sns.us-east-1.amazonaws.com/SimpleNotificationService-7ff5318490ec183fbaddaa2a969abfda.pem',
-                    UnsubscribeUrl: 'https://sns.us-east-1.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-1:012345678901:GenericApiEventTopicDev:6efec6a5-1f02-4fc5-b0f7-fa7c013cf8bb',
-                    MessageAttributes: {},
-                },
-            },
-        ],
-    };
-    beforeEach(() => {
-        mockSns = JestRatchet.mock(jest.fn);
-        mockSqs = JestRatchet.mock(jest.fn);
-        mockBgMgr = JestRatchet.mock(jest.fn);
-    });
-    it('should translate processes', async () => {
-        mockBgMgr.createEntry.mockResolvedValue({ t: 1 });
-        mockBgMgr.addEntriesToQueue.mockResolvedValue(['a]']);
-        const cfg = {
-            aws: {
-                source: 'test',
-                snsArn: 'test',
-                localMode: true,
-            },
-            processMappings: [
-                {
-                    typeRegex: '.*',
-                    sourceRegex: '.*',
-                    disabled: false,
-                    backgroundProcessTypes: ['TESTBG'],
-                },
-            ],
-        };
-        const output = await InterApiUtil.processInterApiEvent(evt, cfg, mockBgMgr);
-        expect(output).not.toBeNull();
-        expect(output.length).toEqual(1);
-    });
-    it('should verify that an event is an inter-api even', async () => {
-        const res = InterApiUtil.isInterApiSnsEvent(evt);
-        expect(res).toBeTruthy();
-    }, 500);
-});

package/lib/inter-api-manager.js

@@ -1,65 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { EpsilonConstants } from './epsilon-constants.js';
-import { InterApiUtil } from './inter-api/inter-api-util.js';
-import { PublishCommand } from '@aws-sdk/client-sns';
-export class InterApiManager {
-    _aws;
-    _sns;
-    constructor(_aws, _sns) {
-        this._aws = _aws;
-        this._sns = _sns;
-    }
-    get config() {
-        return this._aws;
-    }
-    get sns() {
-        return this._sns;
-    }
-    createEntry(type, data) {
-        const rval = {
-            source: this._aws.source,
-            type: type,
-            data: data,
-        };
-        return rval;
-    }
-    async fireInterApiEventByParts(type, data) {
-        const entry = this.createEntry(type, data);
-        const rval = await this.fireInterApiEvent(entry);
-        return rval;
-    }
-    async fireInterApiEvent(entry) {
-        let rval = null;
-        if (this.config.localMode) {
-            Logger.info('Fire inter-api event ignored because running locally (was %j)', entry);
-            rval = 'INTER-API-IGNORED';
-        }
-        else {
-            try {
-                Logger.info('Firing inter-api event (remote) : %j ', entry);
-                const toWrite = {
-                    type: EpsilonConstants.INTER_API_SNS_EVENT,
-                    interApiEvent: InterApiUtil.addTraceToInterApiEntry(entry),
-                };
-                const msg = JSON.stringify(toWrite);
-                const snsId = await this.writeMessageToSnsTopic(msg);
-                Logger.debug('Inter-api Wrote message : %s to SNS : %s', rval, msg, snsId);
-            }
-            catch (err) {
-                Logger.error('Failed to fireImmediateProcessRequest : %s', err, err);
-            }
-        }
-        return rval;
-    }
-    async writeMessageToSnsTopic(message) {
-        let rval = null;
-        const params = {
-            Message: message,
-            TopicArn: this._aws.snsArn,
-        };
-        Logger.debug('Writing message to SNS topic : j', params);
-        const result = await this.sns.send(new PublishCommand(params));
-        rval = result.MessageId;
-        return rval;
-    }
-}

package/lib/lambda-event-handler/cron-epsilon-lambda-event-handler.js

@@ -1,73 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { AwsUtil } from '../util/aws-util.js';
-import { CronUtil } from '../util/cron-util.js';
-import { LambdaEventDetector } from '@bitblit/ratchet-aws/lib/lambda/lambda-event-detector.js';
-export class CronEpsilonLambdaEventHandler {
-    _epsilon;
-    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 toEnqueue = [];
-                    for (let i = 0; i < cronConfig.entries.length; i++) {
-                        const smCronEntry = cronConfig.entries[i];
-                        if (CronUtil.eventMatchesEntry(evt, smCronEntry, cronConfig)) {
-                            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;
-    }
-}

package/lib/lambda-event-handler/cron-epsilon-lambda-event-handler.spec.js

@@ -1,50 +0,0 @@
-import { BackgroundHandler } from '../background/background-handler.js';
-import { JestRatchet } from '@bitblit/ratchet-jest/lib/jest/jest-ratchet.js';
-import { CronEpsilonLambdaEventHandler } from './cron-epsilon-lambda-event-handler.js';
-import { SingleThreadLocalBackgroundManager } from '../background/manager/single-thread-local-background-manager.js';
-import { jest } from '@jest/globals';
-describe('#cronEpsilonLambdaEventHandler', function () {
-    let mockSqs;
-    let mockSns;
-    beforeEach(() => {
-        mockSqs = JestRatchet.mock(jest.fn);
-        mockSns = JestRatchet.mock(jest.fn);
-    });
-    xit('should verify that cron data functions get executed', async () => {
-        const evt = {
-            id: '1',
-            version: '1',
-            account: 'test',
-            time: 'test',
-            region: '',
-            resources: ['test'],
-            source: null,
-            detail: {},
-            'detail-type': null,
-        };
-        const cronConfig = {
-            timezone: 'America/Los_Angeles',
-            context: 'Test',
-            entries: [
-                {
-                    backgroundTaskType: 'test',
-                    fireImmediate: true,
-                    data: () => {
-                        return { curDate: new Date().toISOString(), fixed: 'abc' };
-                    },
-                },
-            ],
-        };
-        const smConfig = {
-            processors: [],
-            httpSubmissionPath: '/background/',
-            implyTypeFromPathSuffix: true,
-            httpMetaEndpoint: '/background-meta',
-        };
-        const background = new BackgroundHandler(null, null);
-        background.getConfig = jest.fn(() => smConfig);
-        const backgroundManager = new SingleThreadLocalBackgroundManager();
-        const res = await CronEpsilonLambdaEventHandler.processCronEvent(evt, cronConfig, backgroundManager, background);
-        expect(res).toBeTruthy();
-    }, 500);
-});

package/lib/lambda-event-handler/dynamo-epsilon-lambda-event-handler.js

@@ -1,33 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { AwsUtil } from '../util/aws-util.js';
-import { LambdaEventDetector } from '@bitblit/ratchet-aws/lib/lambda/lambda-event-detector.js';
-export class DynamoEpsilonLambdaEventHandler {
-    _epsilon;
-    constructor(_epsilon) {
-        this._epsilon = _epsilon;
-    }
-    extractLabel(evt, context) {
-        return 'DDBEvt:' + evt.Records[0].eventName + ':' + evt.Records[0].eventSource;
-    }
-    handlesEvent(evt) {
-        return LambdaEventDetector.isValidDynamoDBEvent(evt);
-    }
-    async processEvent(evt, context) {
-        let rval = null;
-        if (this._epsilon.config && this._epsilon.config.dynamoDb && evt && evt.Records && evt.Records.length > 0) {
-            const finder = evt.Records[0].eventSourceARN;
-            const handler = AwsUtil.findInMap(finder, this._epsilon.config.dynamoDb.handlers);
-            if (handler) {
-                rval = await handler(evt);
-            }
-            else {
-                Logger.info('Found no Dynamo handler for : %s', finder);
-            }
-        }
-        return rval;
-    }
-    async processUncaughtError(event, context, err) {
-        Logger.error('Error slipped out to outer edge (Dynamo).  Logging and rethrowing : %s', err, err);
-        throw err;
-    }
-}

package/lib/lambda-event-handler/generic-sns-epsilon-lambda-event-handler.js

@@ -1,29 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { AwsUtil } from '../util/aws-util.js';
-import { LambdaEventDetector } from '@bitblit/ratchet-aws/lib/lambda/lambda-event-detector.js';
-export class GenericSnsEpsilonLambdaEventHandler {
-    _epsilon;
-    constructor(_epsilon) {
-        this._epsilon = _epsilon;
-    }
-    extractLabel(evt, context) {
-        return 'SNSEvt:' + evt.Records[0].EventSource;
-    }
-    handlesEvent(evt) {
-        return LambdaEventDetector.isValidSnsEvent(evt);
-    }
-    async processEvent(evt, context) {
-        let rval = null;
-        if (this._epsilon.config && this._epsilon.config.sns && evt && evt.Records.length > 0) {
-            const finder = evt.Records[0].Sns.TopicArn;
-            const handler = AwsUtil.findInMap(finder, this._epsilon.config.sns.handlers);
-            if (handler) {
-                rval = await handler(evt);
-            }
-            else {
-                Logger.info('Found no SNS handler for : %s', finder);
-            }
-        }
-        return rval;
-    }
-}

package/lib/lambda-event-handler/inter-api-epsilon-lambda-event-handler.js

@@ -1,23 +0,0 @@
-import { InterApiUtil } from '../inter-api/inter-api-util.js';
-export class InterApiEpsilonLambdaEventHandler {
-    _epsilon;
-    constructor(_epsilon) {
-        this._epsilon = _epsilon;
-    }
-    extractLabel(evt, context) {
-        const ent = InterApiUtil.extractEntryFromEvent(evt);
-        return 'InterApi:' + ent.source + ':' + ent.type;
-    }
-    handlesEvent(evt) {
-        return this._epsilon.config.interApiConfig && InterApiUtil.isInterApiSnsEvent(evt);
-    }
-    async processEvent(evt, context) {
-        const tmp = await InterApiUtil.processInterApiEvent(evt, this._epsilon.config.interApiConfig, this._epsilon.backgroundManager);
-        const rval = {
-            statusCode: 200,
-            body: JSON.stringify(tmp),
-            isBase64Encoded: false,
-        };
-        return rval;
-    }
-}

package/lib/lambda-event-handler/s3-epsilon-lambda-event-handler.js

@@ -1,41 +0,0 @@
-import { Logger } from '@bitblit/ratchet-common/lib/logger/logger.js';
-import { AwsUtil } from '../util/aws-util.js';
-import { LambdaEventDetector } from '@bitblit/ratchet-aws/lib/lambda/lambda-event-detector.js';
-export class S3EpsilonLambdaEventHandler {
-    _epsilon;
-    constructor(_epsilon) {
-        this._epsilon = _epsilon;
-    }
-    extractLabel(evt, context) {
-        return 'S3Evt:' + evt.Records[0].eventSource;
-    }
-    handlesEvent(evt) {
-        return LambdaEventDetector.isValidS3Event(evt);
-    }
-    async processEvent(evt, context) {
-        let rval = null;
-        if (this._epsilon.config && this._epsilon.config.s3 && evt && evt.Records.length > 0) {
-            const finder = evt.Records[0].s3.bucket.name + '/' + evt.Records[0].s3.object.key;
-            const isRemoveEvent = evt.Records[0].eventName && evt.Records[0].eventName.startsWith('ObjectRemoved');
-            if (isRemoveEvent) {
-                const handler = AwsUtil.findInMap(finder, this._epsilon.config.s3.removeHandlers);
-                if (handler) {
-                    rval = await handler(evt);
-                }
-                else {
-                    Logger.info('Found no s3 create handler for : %s', finder);
-                }
-            }
-            else {
-                const handler = AwsUtil.findInMap(finder, this._epsilon.config.s3.createHandlers);
-                if (handler) {
-                    rval = await handler(evt);
-                }
-                else {
-                    Logger.info('Found no s3 remove handler for : %s', finder);
-                }
-            }
-        }
-        return rval;
-    }
-}