quidproquo-actionprocessor-awslambda 0.0.199 → 0.0.200

package/lib/esm/getActionProcessor/core/event/lambda/serviceFunction/types.d.ts

@@ -0,0 +1,11 @@
+import { ExecuteServiceFunctionEvent } from 'quidproquo-webserver';
+import { Context } from 'aws-lambda';
+import { EitherActionResult, MatchStoryResult, StorySession } from 'quidproquo-core';
+export type AnyExecuteServiceFunctionEventWithSession = ExecuteServiceFunctionEvent<any[]> & {
+    storySession: StorySession;
+};
+export type EventInput = [AnyExecuteServiceFunctionEventWithSession, Context];
+export type EventOutput = EitherActionResult<any>;
+export type InternalEventRecord = ExecuteServiceFunctionEvent<any[]>;
+export type InternalEventOutput = any;
+export type MatchResult = MatchStoryResult<unknown, unknown>;

package/lib/esm/getActionProcessor/core/event/lambda/serviceFunction/types.js

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

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/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("quidproquo-webserver").StorageDriveEvent, MatchResult, void>;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/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/s3/fileEvent/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("quidproquo-webserver").StorageDriveEvent>;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/getRecords.js

@@ -0,0 +1,22 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+import { StorageDriveEventType } from 'quidproquo-webserver';
+import { GLOBAL_STORAGE_DRIVE_NAME } from './types';
+const getProcessGetRecords = (qpqConfig) => {
+    return async ({ eventParams: [s3Event, context] }) => {
+        const records = s3Event.Records.map((r) => {
+            const internalEventRecord = {
+                driveName: GLOBAL_STORAGE_DRIVE_NAME,
+                // TODO: This only needs to be a single filepath now!
+                filePaths: [decodeURIComponent(r.s3.object.key)],
+                eventType: r.eventName.startsWith('ObjectCreated') ? StorageDriveEventType.Create : StorageDriveEventType.Delete,
+            };
+            return internalEventRecord;
+        });
+        return actionResult(records);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.GetRecords]: getProcessGetRecords(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/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("quidproquo-webserver").StorageDriveEvent>;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/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/s3/fileEvent/index.d.ts

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

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/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 getS3FileEventEventProcessor = (qpqConfig) => ({
+    ...getStorySession(qpqConfig),
+    ...getGetRecords(qpqConfig),
+    ...getMatchStory(qpqConfig),
+    ...getAutoRespond(qpqConfig),
+    ...getTransformResponseResult(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/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("quidproquo-webserver").StorageDriveEvent, MatchResult>;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/matchStory.js

@@ -0,0 +1,12 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+import { GLOBAL_STORAGE_DRIVE_RUNTIME } from './types';
+const getProcessMatchStory = (qpqConfig) => {
+    return async ({ qpqEventRecord }) => {
+        return actionResult(GLOBAL_STORAGE_DRIVE_RUNTIME);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.MatchStory]: getProcessMatchStory(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/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, void, void>;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/transformResponseResult.js

@@ -0,0 +1,17 @@
+import { EventActionType, actionResult, ErrorTypeEnum, actionResultError, } from 'quidproquo-core';
+const getProcessTransformResponseResult = (qpqConfig) => {
+    // We might need to JSON.stringify the body.
+    return async ({ eventParams, qpqEventRecordResponses }) => {
+        const onesThatErrored = qpqEventRecordResponses.filter((r) => !r.success);
+        if (onesThatErrored.length > 0) {
+            return actionResultError(ErrorTypeEnum.GenericError, `[${onesThatErrored.length}] files unable to be processed.`);
+        }
+        // Transform back to api gateway
+        return actionResult(void 0);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.TransformResponseResult]: getProcessTransformResponseResult(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/types.d.ts

@@ -0,0 +1,10 @@
+import { StorageDriveEvent, StorageDriveEventResponse } from 'quidproquo-webserver';
+import { S3Event, Context } from 'aws-lambda';
+import { MatchStoryResult, QpqSourceEntry } from 'quidproquo-core';
+export declare const GLOBAL_STORAGE_DRIVE_NAME: string;
+export declare const GLOBAL_STORAGE_DRIVE_RUNTIME: QpqSourceEntry;
+export type EventInput = [S3Event, Context];
+export type EventOutput = void;
+export type InternalEventRecord = StorageDriveEvent;
+export type InternalEventOutput = StorageDriveEventResponse;
+export type MatchResult = MatchStoryResult<any, any>;

package/lib/esm/getActionProcessor/core/event/s3/fileEvent/types.js

@@ -0,0 +1,3 @@
+// Customs
+export const GLOBAL_STORAGE_DRIVE_NAME = process.env.storageDriveName;
+export const GLOBAL_STORAGE_DRIVE_RUNTIME = JSON.parse(process.env.storageDriveEntry || '{}');

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

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

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

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

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

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

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

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

package/lib/esm/getActionProcessor/core/event/sqs/queue/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, boolean>;
+};
+export default _default;

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

@@ -0,0 +1,24 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+const getProcessGetRecords = (qpqConfig) => {
+    return async ({ eventParams: [sqsEvent, context] }) => {
+        const records = sqsEvent.Records.map((record) => {
+            const parsedInternalEventRecord = JSON.parse(record.body);
+            // TODO: Remove the session from this object
+            //       note: we still need to access the session in the story execution for depth and auth etc.
+            const internalEventRecord = {
+                message: {
+                    type: parsedInternalEventRecord.type || 'AWS_ALARM',
+                    payload: parsedInternalEventRecord.payload || {},
+                },
+                id: record.messageId,
+            };
+            return internalEventRecord;
+        });
+        return actionResult(records);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.GetRecords]: getProcessGetRecords(qpqConfig),
+    };
+};

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

@@ -0,0 +1,17 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+const getProcessGetStorySession = (qpqConfig) => {
+    return async ({ qpqEventRecord, eventParams: [sqsEvent] }) => {
+        // Find the src record and pull out the session from that if we can
+        const srcRecord = sqsEvent.Records.find((r) => r.messageId === qpqEventRecord.id);
+        if (srcRecord) {
+            const parsedInternalEventRecord = JSON.parse(srcRecord.body);
+            return actionResult(parsedInternalEventRecord.storySession);
+        }
+        return actionResult(void 0);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.GetStorySession]: getProcessGetStorySession(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/sqs/queue/index.d.ts

@@ -0,0 +1,8 @@
+import { QPQConfig } from 'quidproquo-core';
+export declare const getSqsQueueEventProcessor: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/event/TransformResponseResult": import("quidproquo-core").EventTransformResponseResultActionProcessor<import("./types").EventInput, boolean, import("aws-lambda").SQSBatchResponse>;
+    "@quidproquo-core/event/AutoRespond": import("quidproquo-core").EventAutoRespondActionProcessor<import("./types").InternalEventRecord, import("./types").MatchResult, boolean>;
+    "@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/sqs/queue/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 getSqsQueueEventProcessor = (qpqConfig) => ({
+    ...getStorySession(qpqConfig),
+    ...getGetRecords(qpqConfig),
+    ...getMatchStory(qpqConfig),
+    ...getAutoRespond(qpqConfig),
+    ...getTransformResponseResult(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/event/sqs/queue/matchStory.d.ts

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

package/lib/esm/getActionProcessor/core/event/sqs/queue/matchStory.js

@@ -0,0 +1,42 @@
+import { ErrorTypeEnum, EventActionType, actionResult, actionResultError, qpqCoreUtils, } from 'quidproquo-core';
+import { matchUrl } from '../../../../../awsLambdaUtils';
+export const getQueueConfigSetting = () => {
+    const queueQPQConfigSetting = JSON.parse(process.env.queueQPQConfigSetting);
+    // TODO: Validate here
+    return queueQPQConfigSetting;
+};
+const getProcessMatchStory = (qpqConfig) => {
+    // TODO: Get this out of the qpqconfig like the other event processors
+    const queueQPQConfigSetting = getQueueConfigSetting();
+    return async ({ qpqEventRecord }) => {
+        const queueQueueProcessors = qpqCoreUtils.getQueueQueueProcessors(queueQPQConfigSetting.name, qpqConfig);
+        const queueTypes = Object.keys(queueQueueProcessors).sort();
+        // Find the most relevant match
+        const matchedQueueType = queueTypes
+            .map((qt) => ({
+            match: matchUrl(qt, qpqEventRecord.message.type),
+            queueType: qt,
+        }))
+            .find((m) => m.match.didMatch);
+        if (!matchedQueueType) {
+            // If we have event bus subscriptions then we don't want to error if we can't match
+            // early exit will just exit gracefully
+            if (queueQPQConfigSetting.eventBusSubscriptions.length > 0) {
+                return actionResult({});
+            }
+            return actionResultError(ErrorTypeEnum.NotFound, `queue type not found ${qpqEventRecord.message.type}`);
+        }
+        const sourceEntry = queueQueueProcessors[matchedQueueType.queueType];
+        return actionResult({
+            src: sourceEntry.src,
+            runtime: sourceEntry.runtime,
+            runtimeOptions: matchedQueueType.match.params || {},
+            config: matchedQueueType.queueType,
+        });
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.MatchStory]: getProcessMatchStory(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/sqs/queue/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, boolean, import("aws-lambda").SQSBatchResponse>;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/event/sqs/queue/transformResponseResult.js

@@ -0,0 +1,24 @@
+import { EventActionType, actionResult } from 'quidproquo-core';
+const getProcessTransformResponseResult = (qpqConfig) => {
+    // We might need to JSON.stringify the body.
+    return async ({ eventParams, qpqEventRecordResponses }) => {
+        const [sqsEvent] = eventParams;
+        const batchItemFailures = qpqEventRecordResponses
+            .filter((record) => !record.success)
+            .map((record, index) => {
+            const batchItemFailure = {
+                itemIdentifier: sqsEvent.Records[index].messageId,
+            };
+            return batchItemFailure;
+        });
+        // Transform back to api gateway
+        return actionResult({
+            batchItemFailures,
+        });
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [EventActionType.TransformResponseResult]: getProcessTransformResponseResult(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/core/event/sqs/queue/types.d.ts

@@ -0,0 +1,12 @@
+import { QueueEventResponse } from 'quidproquo-webserver';
+import { SQSEvent, Context, SQSBatchResponse } from 'aws-lambda';
+import { MatchStoryResult, QueueMessage, StorySession } from 'quidproquo-core';
+import { QueueEvent } from 'quidproquo-webserver';
+export type AnyQueueMessageWithSession = QueueMessage<any> & {
+    storySession: StorySession;
+};
+export type EventInput = [SQSEvent, Context];
+export type EventOutput = SQSBatchResponse;
+export type InternalEventRecord = QueueEvent<QueueMessage<any>>;
+export type InternalEventOutput = QueueEventResponse;
+export type MatchResult = MatchStoryResult<any, any>;

package/lib/esm/getActionProcessor/core/event/sqs/queue/types.js

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

package/lib/esm/getActionProcessor/core/event/utils/isAuthValid.d.ts

@@ -0,0 +1,3 @@
+import { QPQConfig } from 'quidproquo-core';
+import { RouteAuthSettings } from 'quidproquo-webserver';
+export declare const isAuthValid: (qpqConfig: QPQConfig, authHeader?: string | null, apiKeyHeader?: string | null, authSettings?: RouteAuthSettings) => Promise<boolean>;

package/lib/esm/getActionProcessor/core/event/utils/isAuthValid.js

@@ -0,0 +1,54 @@
+import { qpqCoreUtils } from 'quidproquo-core';
+import { verifyJwt } from '../../../../logic/cognito/verifyJwt';
+import { getExportedValue } from '../../../../logic/cloudformation/getExportedValue';
+import { getApiKeys } from '../../../../logic/apiGateway/getApiKeys';
+import { getCFExportNameUserPoolIdFromConfig, getConfigRuntimeResourceName, } from '../../../../awsNamingUtils';
+const isAuthValidForCognito = async (qpqConfig, authSettings, authHeader) => {
+    // If there are no auth settings ~ Its valid.
+    if (!authSettings.userDirectoryName) {
+        return true;
+    }
+    // We need a header to be able to auth
+    if (!authHeader) {
+        return false;
+    }
+    // Make sure we have a Bearer token
+    const [authType, accessToken] = authHeader.split(' ');
+    if (authType !== 'Bearer' || !accessToken) {
+        return false;
+    }
+    // Grab the user directory to auth against
+    const userDirectoryName = authSettings.userDirectoryName;
+    const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+    // Resolve the user pool id
+    const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
+    // Verify the token
+    return await verifyJwt(accessToken, userPoolId, region, false);
+};
+const isAuthValidForApiKeys = async (qpqConfig, authSettings, apiKeyHeader) => {
+    const apiKeys = authSettings.apiKeys || [];
+    if (apiKeys.length === 0) {
+        return true;
+    }
+    const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+    const application = qpqCoreUtils.getApplicationName(qpqConfig);
+    const service = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    const environment = qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig);
+    const feature = qpqCoreUtils.getApplicationModuleFeature(qpqConfig);
+    const realApiKeys = await getApiKeys(region, ...apiKeys.map((apiKey) => {
+        const apiKeyApplication = apiKey.applicationName || application;
+        const apiKeyService = apiKey.serviceName || service;
+        return getConfigRuntimeResourceName(apiKey.name, apiKeyApplication, apiKeyService, environment, feature);
+    }));
+    const index = realApiKeys.findIndex((apiKey) => apiKey.value === apiKeyHeader);
+    return index >= 0;
+};
+export const isAuthValid = async (qpqConfig, authHeader, apiKeyHeader, authSettings) => {
+    // If there are no auth settings ~ Its valid.
+    if (!authSettings) {
+        return true;
+    }
+    const cognitoValid = await isAuthValidForCognito(qpqConfig, authSettings, authHeader);
+    const authKeysValid = await isAuthValidForApiKeys(qpqConfig, authSettings, apiKeyHeader);
+    return cognitoValid && authKeysValid;
+};

package/lib/esm/getActionProcessor/core/event/utils/parseMultipartFormData.d.ts

@@ -0,0 +1,2 @@
+import { QPQBinaryData } from 'quidproquo-core';
+export declare const parseMultipartFormData: (event: import("aws-lambda").APIGatewayProxyEvent) => Promise<QPQBinaryData[]>;

package/lib/esm/getActionProcessor/core/event/utils/parseMultipartFormData.js

@@ -0,0 +1,45 @@
+import Busboy from 'busboy';
+export const parseMultipartFormData = (event) => new Promise((resolve, reject) => {
+    const busboy = Busboy({
+        headers: {
+            'content-type': event.headers['content-type'] || event.headers['Content-Type'],
+        },
+    });
+    const result = {
+        files: [],
+        fields: {},
+    };
+    busboy.on('file', (name, file, info) => {
+        let fileBuffer = Buffer.alloc(0);
+        file.on('data', (data) => {
+            fileBuffer = Buffer.concat([fileBuffer, data]); // Concatenate the new data to the existing buffer
+        });
+        file.on('end', () => {
+            if (fileBuffer.length > 0) {
+                result.files.push({
+                    filename: info.filename,
+                    contentType: info.mimeType,
+                    encoding: info.encoding,
+                    name: name,
+                    content: fileBuffer,
+                });
+            }
+        });
+    });
+    busboy.on('field', (name, value) => {
+        result.fields[name] = value;
+    });
+    busboy.on('error', (error) => {
+        reject(error);
+    });
+    busboy.on('finish', () => {
+        const qpqBinaryFiles = result.files.map((f) => ({
+            filename: f.filename,
+            mimetype: f.contentType,
+            base64Data: f.content.toString('base64'),
+        }));
+        resolve(qpqBinaryFiles);
+    });
+    busboy.write(event.body, event.isBase64Encoded ? 'base64' : 'binary');
+    busboy.end();
+});

package/lib/esm/getActionProcessor/core/eventBus/getQueueSendMessageActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig } from 'quidproquo-core';
+import { EventBusSendMessageActionProcessor } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/EventBus/SendMessage": EventBusSendMessageActionProcessor<any>;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/eventBus/getQueueSendMessageActionProcessor.js

@@ -0,0 +1,28 @@
+import { qpqCoreUtils, actionResultError, ErrorTypeEnum } from 'quidproquo-core';
+import { actionResult, EventBusActionType, } from 'quidproquo-core';
+import { publishMessage } from '../../../logic/sns/publishMessage';
+import { getEventBusSnsTopicArn } from '../../../awsNamingUtils';
+const getProcessEventBusSendMessage = (qpqConfig) => {
+    return async ({ eventBusName, eventBusMessages, context }, session) => {
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const eventBusConfig = qpqCoreUtils.getEventBusConfigByName(eventBusName, qpqConfig);
+        if (!eventBusConfig) {
+            return actionResultError(ErrorTypeEnum.NotFound, `Event bus ${eventBusName} not found`);
+        }
+        const topicArn = getEventBusSnsTopicArn(eventBusConfig.owner?.resourceNameOverride || eventBusName, qpqConfig, eventBusConfig.owner?.module || qpqCoreUtils.getApplicationModuleName(qpqConfig), eventBusConfig.owner?.environment || qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig), eventBusConfig.owner?.application || qpqCoreUtils.getApplicationName(qpqConfig), eventBusConfig.owner?.feature || qpqCoreUtils.getApplicationModuleFeature(qpqConfig));
+        await publishMessage(topicArn, region, eventBusMessages.map((message) => {
+            const eventBusMessageWithSession = {
+                ...message,
+                storySession: {
+                    ...session,
+                    context
+                },
+            };
+            return JSON.stringify(eventBusMessageWithSession);
+        }));
+        return actionResult(void 0);
+    };
+};
+export default (qpqConfig) => ({
+    [EventBusActionType.SendMessages]: getProcessEventBusSendMessage(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/eventBus/index.d.ts

@@ -0,0 +1,5 @@
+import { QPQConfig } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/EventBus/SendMessage": import("quidproquo-core").EventBusSendMessageActionProcessor<any>;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/eventBus/index.js

@@ -0,0 +1,4 @@
+import getQueueSendMessageActionProcessor from './getQueueSendMessageActionProcessor';
+export default (qpqConfig) => ({
+    ...getQueueSendMessageActionProcessor(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/file/getFileDeleteActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig } from 'quidproquo-core';
+import { FileDeleteActionProcessor } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/File/Delete": FileDeleteActionProcessor;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/file/getFileDeleteActionProcessor.js

@@ -0,0 +1,21 @@
+import { qpqCoreUtils } from 'quidproquo-core';
+import { actionResult, FileActionType } from 'quidproquo-core';
+import { deleteFiles } from '../../../logic/s3/s3Utils';
+import { resolveStorageDriveBucketName } from './utils';
+const getProcessFileDelete = (qpqConfig) => {
+    return async ({ drive, filepaths }) => {
+        const s3BucketName = resolveStorageDriveBucketName(drive, qpqConfig);
+        const errored = await deleteFiles(s3BucketName, filepaths, qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig));
+        // errored deletes are a graceful success ~ Retry
+        // if (errored.length > 0) {
+        //   return actionResultError(
+        //     ErrorTypeEnum.GenericError,
+        //     `Could not delete files ${errored.length}`,
+        //   );
+        // }
+        return actionResult(errored);
+    };
+};
+export default (qpqConfig) => ({
+    [FileActionType.Delete]: getProcessFileDelete(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/file/getFileExistsActionProcessor.d.ts

@@ -0,0 +1,5 @@
+import { FileExistsActionProcessor, QPQConfig } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/File/Exists": FileExistsActionProcessor;
+};
+export default _default;

package/lib/esm/getActionProcessor/core/file/getFileExistsActionProcessor.js

@@ -0,0 +1,12 @@
+import { actionResult, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { resolveStorageDriveBucketName } from './utils';
+import { objectExists } from '../../../logic/s3/s3Utils';
+const getProcessFileExists = (qpqConfig) => {
+    return async ({ drive, filepath }) => {
+        const s3BucketName = resolveStorageDriveBucketName(drive, qpqConfig);
+        return actionResult(await objectExists(s3BucketName, filepath, qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig)));
+    };
+};
+export default (qpqConfig) => ({
+    [FileActionType.Exists]: getProcessFileExists(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/file/getFileGenerateTemporarySecureUrlActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig } from 'quidproquo-core';
+import { FileGenerateTemporarySecureUrlActionProcessor } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-core/File/GenerateTemporarySecureUrl": FileGenerateTemporarySecureUrlActionProcessor;
+};
+export default _default;