quidproquo-actionprocessor-awslambda 0.0.222 → 0.0.224

package/lib/esm/getLambdaEntries.js

@@ -0,0 +1,21 @@
+import path from 'path';
+export const entryNames = [
+    'anyExecuteServiceFunctionEvent_serviceFunction',
+    'apiGatewayEventHandler_redirect',
+    'apiGatewayEventHandler',
+    'apiGatwayEventWebsocketWithIdentity_websocketEvent',
+    'cloudFrontRequestEvent_originRequest',
+    'cloudFrontRequestEvent_viewerRequest',
+    'customMessageTriggerEvent_customMessage',
+    'customMessageTriggerEvent_defineAuthChallenge',
+    'customMessageTriggerEvent_createAuthChallenge',
+    'customMessageTriggerEvent_verifyAuthChallenge',
+    'eventBridgeEvent_recurringSchedule',
+    'eventBridgeEvent_stackDeploy',
+    's3Event_fileEvent',
+    'sqsEvent_queueEvent',
+];
+export const getLambdaEntries = () => entryNames.reduce((acc, name) => ({
+    ...acc,
+    [name]: path.join(__dirname, `./lambdas/${name}`),
+}), {});

package/lib/esm/index.d.ts

@@ -2,7 +2,8 @@ export * from './getActionProcessor';
 export * as awsLambdaUtils from './awsLambdaUtils';
 export * as awsNamingUtils from './awsNamingUtils';
 export * from './runtimeConfig/QPQAWSResourceMap';
-export * from './types';
 export * from './logic/parametersManager/getParameter';
 export * from './logic/parametersManager/getParameters';
 export * from './logic/cache/memoFunc';
+export * from './lambdaHandlers';
+export * from './getLambdaEntries';

package/lib/esm/index.js

@@ -2,7 +2,8 @@ export * from './getActionProcessor';
 export * as awsLambdaUtils from './awsLambdaUtils';
 export * as awsNamingUtils from './awsNamingUtils';
 export * from './runtimeConfig/QPQAWSResourceMap';
-export * from './types';
 export * from './logic/parametersManager/getParameter';
 export * from './logic/parametersManager/getParameters';
 export * from './logic/cache/memoFunc';
+export * from './lambdaHandlers';
+export * from './getLambdaEntries';

package/lib/esm/lambdaHandlers/getAnyExecuteServiceFunctionEvent_serviceFunction.d.ts

@@ -0,0 +1,7 @@
+import { ExecuteServiceFunctionEvent } from 'quidproquo-webserver';
+import { DynamicModuleLoader, QPQConfig, StorySession } from 'quidproquo-core';
+type AnyExecuteServiceFunctionEventWithSession = ExecuteServiceFunctionEvent<any[]> & {
+    storySession: StorySession;
+};
+export declare const getAnyExecuteServiceFunctionEvent_serviceFunction: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: AnyExecuteServiceFunctionEventWithSession, context: import("aws-lambda").Context) => Promise<any>;
+export {};

package/lib/esm/lambdaHandlers/getAnyExecuteServiceFunctionEvent_serviceFunction.js

@@ -0,0 +1,6 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getLambdaServiceFunctionEventProcessor } from '../getActionProcessor';
+export const getAnyExecuteServiceFunctionEvent_serviceFunction = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.SERVICE_FUNCTION_EXE, (event) => {
+    return event.storySession;
+}, getLambdaServiceFunctionEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getApiGatewayEventHandler.d.ts

@@ -0,0 +1,2 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+export declare const getApiGatewayEventHandler: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: import("aws-lambda").APIGatewayProxyEvent, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getApiGatewayEventHandler.js

@@ -0,0 +1,14 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { qpqWebServerUtils } from 'quidproquo-webserver';
+import { getApiGatewayApiEventEventProcessor } from '../getActionProcessor';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+export const getApiGatewayEventHandler = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.API, (event) => {
+    console.log('event', JSON.stringify(event, null, 2));
+    console.log(event);
+    const accessToken = qpqWebServerUtils.getAccessTokenFromHeaders(event.headers);
+    return {
+        depth: 0,
+        accessToken: accessToken,
+        context: {},
+    };
+}, getApiGatewayApiEventEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getApiGatewayEventHandler_redirect.d.ts

