@bitblit/ratchet-epsilon-common 4.0.85-alpha

package/dist/es/inter-api/inter-api-util.js

@@ -0,0 +1,58 @@
+import { LambdaEventDetector } from '@bitblit/ratchet-aws';
+import { EpsilonConstants } from '../epsilon-constants';
+import { RequireRatchet } from '@bitblit/ratchet-common';
+import { Logger, StringRatchet } from '@bitblit/ratchet-common';
+import { ContextUtil } from '../util/context-util';
+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/dist/es/inter-api-manager.js

@@ -0,0 +1,63 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { EpsilonConstants } from './epsilon-constants';
+import { InterApiUtil } from './inter-api/inter-api-util';
+import { PublishCommand } from '@aws-sdk/client-sns';
+export class InterApiManager {
+    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/dist/es/lambda-event-handler/cron-epsilon-lambda-event-handler.js

@@ -0,0 +1,72 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { AwsUtil } from '../util/aws-util';
+import { CronUtil } from '../util/cron-util';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws';
+export class CronEpsilonLambdaEventHandler {
+    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/dist/es/lambda-event-handler/dynamo-epsilon-lambda-event-handler.js

@@ -0,0 +1,32 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { AwsUtil } from '../util/aws-util';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws';
+export class DynamoEpsilonLambdaEventHandler {
+    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/dist/es/lambda-event-handler/generic-sns-epsilon-lambda-event-handler.js

@@ -0,0 +1,28 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { AwsUtil } from '../util/aws-util';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws';
+export class GenericSnsEpsilonLambdaEventHandler {
+    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/dist/es/lambda-event-handler/inter-api-epsilon-lambda-event-handler.js

@@ -0,0 +1,22 @@
+import { InterApiUtil } from '../inter-api/inter-api-util';
+export class InterApiEpsilonLambdaEventHandler {
+    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/dist/es/lambda-event-handler/s3-epsilon-lambda-event-handler.js

@@ -0,0 +1,40 @@
+import { Logger } from '@bitblit/ratchet-common';
+import { AwsUtil } from '../util/aws-util';
+import { LambdaEventDetector } from '@bitblit/ratchet-aws';
+export class S3EpsilonLambdaEventHandler {
+    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;
+    }
+}

package/dist/es/local-container-server.js

@@ -0,0 +1,74 @@
+import { Logger, LoggerLevelName, StringRatchet } from '@bitblit/ratchet-common';
+import http from 'http';
+import { EventUtil } from './http/event-util';
+import fetch from 'cross-fetch';
+import { LocalServer } from './local-server';
+import { CliRatchet } from '@bitblit/ratchet-node-only';
+export class LocalContainerServer {
+    constructor(port = 8889) {
+        this.port = port;
+        this.aborted = false;
+    }
+    async runServer() {
+        return new Promise((res, rej) => {
+            try {
+                Logger.info('Starting Epsilon server on port %d', this.port);
+                this.server = http.createServer(this.requestHandler.bind(this)).listen(this.port);
+                Logger.info('Epsilon server is listening');
+                process.on('SIGINT', () => {
+                    Logger.info('Caught SIGINT - shutting down test server...');
+                    this.aborted = true;
+                    res(true);
+                });
+            }
+            catch (err) {
+                Logger.error('Local server failed : %s', err, err);
+                rej(err);
+            }
+        });
+    }
+    async requestHandler(request, response) {
+        const context = {
+            awsRequestId: 'LOCAL-' + StringRatchet.createType4Guid(),
+            getRemainingTimeInMillis() {
+                return 300000;
+            },
+        };
+        const evt = await LocalServer.messageToApiGatewayEvent(request, context);
+        const logEventLevel = EventUtil.eventIsAGraphQLIntrospection(evt) ? LoggerLevelName.silly : LoggerLevelName.info;
+        Logger.logByLevel(logEventLevel, 'Processing event: %j', evt);
+        if (evt.path == '/epsilon-poison-pill') {
+            this.aborted = true;
+            return true;
+        }
+        else {
+            const url = 'http://localhost:8080/2015-03-31/functions/function/invocations';
+            try {
+                const postResp = await fetch(url, { method: 'POST', body: JSON.stringify(evt) });
+                const respBody = await postResp.json();
+                const result = respBody;
+                const written = await LocalServer.writeProxyResultToServerResponse(result, response);
+                return written;
+            }
+            catch (err) {
+                Logger.error('Failed: %s', err);
+                return '{"bad":true}';
+            }
+        }
+    }
+}
+if (CliRatchet.isCalledFromCLISingle('local-container-server')) {
+    Logger.setLevel(LoggerLevelName.debug);
+    Logger.debug('Running local container server');
+    const testServer = new LocalContainerServer();
+    testServer
+        .runServer()
+        .then((res) => {
+        Logger.info('Got res server');
+        process.exit(0);
+    })
+        .catch((err) => {
+        Logger.error('Error : %s', err);
+        process.exit(1);
+    });
+}

package/dist/es/local-server-cert.js

@@ -0,0 +1,67 @@
+export class LocalServerCert {
+}
+LocalServerCert.CLIENT_CSR = '-----BEGIN CERTIFICATE REQUEST-----\n' +
+    'MIICwjCCAaoCAQAwfTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAk5WMRIwEAYDVQQH\n' +
+    'DAlMYXMgVmVnYXMxDjAMBgNVBAoMBVBsdW1hMRkwFwYDVQQDDBB3d3cuaGV5cGx1\n' +
+    'bWEuY29tMSIwIAYJKoZIhvcNAQkBFhNjd2Vpc3NAaGV5cGx1bWEuY29tMIIBIjAN\n' +
+    'BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Gh1SD1VciosMgh3MHF7IyKgNTu2\n' +
+    'DjGMoORJV4VNKzrjp7UOdKnD3so0Xx3A6bUTYAL8Vtc+EG+8LZjUpBIOwuKzzbVo\n' +
+    't16+yt3YXBxzTZPU9g7sFsXx42RoNispIFq0enRtJrq/zq8izZxUZdGn9XD2DidL\n' +
+    'AedtRGjb8cmRuP6wmMRPBOZjct4ZjsSiTyhPa6kpt8V7Pa7vm0HGxcHiDAGp6zoy\n' +
+    'GHfBdsqeBdGbkGT1ZPfs9kpbtXPm82Sckd0p3oY3fJn0rZqpTAb8qcdGcnheYtqX\n' +
+    'FSjX7EoGsIXAK+oj25MvtfoZFMk4rjQ7FkHbgGk0iMHLN0kNjJzN0ysN/wIDAQAB\n' +
+    'oAAwDQYJKoZIhvcNAQELBQADggEBAMbpCdoqmY9crolsh5y9YtYDLRIwisTjTjU1\n' +
+    'Xzp1MurSzGIdHLokU+fdVWTIzn3uOu24yTQouTUUoYWHT4YgN4wELdDydfNxWvyl\n' +
+    'r34QV5B0FZbRV2sNz/3C1UX/Uor4af1Yv+QYlGHspgj+WIAEkNQ3xQIo9+I/miR+\n' +
+    '2VSlydtyGvmzipgv6CAwOsrQsIw7DkpVmnqIjgjPSXlGCgeKM9S1D/CwNwZnVA/e\n' +
+    'DF1SzDkJKl60/n+xZGYl/OtkH9vB8T6fHqk0iMxXuVUxI137fwEJwIQB5L6hFyJa\n' +
+    'L4hbjq7Cull4qOhXDby+fNJT9Ic7VCosJBXBHxHPsEnY2+TZAJo=\n' +
+    '-----END CERTIFICATE REQUEST-----\n';
+LocalServerCert.CLIENT_CERT_PEM = '-----BEGIN CERTIFICATE-----\n' +
+    'MIIDgTCCAmkCFDKASki0c6HD75dCdIZZ3vXq4eQeMA0GCSqGSIb3DQEBCwUAMH0x\n' +
+    'CzAJBgNVBAYTAlVTMQswCQYDVQQIDAJOVjESMBAGA1UEBwwJTGFzIFZlZ2FzMQ4w\n' +
+    'DAYDVQQKDAVQbHVtYTEZMBcGA1UEAwwQd3d3LmhleXBsdW1hLmNvbTEiMCAGCSqG\n' +
+    'SIb3DQEJARYTY3dlaXNzQGhleXBsdW1hLmNvbTAeFw0yMzAxMjMxMDU2MDlaFw0y\n' +
+    'MzAyMjIxMDU2MDlaMH0xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJOVjESMBAGA1UE\n' +
+    'BwwJTGFzIFZlZ2FzMQ4wDAYDVQQKDAVQbHVtYTEZMBcGA1UEAwwQd3d3LmhleXBs\n' +
+    'dW1hLmNvbTEiMCAGCSqGSIb3DQEJARYTY3dlaXNzQGhleXBsdW1hLmNvbTCCASIw\n' +
+    'DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANhodUg9VXIqLDIIdzBxeyMioDU7\n' +
+    'tg4xjKDkSVeFTSs646e1DnSpw97KNF8dwOm1E2AC/FbXPhBvvC2Y1KQSDsLis821\n' +
+    'aLdevsrd2Fwcc02T1PYO7BbF8eNkaDYrKSBatHp0bSa6v86vIs2cVGXRp/Vw9g4n\n' +
+    'SwHnbURo2/HJkbj+sJjETwTmY3LeGY7Eok8oT2upKbfFez2u75tBxsXB4gwBqes6\n' +
+    'Mhh3wXbKngXRm5Bk9WT37PZKW7Vz5vNknJHdKd6GN3yZ9K2aqUwG/KnHRnJ4XmLa\n' +
+    'lxUo1+xKBrCFwCvqI9uTL7X6GRTJOK40OxZB24BpNIjByzdJDYyczdMrDf8CAwEA\n' +
+    'ATANBgkqhkiG9w0BAQsFAAOCAQEAWQG2tvWY+cyeeumD/7WKTBNaBjg4EAe+1mnZ\n' +
+    'KQsg0gGUL0kWsqCkg4xEqIojkKMjs62uS6ballEyWawygYd91OaJLFopNu+Dxk4N\n' +
+    '5GWKpriPr02vI6rMUZNtCmsooukEShr5ufFWb4WLnk4NXQlBCXTHbmIf7Z82UOMw\n' +
+    'ONZdZyKLqlA0Z6SWYBp2gO32puww6dUU0DAKkIIx1SN8i8UKvowRAy13bugPtyau\n' +
+    'NknlE3J1+Gab1hHCMRdKFZPKy8nc7LWUNZhgKdY82IC/k5FSW32Wibfog1TwWRJR\n' +
+    'ceTW4EN4P7ZmdHGMYkIplc7Qcx0mraY2HRqmjA33j3cNcY5UsQ==\n' +
+    '-----END CERTIFICATE-----\n';
+LocalServerCert.CLIENT_KEY_PEM = '-----BEGIN RSA PRIVATE KEY-----\n' +
+    'MIIEogIBAAKCAQEA2Gh1SD1VciosMgh3MHF7IyKgNTu2DjGMoORJV4VNKzrjp7UO\n' +
+    'dKnD3so0Xx3A6bUTYAL8Vtc+EG+8LZjUpBIOwuKzzbVot16+yt3YXBxzTZPU9g7s\n' +
+    'FsXx42RoNispIFq0enRtJrq/zq8izZxUZdGn9XD2DidLAedtRGjb8cmRuP6wmMRP\n' +
+    'BOZjct4ZjsSiTyhPa6kpt8V7Pa7vm0HGxcHiDAGp6zoyGHfBdsqeBdGbkGT1ZPfs\n' +
+    '9kpbtXPm82Sckd0p3oY3fJn0rZqpTAb8qcdGcnheYtqXFSjX7EoGsIXAK+oj25Mv\n' +
+    'tfoZFMk4rjQ7FkHbgGk0iMHLN0kNjJzN0ysN/wIDAQABAoIBAHzZ9yAQUqWk8w6C\n' +
+    'l9EZB4PDzE4p/uS9bXa9fhrCSz0vonv1FzvzXY/BdOmTTuMGlwEDd/XaBHKTJCvi\n' +
+    'SnvF90I0bKu3h4yTWtvLlbG+sD8HlQvInCifVuhr2zu1Nur1qb4kQXzgrRxfKmMZ\n' +
+    'WA/OH2qZGzwbK0kT7ZRUMuCR/EKPjYw9KP6pMF8nxXUjSm+g3YwgIB8kiPeDCV6C\n' +
+    '0/Ecpv5qMqcoYTg9f9KyBNmY3U5ZgbYrdwTDSMrrTwZKSHhTktdF0SEfYrVGLLEU\n' +
+    'vfQQlQmfcc5Z3+cz99BH1BeTNaCPtEaXjgvQYwkWlSxnY6QUE0p1qq9Jy0xaVEx9\n' +
+    '8LReuHECgYEA/hhJ6b2XV1WLtszFO8MRMzlyMuvBc3Ot0dsuJ7r1W3WOF5X7poSU\n' +
+    'xG0xe+n6Kubmi3tGhzS7BN4TEO9/SSE2gIQTk9zwAMuf+mZJQcG0Qz1iftVp5nnM\n' +
+    'zi205vBLLq2Pmk7wbhTIBO8J190Dli1/fuvk/cmJrA60Ys8v3y4e820CgYEA2gfV\n' +
+    'Q3eHRxk3wl4On71mMovY7lMx6+S8K8hBGo26A5FIu6N6v2jxKnQ5YphwFgjtkxgs\n' +
+    'LspAXmxRwFMapZP3d/nFeBhlOzNly7tqIdDOeNqEcUzEx7pwGXpWGZEHOYs1fvU+\n' +
+    'gU/1N8q9DBvr0B+XGeYR3NNdljajo6pwWZ6ed5sCgYAGmkz5ZPLU0yVBR8rsRaJh\n' +
+    'yWFdT2EEhgIDTQXDBImxqblahYw3hIR1Ij1B8g+NI9jj0P1BMC6X7sliDEcreFB5\n' +
+    'QHVdx0T5UFFE6XmH2ue7Q5IWp6cL1ShsRyXHRoE9okb0BI8c3S9haXDBCj44ndAN\n' +
+    'VUXrDlykevFXC/k7fHBTdQKBgHjIshpoEycOD1e753oS4JTL6GdO6271DlFq5LYj\n' +
+    'IZNsXtCkJhH3vvJ35Hp8XEu4snQ0hfV90d79PuS+pRppOETct8pqKVp8hL4ymv8U\n' +
+    'v+0vkQN7NeA3pnZW0W/kag400nP8xJ26f+xiggw9Q4vOlFSioe6loUjgCBNZDlh3\n' +
+    'iO5VAoGASXkcv39B9/8FuWQ7rwhXHEubxOOwZZzSBU1wtLj2qHyPGoeU9ZpsmdrL\n' +
+    'XS9w1Jy0e49qmbBjzTqAEBw2nn/JVMFHyI/s//JVF7Q9GfBZAF5XF6mJ24yzTKgF\n' +
+    'kSoO5T+7s8NXi0eAIBe4CkWCBX7kWEZtu46GuVhsrC3oEazuLOs=\n' +
+    '-----END RSA PRIVATE KEY-----\n';

package/dist/es/local-server.js

@@ -0,0 +1,140 @@
+import { Logger } from '@bitblit/ratchet-common';
+import http from 'http';
+import https from 'https';
+import { StringRatchet } from '@bitblit/ratchet-common';
+import { DateTime } from 'luxon';
+import qs from 'querystring';
+import { EventUtil } from './http/event-util';
+import { LoggerLevelName } from '@bitblit/ratchet-common';
+import { LocalServerCert } from './local-server-cert';
+export class LocalServer {
+    constructor(globalHandler, port = 8888, https = false) {
+        this.globalHandler = globalHandler;
+        this.port = port;
+        this.aborted = false;
+    }
+    async runServer() {
+        return new Promise((res, rej) => {
+            try {
+                Logger.info('Starting Epsilon server on port %d', this.port);
+                if (https) {
+                    const options = {
+                        key: LocalServerCert.CLIENT_KEY_PEM,
+                        cert: LocalServerCert.CLIENT_CERT_PEM,
+                    };
+                    Logger.info('Starting https server - THIS SERVER IS NOT SECURE!  The KEYS are in the code!  Testing Server Only - Use at your own risk!');
+                    this.server = https.createServer(options, this.requestHandler.bind(this)).listen(this.port);
+                }
+                else {
+                    this.server = http.createServer(this.requestHandler.bind(this)).listen(this.port);
+                }
+                Logger.info('Epsilon server is listening');
+                process.on('SIGINT', () => {
+                    Logger.info('Caught SIGINT - shutting down test server...');
+                    this.aborted = true;
+                    res(true);
+                });
+            }
+            catch (err) {
+                Logger.error('Local server failed : %s', err, err);
+                rej(err);
+            }
+        });
+    }
+    async requestHandler(request, response) {
+        const context = {
+            awsRequestId: 'LOCAL-' + StringRatchet.createType4Guid(),
+            getRemainingTimeInMillis() {
+                return 300000;
+            },
+        };
+        const evt = await LocalServer.messageToApiGatewayEvent(request, context);
+        const logEventLevel = EventUtil.eventIsAGraphQLIntrospection(evt) ? LoggerLevelName.silly : LoggerLevelName.info;
+        if (evt.path == '/epsilon-poison-pill') {
+            this.aborted = true;
+            return true;
+        }
+        else {
+            const result = await this.globalHandler.lambdaHandler(evt, context);
+            const written = await LocalServer.writeProxyResultToServerResponse(result, response);
+            return written;
+        }
+    }
+    static async bodyAsBase64String(request) {
+        return new Promise((res, rej) => {
+            const body = [];
+            request.on('data', (chunk) => {
+                body.push(chunk);
+            });
+            request.on('end', () => {
+                const rval = Buffer.concat(body).toString('base64');
+                res(rval);
+            });
+        });
+    }
+    static async messageToApiGatewayEvent(request, context) {
+        const bodyString = await LocalServer.bodyAsBase64String(request);
+        const stageIdx = request.url.indexOf('/', 1);
+        const stage = request.url.substring(1, stageIdx);
+        const path = request.url.substring(stageIdx + 1);
+        const reqTime = new Date().getTime();
+        const formattedTime = DateTime.utc().toFormat('dd/MMM/yyyy:hh:mm:ss ZZ');
+        const queryIdx = request.url.indexOf('?');
+        const queryStringParams = queryIdx > -1 ? qs.parse(request.url.substring(queryIdx + 1)) : {};
+        const headers = Object.assign({}, request.headers);
+        headers['X-Forwarded-Proto'] = 'http';
+        const rval = {
+            body: bodyString,
+            multiValueHeaders: {},
+            multiValueQueryStringParameters: {},
+            resource: '/{proxy+}',
+            path: request.url,
+            httpMethod: request.method.toLowerCase(),
+            isBase64Encoded: true,
+            queryStringParameters: queryStringParams,
+            pathParameters: {
+                proxy: path,
+            },
+            stageVariables: {
+                baz: 'qux',
+            },
+            headers: headers,
+            requestContext: {
+                accountId: '123456789012',
+                resourceId: '123456',
+                stage: stage,
+                requestId: context.awsRequestId,
+                requestTime: formattedTime,
+                requestTimeEpoch: reqTime,
+                identity: null,
+                path: request.url,
+                domainName: request.headers['host'],
+                resourcePath: '/{proxy+}',
+                httpMethod: request.method.toLowerCase(),
+                apiId: '1234567890',
+                protocol: 'HTTP/1.1',
+            },
+        };
+        return rval;
+    }
+    static async writeProxyResultToServerResponse(proxyResult, response) {
+        const isGraphQLSchemaResponse = !!proxyResult && !!proxyResult.body && proxyResult.body.indexOf('{"data":{"__schema"') > -1;
+        if (!isGraphQLSchemaResponse) {
+            Logger.debug('Result: %j', proxyResult);
+        }
+        response.statusCode = proxyResult.statusCode;
+        if (proxyResult.headers) {
+            Object.keys(proxyResult.headers).forEach((hk) => {
+                response.setHeader(hk, String(proxyResult.headers[hk]));
+            });
+        }
+        if (proxyResult.multiValueHeaders) {
+            Object.keys(proxyResult.multiValueHeaders).forEach((hk) => {
+                response.setHeader(hk, proxyResult.multiValueHeaders[hk].join(','));
+            });
+        }
+        const toWrite = proxyResult.isBase64Encoded ? Buffer.from(proxyResult.body, 'base64') : Buffer.from(proxyResult.body);
+        response.end(toWrite);
+        return !!proxyResult.body;
+    }
+}

package/dist/es/open-api-util/open-api-doc-modifications.js

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