quidproquo-actionprocessor-awslambda 0.0.198 → 0.0.200

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

@@ -0,0 +1,39 @@
+import { EventActionType, actionResult, qpqCoreUtils } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+import { parseMultipartFormData } from '../../utils/parseMultipartFormData';
+const getProcessGetRecords = (qpqConfig) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async ({ eventParams: [apiGatewayEvent, context] }) => {
+        // 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: {
+                ...(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 ((qpqWebServerUtils.getHeaderValue('Content-Type', apiGatewayEvent.headers) || '').startsWith('multipart/form-data') && apiGatewayEvent.body) {
+            internalEventRecord.files = await parseMultipartFormData(apiGatewayEvent);
+        }
+        console.log(JSON.stringify(internalEventRecord, null, 2));
+        return actionResult([internalEventRecord]);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.GetRecords]: getProcessGetRecords(qpqConfig),
+    };
+};

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/api/getStorySession.js

@@ -0,0 +1,11 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+const getProcessGetStorySession = (qpqConfig) => {
+    return async ({ qpqEventRecord, eventParams }) => {
+        return actionResult(void 0);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.GetStorySession]: getProcessGetStorySession(qpqConfig),
+    };
+};

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/api/index.js

@@ -0,0 +1,12 @@
+import getAutoRespond from './autoRespond';
+import getGetRecords from './getRecords';
+import getStorySession from './getStorySession';
+import getMatchStory from './matchStory';
+import getTransformResponseResult from './transformResponseResult';
+export const getApiGatewayApiEventEventProcessor = (qpqConfig) => ({
+    ...getStorySession(qpqConfig),
+    ...getGetRecords(qpqConfig),
+    ...getMatchStory(qpqConfig),
+    ...getAutoRespond(qpqConfig),
+    ...getTransformResponseResult(qpqConfig),
+});

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/api/matchStory.js

@@ -0,0 +1,34 @@
+import { ErrorTypeEnum, EventActionType, actionResult, actionResultError } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+import { matchUrl } from '../../../../../awsLambdaUtils';
+const getProcessMatchStory = (qpqConfig) => {
+    const routes = qpqWebServerUtils.getAllRoutes(qpqConfig);
+    return async ({ qpqEventRecord }) => {
+        // 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 = qpqWebServerUtils.sortPathMatchConfigs(routesWithNoOptions);
+        const matchedRoute = sortedRoutes
+            .map((r) => ({
+            match: matchUrl(r.path, qpqEventRecord.path),
+            route: r,
+        }))
+            .find((m) => m.match.didMatch);
+        if (!matchedRoute) {
+            return actionResultError(ErrorTypeEnum.NotFound, `route not found [${qpqEventRecord.path}] - [${qpqWebServerUtils.getHeaderValue('user-agent', qpqEventRecord.headers)}]`);
+        }
+        return 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: qpqWebServerUtils.mergeAllRouteOptions('api', matchedRoute.route, qpqConfig),
+        });
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.MatchStory]: getProcessMatchStory(qpqConfig),
+    };
+};

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/api/transformResponseResult.js

@@ -0,0 +1,56 @@
+import { EventActionType, actionResult, ErrorTypeEnum } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+const ErrorTypeHttpResponseMap = {
+    [ErrorTypeEnum.BadRequest]: 400,
+    [ErrorTypeEnum.Unauthorized]: 401,
+    [ErrorTypeEnum.PaymentRequired]: 402,
+    [ErrorTypeEnum.Forbidden]: 403,
+    [ErrorTypeEnum.NotFound]: 404,
+    [ErrorTypeEnum.TimeOut]: 408,
+    [ErrorTypeEnum.Conflict]: 409,
+    [ErrorTypeEnum.UnsupportedMediaType]: 415,
+    [ErrorTypeEnum.OutOfResources]: 500,
+    [ErrorTypeEnum.GenericError]: 500,
+    [ErrorTypeEnum.NotImplemented]: 501,
+    [ErrorTypeEnum.NoContent]: 204,
+    [ErrorTypeEnum.Invalid]: 422,
+};
+const transformHttpEventHeadersToAPIGatewayProxyResultHeaders = (headers) => {
+    return Object.keys(headers)
+        .filter((header) => !!headers[header])
+        .reduce((acc, header) => ({ ...acc, [header]: headers[header] }), {});
+};
+const getResponseFromErrorResult = (error) => {
+    const statusCode = ErrorTypeHttpResponseMap[error.errorType] || 500;
+    return qpqWebServerUtils.toJsonEventResponse({
+        errorType: error.errorType,
+        errorText: error.errorText,
+    }, statusCode);
+};
+const getProcessTransformResponseResult = (qpqConfig) => {
+    // We might need to JSON.stringify the body.
+    return async ({ eventParams, qpqEventRecordResponses }) => {
+        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 = {
+            ...qpqWebServerUtils.getCorsHeaders(qpqConfig, {}, currentHeaders),
+            ...currentHeaders,
+        };
+        // Transform back to api gateway
+        return actionResult({
+            statusCode: successRecord.status,
+            body: apiGatewayEvent.httpMethod === 'HEAD' || !successRecord.body ? '' : successRecord.body,
+            isBase64Encoded: successRecord.isBase64Encoded,
+            headers: transformHttpEventHeadersToAPIGatewayProxyResultHeaders(headers),
+        });
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.TransformResponseResult]: getProcessTransformResponseResult(qpqConfig),
+    };
+};

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/api/types.js

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

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

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

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

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

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/websocket/autoRespond.js