@@ -0,0 +1,8 @@
+import { Context } from 'aws-lambda';
+export declare const getApiGatewayEventHandler_redirect: () => (event: import("aws-lambda").APIGatewayProxyEvent, context: Context) => Promise<{
+    statusCode: number;
+    body: string;
+    headers: {
+        Location: string;
+    };
+}>;

package/lib/esm/lambdaHandlers/getApiGatewayEventHandler_redirect.js

@@ -0,0 +1,37 @@
+const apiGatewayEventHandler_redirect = async (event, context) => {
+    console.log('event: ', JSON.stringify(event, null, 2));
+    console.log('process.env: ', JSON.stringify(process.env, null, 2));
+    const redirectConfig = JSON.parse(process.env.redirectConfig);
+    // For direct urls ~ Go straight to the url
+    let redirectUrl = redirectConfig.redirectUrl;
+    // Otherwise it must be a domain redirect
+    if (!redirectConfig.redirectUrl.startsWith('http')) {
+        const environment = JSON.parse(process.env.environment);
+        const featureEnvironment = JSON.parse(process.env.featureEnvironment || '""');
+        let baseDomain = redirectConfig.redirectUrl;
+        if (redirectConfig.addEnvironment && environment !== 'production') {
+            baseDomain = `${environment}.${baseDomain}`;
+        }
+        if (redirectConfig.addFeatureEnvironment && featureEnvironment) {
+            baseDomain = `${featureEnvironment}.${baseDomain}`;
+        }
+        redirectUrl = `https://${baseDomain}${event.path}`;
+    }
+    // Add query parameters if they exist
+    const queryParams = event.queryStringParameters;
+    if (queryParams) {
+        const queryString = Object.entries(queryParams)
+            .filter(([, value]) => value !== undefined) // Filter out undefined values
+            .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+            .join('&');
+        redirectUrl += `?${queryString}`;
+    }
+    return {
+        statusCode: 301,
+        body: '',
+        headers: {
+            Location: redirectUrl,
+        },
+    };
+};
+export const getApiGatewayEventHandler_redirect = () => apiGatewayEventHandler_redirect;

package/lib/esm/lambdaHandlers/getApiGatwayEventWebsocketWithIdentity_websocketEvent.d.ts

@@ -0,0 +1,10 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+import { APIGatewayProxyWebsocketEventV2WithRequestContext, APIGatewayEventWebsocketRequestContextV2 } from 'aws-lambda';
+type ApiGatwayEventWebsocketWithIdentity = APIGatewayProxyWebsocketEventV2WithRequestContext<APIGatewayEventWebsocketRequestContextV2 & {
+    identity: {
+        sourceIp: string;
+        userAgent: string;
+    };
+}>;
+export declare const getApiGatwayEventWebsocketWithIdentity_websocketEvent: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: ApiGatwayEventWebsocketWithIdentity, context: import("aws-lambda").Context) => Promise<any>;
+export {};

package/lib/esm/lambdaHandlers/getApiGatwayEventWebsocketWithIdentity_websocketEvent.js

@@ -0,0 +1,9 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getApiGatewayWebsocketEventEventProcessor } from '../getActionProcessor';
+export const getApiGatwayEventWebsocketWithIdentity_websocketEvent = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.WEBSOCKET_EVENT, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, getApiGatewayWebsocketEventEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getCloudFrontRequestEvent_originRequest.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+import { CloudFrontRequestEvent } from 'aws-lambda';
+export declare const getCloudFrontRequestEvent_originRequest: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: CloudFrontRequestEvent, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getCloudFrontRequestEvent_originRequest.js

@@ -0,0 +1,9 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getCloudFrontOriginRequestEventProcessor } from '../getActionProcessor';
+export const getCloudFrontRequestEvent_originRequest = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.EVENT_SEO_OR, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, getCloudFrontOriginRequestEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getCloudFrontRequestEvent_viewerRequest.d.ts

