quidproquo-actionprocessor-awslambda 0.0.198 → 0.0.199

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/autoRespond.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventAutoRespondActionProcessor } from 'quidproquo-core';
+import { MatchResult } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/AutoRespond": EventAutoRespondActionProcessor<import("./types").AnyHTTPEvent, MatchResult, import("./types").AnyHTTPEventResponse>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/autoRespond.js

@@ -0,0 +1,47 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const isAuthValid_1 = require("../../utils/isAuthValid");
+const getProcessAutoRespond = (qpqConfig) => {
+    return ({ qpqEventRecord, matchResult }) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        // Just auto respond for options requests
+        if (qpqEventRecord.method === 'OPTIONS') {
+            return (0, quidproquo_core_1.actionResult)({
+                status: 200,
+                isBase64Encoded: false,
+                body: '',
+                headers: quidproquo_webserver_1.qpqWebServerUtils.getCorsHeaders(qpqConfig, matchResult.config || {}, qpqEventRecord.headers),
+            });
+        }
+        // TODO: We can pull out the jwt from the session if thats a better way?
+        // Think about that when you dont have covid.
+        const authValid = yield (0, isAuthValid_1.isAuthValid)(qpqConfig, quidproquo_webserver_1.qpqWebServerUtils.getHeaderValue('Authorization', qpqEventRecord.headers), quidproquo_webserver_1.qpqWebServerUtils.getHeaderValue('x-api-key', qpqEventRecord.headers), (_a = matchResult.config) === null || _a === void 0 ? void 0 : _a.routeAuthSettings);
+        if (!authValid) {
+            return (0, quidproquo_core_1.actionResult)({
+                status: 401,
+                isBase64Encoded: false,
+                body: JSON.stringify({
+                    message: 'You are unauthorized to access this resource',
+                }),
+                headers: quidproquo_webserver_1.qpqWebServerUtils.getCorsHeaders(qpqConfig, matchResult.config || {}, qpqEventRecord.headers),
+            });
+        }
+        return (0, quidproquo_core_1.actionResult)(null);
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.AutoRespond]: getProcessAutoRespond(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/getRecords.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventGetRecordsActionProcessor } from 'quidproquo-core';
+import { EventInput } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/Event/GetRecords": EventGetRecordsActionProcessor<EventInput, import("./types").AnyHTTPEvent>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/getRecords.js