@@ -0,0 +1,11 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+const getProcessAutoRespond = (qpqConfig) => {
+    return async ({ qpqEventRecord, matchResult }) => {
+        return actionResult(null);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.AutoRespond]: getProcessAutoRespond(qpqConfig),
+    };
+};

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/websocket/getRecords.js

@@ -0,0 +1,27 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+import { WebSocketEventType } from 'quidproquo-webserver';
+const awsToQoqEventTypeMap = {
+    MESSAGE: WebSocketEventType.Message,
+    CONNECT: WebSocketEventType.Connect,
+    DISCONNECT: WebSocketEventType.Disconnect,
+};
+const getProcessGetRecords = (qpqConfig) => {
+    return async ({ eventParams: [websocketEvent, context] }) => {
+        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 actionResult([internalEventRecord]);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.GetRecords]: getProcessGetRecords(qpqConfig),
+    };
+};

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/websocket/getStorySession.js

@@ -0,0 +1,11 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+const getProcessGetStorySession = (qpqConfig) => {
+    return async ({ qpqEventRecord, eventParams }) => {
+        return actionResult(void 0);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.GetStorySession]: getProcessGetStorySession(qpqConfig),
+    };
+};

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/websocket/index.js

@@ -0,0 +1,12 @@
+import getAutoRespond from './autoRespond';
+import getGetRecords from './getRecords';
+import getMatchStory from './matchStory';
+import getTransformResponseResult from './transformResponseResult';
+import getStorySession from './getStorySession';
+export const getApiGatewayWebsocketEventEventProcessor = (qpqConfig) => ({
+    ...getStorySession(qpqConfig),
+    ...getGetRecords(qpqConfig),
+    ...getMatchStory(qpqConfig),
+    ...getAutoRespond(qpqConfig),
+    ...getTransformResponseResult(qpqConfig),
+});

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/websocket/matchStory.js

@@ -0,0 +1,32 @@
+import { ErrorTypeEnum, EventActionType, actionResult, actionResultError } from 'quidproquo-core';
+import { GLOBAL_WEBSOCKET_API_NAME } from './types';
+import { WebSocketEventType, qpqWebServerUtils } from 'quidproquo-webserver';
+const getProcessMatchStory = (qpqConfig) => {
+    const userDirectoryConfig = qpqWebServerUtils.getWebsocketEntryByApiName(GLOBAL_WEBSOCKET_API_NAME, qpqConfig);
+    return async ({ qpqEventRecord }) => {
+        switch (qpqEventRecord.eventType) {
+            case WebSocketEventType.Connect:
+                return actionResult({
+                    src: userDirectoryConfig.eventProcessors.onConnect.src,
+                    runtime: userDirectoryConfig.eventProcessors.onConnect.runtime,
+                });
+            case WebSocketEventType.Disconnect:
+                return actionResult({
+                    src: userDirectoryConfig.eventProcessors.onDisconnect.src,
+                    runtime: userDirectoryConfig.eventProcessors.onDisconnect.runtime,
+                });
+            case WebSocketEventType.Message:
+                return actionResult({
+                    src: userDirectoryConfig.eventProcessors.onMessage.src,
+                    runtime: userDirectoryConfig.eventProcessors.onMessage.runtime,
+                });
+            default:
+                return actionResultError(ErrorTypeEnum.NotFound, `Websocket lambda not implemented for ${qpqEventRecord.eventType}`);
+        }
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.MatchStory]: getProcessMatchStory(qpqConfig),
+    };
+};

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/websocket/transformResponseResult.js