@@ -0,0 +1,39 @@
+import { CloudFrontRequestEvent, Context } from 'aws-lambda';
+export declare const viewerRequestEventHandler: (event: CloudFrontRequestEvent, context: Context) => Promise<{
+    headers: {
+        "x-qpq-is-bot": {
+            key: string;
+            value: string;
+        }[];
+    };
+    body?: {
+        action: "replace" | "read-only";
+        data: string;
+        encoding: "text" | "base64";
+        readonly inputTruncated: boolean;
+    } | undefined;
+    clientIp: string;
+    method: string;
+    uri: string;
+    querystring: string;
+    origin?: import("aws-lambda").CloudFrontOrigin | undefined;
+}>;
+export declare const getCloudFrontRequestEvent_viewerRequest: () => (event: CloudFrontRequestEvent, context: Context) => Promise<{
+    headers: {
+        "x-qpq-is-bot": {
+            key: string;
+            value: string;
+        }[];
+    };
+    body?: {
+        action: "replace" | "read-only";
+        data: string;
+        encoding: "text" | "base64";
+        readonly inputTruncated: boolean;
+    } | undefined;
+    clientIp: string;
+    method: string;
+    uri: string;
+    querystring: string;
+    origin?: import("aws-lambda").CloudFrontOrigin | undefined;
+}>;

package/lib/esm/lambdaHandlers/getCloudFrontRequestEvent_viewerRequest.js

@@ -0,0 +1,25 @@
+import { qpqHeaderIsBot } from 'quidproquo-webserver';
+export const viewerRequestEventHandler = async (event, context) => {
+    console.log(JSON.stringify(event));
+    const request = event.Records[0].cf.request;
+    const headers = request.headers;
+    const userAgent = headers['user-agent'][0]?.value || 'unknown';
+    // let isBot = userAgent.match(/bot|crawl|spider|slurp|facebot|facebookexternalhit/i);
+    // Bot testing for integrating Prerender ~ you then do what you want inside the app business logic
+    // For more info: https://docs.prerender.io/docs/apache-2
+    let isBot = userAgent.match(/googlebot|bingbot|yandex|baiduspider|facebookexternalhit|twitterbot|rogerbot|linkedinbot|embedly|quora link preview|showyoubot|outbrain|pinterest\/0\.|pinterestbot|slackbot|vkShare|W3C_Validator|whatsapp|redditbot|applebot|flipboard|tumblr|bitlybot|skypeuripreview|nuzzel|discordbot|google page speed|qwantify|bitrix link preview|xing-contenttabreceiver|google-inspectiontool|chrome-lighthouse|telegrambot/i);
+    return {
+        ...request,
+        headers: {
+            ...request.headers,
+            [qpqHeaderIsBot]: [
+                {
+                    key: qpqHeaderIsBot,
+                    value: isBot ? 'true' : 'false',
+                },
+            ],
+        },
+    };
+};
+// Default executor
+export const getCloudFrontRequestEvent_viewerRequest = () => viewerRequestEventHandler;

package/lib/esm/lambdaHandlers/getCustomMessageTriggerEvent_createAuthChallenge.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+import { CustomMessageTriggerEvent } from 'aws-lambda';
+export declare const getCustomMessageTriggerEvent_createAuthChallenge: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: CustomMessageTriggerEvent, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getCustomMessageTriggerEvent_createAuthChallenge.js

@@ -0,0 +1,9 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getCognitoCreateAuthChallengeEventProcessor } from '../getActionProcessor';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+export const getCustomMessageTriggerEvent_createAuthChallenge = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.AUTH_CREATE_AUTH_CHALLENGE, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, getCognitoCreateAuthChallengeEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getCustomMessageTriggerEvent_customMessage.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+import { CustomMessageTriggerEvent } from 'aws-lambda';
+export declare const getCustomMessageTriggerEvent_customMessage: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: CustomMessageTriggerEvent, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getCustomMessageTriggerEvent_customMessage.js

@@ -0,0 +1,9 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getCognitoCustomMessageEventProcessor } from '../getActionProcessor';
+export const getCustomMessageTriggerEvent_customMessage = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.SEND_EMAIL_EVENT, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, getCognitoCustomMessageEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getCustomMessageTriggerEvent_defineAuthChallenge.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+import { CustomMessageTriggerEvent } from 'aws-lambda';
+export declare const getCustomMessageTriggerEvent_defineAuthChallenge: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: CustomMessageTriggerEvent, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getCustomMessageTriggerEvent_defineAuthChallenge.js