@@ -0,0 +1,47 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const parseMultipartFormData_1 = require("../../utils/parseMultipartFormData");
+const getProcessGetRecords = (qpqConfig) => {
+    const serviceName = quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return ({ eventParams: [apiGatewayEvent, context] }) => __awaiter(void 0, void 0, void 0, function* () {
+        // Initialize `path` by removing the service name prefix from `apiGatewayEvent.path`.
+        // This adjustment is necessary because the API gateway routes requests to services based on
+        // a base path that includes the service name. By subtracting `serviceName.length + 1` from the
+        // substring method's start index, we effectively strip the leading `/<serviceName>` segment,
+        // accounting for the leading slash. This ensures `path` reflects the intended resource location
+        // after the service name. Defaults to '/' if `apiGatewayEvent.path` is not provided.
+        const path = (apiGatewayEvent.path || '/').substring(serviceName.length + 1);
+        const internalEventRecord = {
+            path,
+            query: Object.assign(Object.assign({}, (apiGatewayEvent.multiValueQueryStringParameters || {})), (apiGatewayEvent.queryStringParameters || {})),
+            body: apiGatewayEvent.body,
+            headers: apiGatewayEvent.headers,
+            method: apiGatewayEvent.httpMethod,
+            correlation: context.awsRequestId,
+            sourceIp: apiGatewayEvent.requestContext.identity.sourceIp,
+            isBase64Encoded: apiGatewayEvent.isBase64Encoded,
+        };
+        // Transform the body if its a multipart/form-data
+        if ((quidproquo_webserver_1.qpqWebServerUtils.getHeaderValue('Content-Type', apiGatewayEvent.headers) || '').startsWith('multipart/form-data') && apiGatewayEvent.body) {
+            internalEventRecord.files = yield (0, parseMultipartFormData_1.parseMultipartFormData)(apiGatewayEvent);
+        }
+        console.log(JSON.stringify(internalEventRecord, null, 2));
+        return (0, quidproquo_core_1.actionResult)([internalEventRecord]);
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.GetRecords]: getProcessGetRecords(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/getStorySession.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventGetStorySessionActionProcessor } from 'quidproquo-core';
+import { EventInput } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/GetStorySession": EventGetStorySessionActionProcessor<EventInput, import("./types").AnyHTTPEvent>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/getStorySession.js

@@ -0,0 +1,22 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessGetStorySession = (qpqConfig) => {
+    return ({ qpqEventRecord, eventParams }) => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)(void 0);
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.GetStorySession]: getProcessGetStorySession(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/index.d.ts

@@ -0,0 +1,8 @@
+import { QPQConfig } from 'quidproquo-core';
+export declare const getApiGatewayApiEventEventProcessor: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/TransformResponseResult": import("quidproquo-core").EventTransformResponseResultActionProcessor<import("./types").EventInput, import("./types").AnyHTTPEventResponse, import("aws-lambda").APIGatewayProxyResult>;
+    "@quidproquo-core/event/AutoRespond": import("quidproquo-core").EventAutoRespondActionProcessor<import("./types").AnyHTTPEvent, import("./types").MatchResult, import("./types").AnyHTTPEventResponse>;
+    "@quidproquo-core/event/MatchStory": import("quidproquo-core").EventMatchStoryActionProcessor<import("./types").AnyHTTPEvent, import("./types").MatchResult>;
+    "@quidproquo-core/Event/GetRecords": import("quidproquo-core").EventGetRecordsActionProcessor<import("./types").EventInput, import("./types").AnyHTTPEvent>;
+    "@quidproquo-core/event/GetStorySession": import("quidproquo-core").EventGetStorySessionActionProcessor<import("./types").EventInput, import("./types").AnyHTTPEvent>;
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiGatewayApiEventEventProcessor = void 0;
+const autoRespond_1 = __importDefault(require("./autoRespond"));
+const getRecords_1 = __importDefault(require("./getRecords"));
+const getStorySession_1 = __importDefault(require("./getStorySession"));
+const matchStory_1 = __importDefault(require("./matchStory"));
+const transformResponseResult_1 = __importDefault(require("./transformResponseResult"));
+const getApiGatewayApiEventEventProcessor = (qpqConfig) => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (0, getStorySession_1.default)(qpqConfig)), (0, getRecords_1.default)(qpqConfig)), (0, matchStory_1.default)(qpqConfig)), (0, autoRespond_1.default)(qpqConfig)), (0, transformResponseResult_1.default)(qpqConfig)));
+exports.getApiGatewayApiEventEventProcessor = getApiGatewayApiEventEventProcessor;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/matchStory.d.ts

@@ -0,0 +1,6 @@
+import { EventMatchStoryActionProcessor, QPQConfig } from 'quidproquo-core';
+import { MatchResult } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/MatchStory": EventMatchStoryActionProcessor<import("./types").AnyHTTPEvent, MatchResult>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/matchStory.js