@@ -0,0 +1,18 @@
+import { EventActionType, actionResult, actionResultError } from 'quidproquo-core';
+const getProcessTransformResponseResult = (qpqConfig) => {
+    return async ({ eventParams, qpqEventRecordResponses }) => {
+        const [record] = qpqEventRecordResponses;
+        if (!record.success) {
+            return actionResultError(record.error.errorType, record.error.errorText, record.error.errorStack);
+        }
+        // Transform back to api gateway
+        return actionResult({
+            statusCode: 200,
+        });
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.TransformResponseResult]: getProcessTransformResponseResult(qpqConfig),
+    };
+};

package/lib/esm/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/esm/getActionProcessor/core/event/apiGatwayEvent/websocket/types.js

@@ -0,0 +1,2 @@
+// TODO: Don't use Globals like this
+export const GLOBAL_WEBSOCKET_API_NAME = process.env.websocketApiName;

package/lib/esm/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/esm/getActionProcessor/core/event/cloudFrontOriginRequest/autoRespond.js

@@ -0,0 +1,11 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+const getProcessAutoRespond = (qpqConfig) => {
+    return async () => {
+        return actionResult(null);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.AutoRespond]: getProcessAutoRespond(qpqConfig),
+    };
+};

package/lib/esm/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;

package/lib/esm/getActionProcessor/core/event/cloudFrontOriginRequest/getRecords.js