@@ -0,0 +1,9 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getCognitoDefineAuthChallengeEventProcessor } from '../getActionProcessor';
+export const getCustomMessageTriggerEvent_defineAuthChallenge = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.AUTH_DEFINE_AUTH_CHALLENGE, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, getCognitoDefineAuthChallengeEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getCustomMessageTriggerEvent_verifyAuthChallenge.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+import { VerifyAuthChallengeResponseTriggerEvent } from 'aws-lambda';
+export declare const getCustomMessageTriggerEvent_verifyAuthChallenge: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: VerifyAuthChallengeResponseTriggerEvent, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getCustomMessageTriggerEvent_verifyAuthChallenge.js

@@ -0,0 +1,9 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getCognitoVerifyAuthChallengeEventProcessor } from '../getActionProcessor';
+export const getCustomMessageTriggerEvent_verifyAuthChallenge = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.AUTH_VERIFY_AUTH_CHALLENGE, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, getCognitoVerifyAuthChallengeEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getEventBridgeEvent_recurringSchedule.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+import { EventBridgeEvent } from 'aws-lambda';
+export declare const getEventBridgeEvent_recurringSchedule: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: EventBridgeEvent<string, void>, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getEventBridgeEvent_recurringSchedule.js

@@ -0,0 +1,11 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getEventBridgeEventActionProcessor } from '../getActionProcessor';
+export const getEventBridgeEvent_recurringSchedule = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.RECURRING_SCHEDULE, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, 
+// TODO: rename this.
+getEventBridgeEventActionProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getEventBridgeEvent_stackDeploy.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+import { EventBridgeEvent } from 'aws-lambda';
+export declare const getEventBridgeEvent_stackDeploy: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: EventBridgeEvent<string, void>, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getEventBridgeEvent_stackDeploy.js

@@ -0,0 +1,9 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getEventBridgeStackDeployEventActionProcessor } from '../getActionProcessor';
+export const getEventBridgeEvent_stackDeploy = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.DEPLOY_EVENT, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, getEventBridgeStackDeployEventActionProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getS3Event_fileEvent.d.ts

@@ -0,0 +1,3 @@
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+import { S3Event } from 'aws-lambda';
+export declare const getS3Event_fileEvent: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: S3Event, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getS3Event_fileEvent.js

@@ -0,0 +1,9 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getS3FileEventEventProcessor } from '../getActionProcessor';
+export const getS3Event_fileEvent = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.STORAGEDRIVE_EVENT, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, getS3FileEventEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/getSqsEvent_queueEvent.d.ts