@@ -0,0 +1,45 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const awsLambdaUtils_1 = require("../../../../../awsLambdaUtils");
+const getProcessMatchStory = (qpqConfig) => {
+    const routes = quidproquo_webserver_1.qpqWebServerUtils.getAllRoutes(qpqConfig);
+    return ({ qpqEventRecord }) => __awaiter(void 0, void 0, void 0, function* () {
+        // Sort the routes by string length
+        // Note: We may need to filter variable routes out {} as the variables are length independent
+        const routesWithNoOptions = routes.filter((r) => r.method === qpqEventRecord.method || qpqEventRecord.method === 'OPTIONS' || (qpqEventRecord.method === 'HEAD' && r.method === 'GET'));
+        // Find the most relevant match
+        const sortedRoutes = quidproquo_webserver_1.qpqWebServerUtils.sortPathMatchConfigs(routesWithNoOptions);
+        const matchedRoute = sortedRoutes
+            .map((r) => ({
+            match: (0, awsLambdaUtils_1.matchUrl)(r.path, qpqEventRecord.path),
+            route: r,
+        }))
+            .find((m) => m.match.didMatch);
+        if (!matchedRoute) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `route not found [${qpqEventRecord.path}] - [${quidproquo_webserver_1.qpqWebServerUtils.getHeaderValue('user-agent', qpqEventRecord.headers)}]`);
+        }
+        return (0, quidproquo_core_1.actionResult)({
+            src: matchedRoute.route.src,
+            runtime: matchedRoute.route.runtime,
+            runtimeOptions: matchedRoute.match.params || {},
+            // TODO: Make this aware of the API that we are eventing
+            config: quidproquo_webserver_1.qpqWebServerUtils.mergeAllRouteOptions('api', matchedRoute.route, qpqConfig),
+        });
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.MatchStory]: getProcessMatchStory(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/transformResponseResult.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventTransformResponseResultActionProcessor } from 'quidproquo-core';
+import { EventInput } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/TransformResponseResult": EventTransformResponseResultActionProcessor<EventInput, import("./types").AnyHTTPEventResponse, import("aws-lambda").APIGatewayProxyResult>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/transformResponseResult.js