@@ -0,0 +1,28 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+const getProcessGetRecords = (qpqConfig) => {
+    return async ({ eventParams: [cloudFrontRequestEvent, context] }) => {
+        const records = cloudFrontRequestEvent.Records.map((record) => {
+            const cfRecordRequest = record.cf.request;
+            const headers = Object.keys(cfRecordRequest.headers).reduce((acc, header) => ({ ...acc, [header]: cfRecordRequest.headers[header][0].value }), {});
+            const internalRecord = {
+                domain: qpqWebServerUtils.getBaseDomainName(qpqConfig),
+                body: cfRecordRequest.body,
+                correlation: context.awsRequestId,
+                method: cfRecordRequest.method,
+                path: cfRecordRequest.uri,
+                sourceIp: cfRecordRequest.clientIp,
+                headers: headers,
+                // TODO: query string support
+                query: {},
+            };
+            return internalRecord;
+        });
+        return actionResult(records);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.GetRecords]: getProcessGetRecords(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/cloudFrontOriginRequest/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/esm/getActionProcessor/core/event/cloudFrontOriginRequest/getStorySession.js

@@ -0,0 +1,11 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+const getProcessGetStorySession = (qpqConfig) => {
+    return async ({ qpqEventRecord, eventParams }) => {
+        return actionResult(void 0);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.GetStorySession]: getProcessGetStorySession(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/cloudFrontOriginRequest/index.d.ts

@@ -0,0 +1,8 @@
+import { QPQConfig } from 'quidproquo-core';
+export declare const getCloudFrontOriginRequestEventProcessor: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/TransformResponseResult": import("quidproquo-core").EventTransformResponseResultActionProcessor<import("./types").EventInput, import("quidproquo-webserver").SeoEventResponse, import("aws-lambda").CloudFrontRequestResult>;
+    "@quidproquo-core/event/AutoRespond": import("quidproquo-core").EventAutoRespondActionProcessor<import("./types").InternalEventRecord, import("./types").MatchResult, import("quidproquo-webserver").SeoEventResponse>;
+    "@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/esm/getActionProcessor/core/event/cloudFrontOriginRequest/index.js

@@ -0,0 +1,12 @@
+import getAutoRespond from './autoRespond';
+import getGetRecords from './getRecords';
+import getMatchStory from './matchStory';
+import getTransformResponseResult from './transformResponseResult';
+import getStorySession from './getStorySession';
+export const getCloudFrontOriginRequestEventProcessor = (qpqConfig) => ({
+    ...getStorySession(qpqConfig),
+    ...getGetRecords(qpqConfig),
+    ...getMatchStory(qpqConfig),
+    ...getAutoRespond(qpqConfig),
+    ...getTransformResponseResult(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/event/cloudFrontOriginRequest/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/esm/getActionProcessor/core/event/cloudFrontOriginRequest/matchStory.js

@@ -0,0 +1,32 @@
+import { ErrorTypeEnum, EventActionType, actionResult, actionResultError } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+import { matchUrl } from '../../../../awsLambdaUtils';
+const getProcessMatchStory = (qpqConfig) => {
+    const seoConfigs = qpqWebServerUtils.getAllSeo(qpqConfig);
+    return async ({ qpqEventRecord }) => {
+        // Sort the routes by string length
+        // we don't sort them here for SEO... its the order they are defined.
+        const sortedSeoConfigs = seoConfigs; // qpqWebServerUtils.sortPathMatchConfigs(seoConfigs);
+        // Find the most relevant match
+        const matchedSeoConfig = sortedSeoConfigs
+            .map((r) => ({
+            match: matchUrl(r.path, qpqEventRecord.path),
+            route: r,
+        }))
+            .find((m) => m.match.didMatch);
+        if (!matchedSeoConfig) {
+            return actionResultError(ErrorTypeEnum.NotFound, `seo not found [${qpqEventRecord.path}]`);
+        }
+        return actionResult({
+            src: matchedSeoConfig.route.src,
+            runtime: matchedSeoConfig.route.runtime,
+            runtimeOptions: matchedSeoConfig.match.params || {},
+            config: matchedSeoConfig.route,
+        });
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.MatchStory]: getProcessMatchStory(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/cloudFrontOriginRequest/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("quidproquo-webserver").SeoEventResponse, import("aws-lambda").CloudFrontRequestResult>;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/event/cloudFrontOriginRequest/transformResponseResult.js

@@ -0,0 +1,60 @@
+import { EventActionType, actionResult, ErrorTypeEnum } from 'quidproquo-core';
+const ErrorTypeHttpResponseMap = {
+    [ErrorTypeEnum.BadRequest]: 400,
+    [ErrorTypeEnum.Unauthorized]: 401,
+    [ErrorTypeEnum.PaymentRequired]: 402,
+    [ErrorTypeEnum.Forbidden]: 403,
+    [ErrorTypeEnum.NotFound]: 404,
+    [ErrorTypeEnum.TimeOut]: 408,
+    [ErrorTypeEnum.Conflict]: 409,
+    [ErrorTypeEnum.UnsupportedMediaType]: 415,
+    [ErrorTypeEnum.OutOfResources]: 500,
+    [ErrorTypeEnum.GenericError]: 500,
+    [ErrorTypeEnum.NotImplemented]: 501,
+    [ErrorTypeEnum.NoContent]: 204,
+    [ErrorTypeEnum.Invalid]: 422,
+};
+const transformHttpEventHeadersToAPIGatewayProxyResultHeaders = (headers) => {
+    return Object.keys(headers)
+        .filter((header) => !!headers[header])
+        .reduce((acc, header) => ({ ...acc, [header]: headers[header] }), {});
+};
+const getResponseFromErrorResult = (error) => {
+    const statusCode = ErrorTypeHttpResponseMap[error.errorType] || 500;
+    return {
+        status: statusCode,
+        body: JSON.stringify({
+            errorType: error.errorType,
+            errorText: error.errorText,
+        }),
+        fallbackToCDN: true,
+    };
+};
+const getProcessTransformResponseResult = (qpqConfig) => {
+    // We might need to JSON.stringify the body.
+    return async ({ eventParams, qpqEventRecordResponses }) => {
+        const [cloudFrontRequestEvent] = eventParams;
+        const [seoEventResponse] = 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 = seoEventResponse.success ? seoEventResponse.result : getResponseFromErrorResult(seoEventResponse.error);
+        if (successRecord.fallbackToCDN) {
+            return actionResult(cloudFrontRequestEvent.Records[0].cf.request);
+        }
+        const headers = successRecord.headers || {};
+        const responseHeaders = Object.keys(headers).reduce((acc, header) => ({ ...acc, [header]: [{ value: headers[header] }] }), {});
+        const result = {
+            status: `${successRecord.status}`,
+            statusDescription: 'OK',
+            body: successRecord.body,
+            headers: responseHeaders,
+            // TODO: Revist this.
+            bodyEncoding: successRecord.bodyEncoding === 'base64' ? 'base64' : 'text',
+        };
+        return actionResult(result);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.TransformResponseResult]: getProcessTransformResponseResult(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/cloudFrontOriginRequest/types.d.ts

@@ -0,0 +1,8 @@
+import { SeoEvent, SeoEventResponse, SeoEventRouteParams, SeoQPQWebServerConfigSetting } from 'quidproquo-webserver';
+import { CloudFrontRequestEvent, Context, CloudFrontRequestResult } from 'aws-lambda';
+import { MatchStoryResult } from 'quidproquo-core';
+export type EventInput = [CloudFrontRequestEvent, Context];
+export type EventOutput = CloudFrontRequestResult;
+export type InternalEventRecord = SeoEvent<any>;
+export type InternalEventOutput = SeoEventResponse;
+export type MatchResult = MatchStoryResult<SeoEventRouteParams, SeoQPQWebServerConfigSetting>;