@@ -0,0 +1,3 @@
+import { SQSEvent } from 'aws-lambda';
+import { DynamicModuleLoader, QPQConfig } from 'quidproquo-core';
+export declare const getSqsEvent_queueEvent: (dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: SQSEvent, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdaHandlers/getSqsEvent_queueEvent.js

@@ -0,0 +1,9 @@
+import { QpqRuntimeType } from 'quidproquo-core';
+import { getQpqLambdaRuntimeForEvent } from './helpers/getQpqLambdaRuntimeForEvent';
+import { getSqsQueueEventProcessor } from '../getActionProcessor';
+export const getSqsEvent_queueEvent = (dynamicModuleLoader, qpqConfig) => getQpqLambdaRuntimeForEvent(QpqRuntimeType.QUEUE_EVENT, (event) => {
+    return {
+        depth: 0,
+        context: {},
+    };
+}, getSqsQueueEventProcessor, dynamicModuleLoader, qpqConfig);

package/lib/esm/lambdaHandlers/helpers/dynamicModuleLoaderWarmer.d.ts

@@ -0,0 +1 @@
+export declare const dynamicModuleLoaderWarmer: () => Promise<void>;

package/lib/esm/lambdaHandlers/helpers/dynamicModuleLoaderWarmer.js

@@ -0,0 +1,3 @@
+export const dynamicModuleLoaderWarmer = async () => {
+    // NOOP
+};

package/lib/esm/lambdaHandlers/helpers/getQpqLambdaRuntimeForEvent.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'aws-lambda';
+import { ActionProcessorListResolver, DynamicModuleLoader, QPQConfig, QpqRuntimeType, StorySession } from 'quidproquo-core';
+export declare const getQpqLambdaRuntimeForEvent: <E extends unknown>(runtimeType: QpqRuntimeType, getStorySession: (event: E) => StorySession, getActionProcessorList: ActionProcessorListResolver, dynamicModuleLoader: DynamicModuleLoader, qpqConfig: QPQConfig) => (event: E, context: Context) => Promise<any>;

package/lib/esm/lambdaHandlers/helpers/getQpqLambdaRuntimeForEvent.js

@@ -0,0 +1,51 @@
+import { dynamicModuleLoaderWarmer } from './dynamicModuleLoaderWarmer';
+import { getLogger } from './logger';
+import { askProcessEvent, createRuntime, } from 'quidproquo-core';
+import { getRuntimeCorrelation } from './getRuntimeCorrelation';
+import { getAwsActionProcessors } from '../../getActionProcessor';
+const isSnsEvent = (event) => {
+    if (event && typeof event === 'object') {
+        const possibleSnsEvent = event;
+        return possibleSnsEvent.Records && Array.isArray(possibleSnsEvent.Records);
+    }
+    return false;
+};
+export const getQpqLambdaRuntimeForEvent = (runtimeType, getStorySession, getActionProcessorList, dynamicModuleLoader, qpqConfig) => {
+    return async (event, context) => {
+        console.log('tick: ', JSON.stringify(event, null, 2));
+        const logger = getLogger(qpqConfig);
+        const resolveStory = createRuntime(qpqConfig, getStorySession(event), async () => ({
+            ...(await getAwsActionProcessors(qpqConfig, dynamicModuleLoader)),
+            ...(await getActionProcessorList(qpqConfig, dynamicModuleLoader)),
+        }), () => new Date().toISOString(), logger, getRuntimeCorrelation(qpqConfig), runtimeType, dynamicModuleLoader);
+        const processEvent = async () => {
+            const result = await resolveStory(askProcessEvent, [event, context]);
+            await logger.waitToFinishWriting();
+            if (result.error) {
+                throw new Error(result.error.errorText);
+            }
+            console.log('Finished, returning: ', result.result);
+            return result.result;
+        };
+        if (isSnsEvent(event)) {
+            // Non warmer records
+            const recordsNoWarm = event.Records.filter((record) => record.EventSource !== 'aws:sns' || JSON.parse(record.Sns.Message).type !== 'QpqLambdaWarmerEvent');
+            // if we have found some warmers - then we need to warm the lambda
+            if (recordsNoWarm.length !== event.Records.length) {
+                console.log('Found SNS warmer');
+                // TODO: Warm qpq things with dynamic functions
+                // federate in dynamic modules
+                await dynamicModuleLoaderWarmer();
+                // Might as well move the logs to permanent storage
+                await logger.moveToPermanentStorage();
+                return 'Warmed up!';
+            }
+            // If we have events that are not warmers, then we should execute them
+            if (recordsNoWarm.length > 0) {
+                console.log('Running other actions');
+                return await processEvent();
+            }
+        }
+        return await processEvent();
+    };
+};

package/lib/esm/lambdaHandlers/helpers/getRuntimeCorrelation.d.ts

@@ -0,0 +1,2 @@
+import { QPQConfig } from 'quidproquo-core';
+export declare const getRuntimeCorrelation: (qpqConfig: QPQConfig) => string;

package/lib/esm/lambdaHandlers/helpers/getRuntimeCorrelation.js

@@ -0,0 +1,6 @@
+import { qpqCoreUtils } from 'quidproquo-core';
+import { randomGuid } from '../../awsLambdaUtils';
+export const getRuntimeCorrelation = (qpqConfig) => {
+    const moduleName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return `${moduleName}::${randomGuid()}`;
+};

package/lib/esm/lambdaHandlers/helpers/logger.d.ts

@@ -0,0 +1,5 @@
+import { StoryResult, QPQConfig, QpqLogger } from 'quidproquo-core';
+export declare const storyLogger: (result: StoryResult<any>, bucketName: string, region: string) => Promise<void>;
+export declare const storyLoggerFs: (result: StoryResult<any>) => Promise<void>;
+export declare const moveLogsToPerminateStorage: (bucketName: string, region: string) => Promise<void>;
+export declare const getLogger: (qpqConfig: QPQConfig) => QpqLogger;

package/lib/esm/lambdaHandlers/helpers/logger.js

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { getConfigRuntimeResourceName } from '../../awsNamingUtils';
+import { qpqCoreUtils } from 'quidproquo-core';
+const tempDirectory = '/tmp/qpqlogs';
+import { getAwsServiceAccountInfoConfig, getAwsServiceAccountInfoByDeploymentInfo } from 'quidproquo-config-aws';
+export const storyLogger = async (result, bucketName, region) => {
+    try {
+        const s3Client = new S3Client({ region });
+        const commandParams = {
+            Key: `${result.correlation}.json`,
+            Bucket: bucketName,
+            Body: JSON.stringify(result),
+            StorageClass: 'INTELLIGENT_TIERING',
+        };
+        await s3Client.send(new PutObjectCommand(commandParams));
+    }
+    catch {
+        console.log(`Failed to log story result to S3 [${result.correlation}]`);
+    }
+};
+export const storyLoggerFs = async (result) => {
+    try {
+        await fs.promises.mkdir(tempDirectory, { recursive: true });
+        const filePath = path.join(tempDirectory, `${result.correlation}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(result));
+        console.log(`Story result logged to temporary file [${filePath}]`);
+    }
+    catch (error) {
+        console.log(`Failed to log story result to temporary file [${result.correlation}]`);
+        console.error(error);
+    }
+};
+export const moveLogsToPerminateStorage = async (bucketName, region) => {
+    try {
+        await fs.promises.mkdir(tempDirectory, { recursive: true });
+        const files = await fs.promises.readdir(tempDirectory);
+        for (const file of files) {
+            const filePath = path.join(tempDirectory, file);
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            const result = JSON.parse(data);
+            await storyLogger(result, bucketName, region);
+            await fs.promises.unlink(filePath);
+            console.log(`Moved log file [${file}] to S3 and deleted from temporary directory`);
+        }
+    }
+    catch (error) {
+        console.error('Failed to move logs to permanent storage');
+        console.error(error);
+    }
+};
+export const getLogger = (qpqConfig) => {
+    const awsSettings = getAwsServiceAccountInfoConfig(qpqConfig);
+    // If we have no log service, just return nothing.
+    if (!awsSettings.logServiceName || awsSettings.disableLogs || process.env.storageDriveName === 'qpq-logs') {
+        return {
+            log: async () => { },
+            waitToFinishWriting: async () => { },
+            moveToPermanentStorage: async () => { },
+        };
+    }
+    const service = awsSettings.logServiceName;
+    const application = qpqCoreUtils.getApplicationName(qpqConfig);
+    const environment = qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig);
+    const feature = qpqCoreUtils.getApplicationModuleFeature(qpqConfig);
+    // Workout the bucket name.
+    const bucketName = getConfigRuntimeResourceName('qpq-logs', application, service, environment, feature);
+    // Where is this bucket?
+    const regionForBucket = getAwsServiceAccountInfoByDeploymentInfo(qpqConfig, service, environment, feature, application).awsRegion;
+    console.log('Bucket for logs: ', bucketName, regionForBucket);
+    const logs = [];
+    return {
+        log: async (result) => {
+            const promise = storyLogger(result, bucketName, regionForBucket).catch((e) => {
+                console.log('Failed to log story result to S3', JSON.stringify(e, null, 2));
+            });
+            logs.push(promise);
+            console.log('Added to logs', logs.length);
+        },
+        waitToFinishWriting: async () => {
+            console.log('logs.length', logs.length);
+            console.time('Writing Logs');
+            await Promise.all(logs);
+            console.timeEnd('Writing Logs');
+            console.log('done writing logs');
+        },
+        moveToPermanentStorage: async () => {
+            await moveLogsToPerminateStorage(bucketName, regionForBucket);
+        },
+    };
+};

package/lib/esm/lambdaHandlers/index.d.ts

@@ -0,0 +1,15 @@
+export * from './types';
+export * from './getAnyExecuteServiceFunctionEvent_serviceFunction';
+export * from './getApiGatewayEventHandler_redirect';
+export * from './getApiGatewayEventHandler';
+export * from './getApiGatwayEventWebsocketWithIdentity_websocketEvent';
+export * from './getCloudFrontRequestEvent_originRequest';
+export * from './getCloudFrontRequestEvent_viewerRequest';
+export * from './getCustomMessageTriggerEvent_createAuthChallenge';
+export * from './getCustomMessageTriggerEvent_customMessage';
+export * from './getCustomMessageTriggerEvent_defineAuthChallenge';
+export * from './getCustomMessageTriggerEvent_verifyAuthChallenge';
+export * from './getEventBridgeEvent_recurringSchedule';
+export * from './getEventBridgeEvent_stackDeploy';
+export * from './getS3Event_fileEvent';
+export * from './getSqsEvent_queueEvent';

package/lib/esm/lambdaHandlers/index.js

@@ -0,0 +1,15 @@
+export * from './types';
+export * from './getAnyExecuteServiceFunctionEvent_serviceFunction';
+export * from './getApiGatewayEventHandler_redirect';
+export * from './getApiGatewayEventHandler';
+export * from './getApiGatwayEventWebsocketWithIdentity_websocketEvent';
+export * from './getCloudFrontRequestEvent_originRequest';
+export * from './getCloudFrontRequestEvent_viewerRequest';
+export * from './getCustomMessageTriggerEvent_createAuthChallenge';
+export * from './getCustomMessageTriggerEvent_customMessage';
+export * from './getCustomMessageTriggerEvent_defineAuthChallenge';
+export * from './getCustomMessageTriggerEvent_verifyAuthChallenge';
+export * from './getEventBridgeEvent_recurringSchedule';
+export * from './getEventBridgeEvent_stackDeploy';
+export * from './getS3Event_fileEvent';
+export * from './getSqsEvent_queueEvent';

package/lib/esm/lambdaHandlers/types/QpqWarmLambdaEvent.d.ts

@@ -0,0 +1,5 @@
+import { SNSEvent } from 'aws-lambda';
+export type QpqWarmLambdaEvent = {
+    qpqWarm: boolean;
+};
+export type QpqFunctionExecutionEvent<T> = SNSEvent | T;

package/lib/esm/lambdaHandlers/types/index.d.ts

@@ -0,0 +1 @@
+export * from './QpqWarmLambdaEvent';

package/lib/esm/lambdaHandlers/types/index.js

@@ -0,0 +1 @@
+export * from './QpqWarmLambdaEvent';

package/lib/esm/lambdas/anyExecuteServiceFunctionEvent_serviceFunction.d.ts

@@ -0,0 +1,3 @@
+export declare const anyExecuteServiceFunctionEvent_serviceFunction: (event: import("quidproquo-webserver").ExecuteServiceFunctionEvent<any[]> & {
+    storySession: import("quidproquo-core").StorySession;
+}, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdas/anyExecuteServiceFunctionEvent_serviceFunction.js

@@ -0,0 +1,4 @@
+import { getQpqConfig } from './lambda-utils';
+import { dynamicModuleLoader } from './dynamicModuleLoader';
+import { getAnyExecuteServiceFunctionEvent_serviceFunction } from '../lambdaHandlers';
+export const anyExecuteServiceFunctionEvent_serviceFunction = getAnyExecuteServiceFunctionEvent_serviceFunction(dynamicModuleLoader, getQpqConfig());

package/lib/esm/lambdas/apiGatewayEventHandler.d.ts

@@ -0,0 +1 @@
+export declare const apiGatewayEventHandler: (event: import("aws-lambda").APIGatewayProxyEvent, context: import("aws-lambda").Context) => Promise<any>;

package/lib/esm/lambdas/apiGatewayEventHandler.js

@@ -0,0 +1,4 @@
+import { getApiGatewayEventHandler } from '../lambdaHandlers';
+import { getQpqConfig } from './lambda-utils';
+import { dynamicModuleLoader } from './dynamicModuleLoader';
+export const apiGatewayEventHandler = getApiGatewayEventHandler(dynamicModuleLoader, getQpqConfig());

package/lib/esm/lambdas/apiGatewayEventHandler_redirect.d.ts

@@ -0,0 +1,7 @@
+export declare const apiGatewayEventHandler_redirect: (event: import("aws-lambda").APIGatewayProxyEvent, context: import("aws-lambda").Context) => Promise<{
+    statusCode: number;
+    body: string;
+    headers: {
+        Location: string;
+    };
+}>;