@@ -0,0 +1,64 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const ErrorTypeHttpResponseMap = {
+    [quidproquo_core_1.ErrorTypeEnum.BadRequest]: 400,
+    [quidproquo_core_1.ErrorTypeEnum.Unauthorized]: 401,
+    [quidproquo_core_1.ErrorTypeEnum.PaymentRequired]: 402,
+    [quidproquo_core_1.ErrorTypeEnum.Forbidden]: 403,
+    [quidproquo_core_1.ErrorTypeEnum.NotFound]: 404,
+    [quidproquo_core_1.ErrorTypeEnum.TimeOut]: 408,
+    [quidproquo_core_1.ErrorTypeEnum.Conflict]: 409,
+    [quidproquo_core_1.ErrorTypeEnum.UnsupportedMediaType]: 415,
+    [quidproquo_core_1.ErrorTypeEnum.OutOfResources]: 500,
+    [quidproquo_core_1.ErrorTypeEnum.GenericError]: 500,
+    [quidproquo_core_1.ErrorTypeEnum.NotImplemented]: 501,
+    [quidproquo_core_1.ErrorTypeEnum.NoContent]: 204,
+    [quidproquo_core_1.ErrorTypeEnum.Invalid]: 422,
+};
+const transformHttpEventHeadersToAPIGatewayProxyResultHeaders = (headers) => {
+    return Object.keys(headers)
+        .filter((header) => !!headers[header])
+        .reduce((acc, header) => (Object.assign(Object.assign({}, acc), { [header]: headers[header] })), {});
+};
+const getResponseFromErrorResult = (error) => {
+    const statusCode = ErrorTypeHttpResponseMap[error.errorType] || 500;
+    return quidproquo_webserver_1.qpqWebServerUtils.toJsonEventResponse({
+        errorType: error.errorType,
+        errorText: error.errorText,
+    }, statusCode);
+};
+const getProcessTransformResponseResult = (qpqConfig) => {
+    // We might need to JSON.stringify the body.
+    return ({ eventParams, qpqEventRecordResponses }) => __awaiter(void 0, void 0, void 0, function* () {
+        const [apiGatewayEvent] = eventParams;
+        const [record] = qpqEventRecordResponses;
+        // If we have an error, we need to transform it to a response, otherwise we can just use the record as is
+        const successRecord = record.success ? record.result : getResponseFromErrorResult(record.error);
+        // Add the cors headers
+        const currentHeaders = successRecord.headers || {};
+        const headers = Object.assign(Object.assign({}, quidproquo_webserver_1.qpqWebServerUtils.getCorsHeaders(qpqConfig, {}, currentHeaders)), currentHeaders);
+        // Transform back to api gateway
+        return (0, quidproquo_core_1.actionResult)({
+            statusCode: successRecord.status,
+            body: apiGatewayEvent.httpMethod === 'HEAD' || !successRecord.body ? '' : successRecord.body,
+            isBase64Encoded: successRecord.isBase64Encoded,
+            headers: transformHttpEventHeadersToAPIGatewayProxyResultHeaders(headers),
+        });
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.TransformResponseResult]: getProcessTransformResponseResult(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/types.d.ts

@@ -0,0 +1,10 @@
+import { HTTPEvent, HTTPEventResponse } from 'quidproquo-webserver';
+import { APIGatewayEvent, Context, APIGatewayProxyResult } from 'aws-lambda';
+import { MatchStoryResult } from 'quidproquo-core';
+export type AnyHTTPEvent = HTTPEvent<any>;
+export type AnyHTTPEventResponse = HTTPEventResponse<any>;
+export type EventInput = [APIGatewayEvent, Context];
+export type EventOutput = APIGatewayProxyResult;
+export type InternalEventRecord = AnyHTTPEvent;
+export type InternalEventOutput = AnyHTTPEventResponse;
+export type MatchResult = MatchStoryResult<any, any>;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/index.d.ts

@@ -0,0 +1,2 @@
+export * from './api';
+export * from './websocket';

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./websocket"), exports);

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/autoRespond.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventAutoRespondActionProcessor } from 'quidproquo-core';
+import { InternalEventRecord, MatchResult } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/AutoRespond": EventAutoRespondActionProcessor<InternalEventRecord, MatchResult, void>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/autoRespond.js

@@ -0,0 +1,22 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessAutoRespond = (qpqConfig) => {
+    return ({ qpqEventRecord, matchResult }) => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)(null);
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.AutoRespond]: getProcessAutoRespond(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/getRecords.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventGetRecordsActionProcessor } from 'quidproquo-core';
+import { EventInput, InternalEventRecord } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/Event/GetRecords": EventGetRecordsActionProcessor<EventInput, InternalEventRecord>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/getRecords.js

@@ -0,0 +1,38 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const awsToQoqEventTypeMap = {
+    MESSAGE: quidproquo_webserver_1.WebSocketEventType.Message,
+    CONNECT: quidproquo_webserver_1.WebSocketEventType.Connect,
+    DISCONNECT: quidproquo_webserver_1.WebSocketEventType.Disconnect,
+};
+const getProcessGetRecords = (qpqConfig) => {
+    return ({ eventParams: [websocketEvent, context] }) => __awaiter(void 0, void 0, void 0, function* () {
+        const internalEventRecord = {
+            eventType: awsToQoqEventTypeMap[websocketEvent.requestContext.eventType],
+            messageId: websocketEvent.requestContext.messageId,
+            connectionId: websocketEvent.requestContext.connectionId,
+            requestTimeEpoch: websocketEvent.requestContext.requestTimeEpoch,
+            sourceIp: websocketEvent.requestContext.identity.sourceIp,
+            userAgent: websocketEvent.requestContext.identity.userAgent,
+            requestTime: new Date(websocketEvent.requestContext.requestTimeEpoch).toISOString(),
+            body: websocketEvent.body,
+        };
+        return (0, quidproquo_core_1.actionResult)([internalEventRecord]);
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.GetRecords]: getProcessGetRecords(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/getStorySession.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventGetStorySessionActionProcessor } from 'quidproquo-core';
+import { EventInput, InternalEventRecord } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/GetStorySession": EventGetStorySessionActionProcessor<EventInput, InternalEventRecord>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/getStorySession.js

@@ -0,0 +1,22 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessGetStorySession = (qpqConfig) => {
+    return ({ qpqEventRecord, eventParams }) => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)(void 0);
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.GetStorySession]: getProcessGetStorySession(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/index.d.ts

@@ -0,0 +1,8 @@
+import { QPQConfig } from 'quidproquo-core';
+export declare const getApiGatewayWebsocketEventEventProcessor: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/TransformResponseResult": import("quidproquo-core").EventTransformResponseResultActionProcessor<import("./types").EventInput, void, import("./types").EventOutput>;
+    "@quidproquo-core/event/AutoRespond": import("quidproquo-core").EventAutoRespondActionProcessor<import("./types").InternalEventRecord, import("./types").MatchResult, void>;
+    "@quidproquo-core/event/MatchStory": import("quidproquo-core").EventMatchStoryActionProcessor<import("./types").InternalEventRecord, import("./types").MatchResult>;
+    "@quidproquo-core/Event/GetRecords": import("quidproquo-core").EventGetRecordsActionProcessor<import("./types").EventInput, import("./types").InternalEventRecord>;
+    "@quidproquo-core/event/GetStorySession": import("quidproquo-core").EventGetStorySessionActionProcessor<import("./types").EventInput, import("./types").InternalEventRecord>;
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiGatewayWebsocketEventEventProcessor = void 0;
+const autoRespond_1 = __importDefault(require("./autoRespond"));
+const getRecords_1 = __importDefault(require("./getRecords"));
+const matchStory_1 = __importDefault(require("./matchStory"));
+const transformResponseResult_1 = __importDefault(require("./transformResponseResult"));
+const getStorySession_1 = __importDefault(require("./getStorySession"));
+const getApiGatewayWebsocketEventEventProcessor = (qpqConfig) => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (0, getStorySession_1.default)(qpqConfig)), (0, getRecords_1.default)(qpqConfig)), (0, matchStory_1.default)(qpqConfig)), (0, autoRespond_1.default)(qpqConfig)), (0, transformResponseResult_1.default)(qpqConfig)));
+exports.getApiGatewayWebsocketEventEventProcessor = getApiGatewayWebsocketEventEventProcessor;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/matchStory.d.ts

@@ -0,0 +1,6 @@
+import { EventMatchStoryActionProcessor, QPQConfig } from 'quidproquo-core';
+import { InternalEventRecord, MatchResult } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/MatchStory": EventMatchStoryActionProcessor<InternalEventRecord, MatchResult>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/matchStory.js

@@ -0,0 +1,43 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const types_1 = require("./types");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const getProcessMatchStory = (qpqConfig) => {
+    const userDirectoryConfig = quidproquo_webserver_1.qpqWebServerUtils.getWebsocketEntryByApiName(types_1.GLOBAL_WEBSOCKET_API_NAME, qpqConfig);
+    return ({ qpqEventRecord }) => __awaiter(void 0, void 0, void 0, function* () {
+        switch (qpqEventRecord.eventType) {
+            case quidproquo_webserver_1.WebSocketEventType.Connect:
+                return (0, quidproquo_core_1.actionResult)({
+                    src: userDirectoryConfig.eventProcessors.onConnect.src,
+                    runtime: userDirectoryConfig.eventProcessors.onConnect.runtime,
+                });
+            case quidproquo_webserver_1.WebSocketEventType.Disconnect:
+                return (0, quidproquo_core_1.actionResult)({
+                    src: userDirectoryConfig.eventProcessors.onDisconnect.src,
+                    runtime: userDirectoryConfig.eventProcessors.onDisconnect.runtime,
+                });
+            case quidproquo_webserver_1.WebSocketEventType.Message:
+                return (0, quidproquo_core_1.actionResult)({
+                    src: userDirectoryConfig.eventProcessors.onMessage.src,
+                    runtime: userDirectoryConfig.eventProcessors.onMessage.runtime,
+                });
+            default:
+                return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `Websocket lambda not implemented for ${qpqEventRecord.eventType}`);
+        }
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.MatchStory]: getProcessMatchStory(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/transformResponseResult.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventTransformResponseResultActionProcessor } from 'quidproquo-core';
+import { EventInput, EventOutput } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/TransformResponseResult": EventTransformResponseResultActionProcessor<EventInput, void, EventOutput>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/transformResponseResult.js

@@ -0,0 +1,29 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessTransformResponseResult = (qpqConfig) => {
+    return ({ eventParams, qpqEventRecordResponses }) => __awaiter(void 0, void 0, void 0, function* () {
+        const [record] = qpqEventRecordResponses;
+        if (!record.success) {
+            return (0, quidproquo_core_1.actionResultError)(record.error.errorType, record.error.errorText, record.error.errorStack);
+        }
+        // Transform back to api gateway
+        return (0, quidproquo_core_1.actionResult)({
+            statusCode: 200,
+        });
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.TransformResponseResult]: getProcessTransformResponseResult(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/types.d.ts

@@ -0,0 +1,16 @@
+import { WebsocketEvent, WebsocketEventResponse } from 'quidproquo-webserver';
+import { APIGatewayEventWebsocketRequestContextV2, APIGatewayProxyWebsocketEventV2WithRequestContext, Context, APIGatewayProxyResultV2 } from 'aws-lambda';
+import { MatchStoryResult } from 'quidproquo-core';
+type ApiGatwayEventWebsocketWithIdentity = APIGatewayProxyWebsocketEventV2WithRequestContext<APIGatewayEventWebsocketRequestContextV2 & {
+    identity: {
+        sourceIp: string;
+        userAgent: string;
+    };
+}>;
+export declare const GLOBAL_WEBSOCKET_API_NAME: string;
+export type EventInput = [ApiGatwayEventWebsocketWithIdentity, Context];
+export type EventOutput = APIGatewayProxyResultV2;
+export type InternalEventRecord = WebsocketEvent<string | Blob | ArrayBuffer>;
+export type InternalEventOutput = WebsocketEventResponse;
+export type MatchResult = MatchStoryResult<any, any>;
+export {};

package/lib/commonjs/getActionProcessor/core/event/apiGatwayEvent/websocket/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLOBAL_WEBSOCKET_API_NAME = void 0;
+// TODO: Don't use Globals like this
+exports.GLOBAL_WEBSOCKET_API_NAME = process.env.websocketApiName;

package/lib/commonjs/getActionProcessor/core/event/cloudFrontOriginRequest/autoRespond.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventAutoRespondActionProcessor } from 'quidproquo-core';
+import { InternalEventRecord, MatchResult } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/AutoRespond": EventAutoRespondActionProcessor<InternalEventRecord, MatchResult, import("quidproquo-webserver").SeoEventResponse>;
+};
+export default _default;

package/lib/commonjs/getActionProcessor/core/event/cloudFrontOriginRequest/autoRespond.js

@@ -0,0 +1,22 @@
+"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 });
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessAutoRespond = (qpqConfig) => {
+    return () => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)(null);
+    });
+};
+exports.default = (qpqConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.AutoRespond]: getProcessAutoRespond(qpqConfig),
+    };
+};

package/lib/commonjs/getActionProcessor/core/event/cloudFrontOriginRequest/getRecords.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig, EventGetRecordsActionProcessor } from 'quidproquo-core';
+import { EventInput, InternalEventRecord } from './types';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/Event/GetRecords": EventGetRecordsActionProcessor<EventInput, InternalEventRecord>;
+};
+export default _default;