quidproquo-actionprocessor-awslambda 0.0.38 → 0.0.39

package/lib/awsLambdaUtils.d.ts

@@ -0,0 +1,6 @@
+export declare const randomGuid: () => string;
+export interface UrlMatch {
+    didMatch: boolean;
+    params: Record<string, string> | null;
+}
+export declare const matchUrl: (path: string, url: string) => UrlMatch;

package/lib/awsLambdaUtils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchUrl = exports.randomGuid = void 0;
+const crypto_1 = require("crypto");
+const node_match_path_1 = require("node-match-path");
+const randomGuid = () => {
+    return (0, crypto_1.randomUUID)();
+};
+exports.randomGuid = randomGuid;
+const matchUrl = (path, url) => {
+    // /attempt/{attemptUuid}/result/{test} => /attempt/:attemptUuid/result/:test
+    const modifiedPath = path.replaceAll(/{(.+?)}/g, (m, g) => `:${g}`);
+    const matchResult = (0, node_match_path_1.match)(modifiedPath, url);
+    return {
+        didMatch: matchResult.matches,
+        params: matchResult.params,
+    };
+};
+exports.matchUrl = matchUrl;

package/lib/getActionProcessor/core/config/getConfigGetParameterActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { ConfigGetParameterActionProcessor } from 'quidproquo-core';
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+declare const _default: (runtimeConfig: QPQAWSLambdaConfig) => {
+    "@quidproquo-core/Config/GetParameter": ConfigGetParameterActionProcessor;
+};
+export default _default;

package/lib/getActionProcessor/core/config/getConfigGetParameterActionProcessor.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const quidproquo_core_1 = require("quidproquo-core");
+const qpqAwsLambdaRuntimeConfigUtils_1 = require("../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils");
+const getParameter_1 = require("../../../logic/parametersManager/getParameter");
+const getProcessConfigGetParameter = (runtimeConfig) => {
+    return ({ parameterName }) => __awaiter(void 0, void 0, void 0, function* () {
+        const awsParameterKey = (0, qpqAwsLambdaRuntimeConfigUtils_1.resolveParameterKey)(parameterName, runtimeConfig);
+        const parameterValue = yield (0, getParameter_1.getParameter)(awsParameterKey);
+        return (0, quidproquo_core_1.actionResult)(parameterValue);
+    });
+};
+exports.default = (runtimeConfig) => {
+    return {
+        [quidproquo_core_1.ConfigActionType.GetParameter]: getProcessConfigGetParameter(runtimeConfig),
+    };
+};

package/lib/getActionProcessor/core/config/getConfigGetParametersActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { ConfigGetParametersActionProcessor } from 'quidproquo-core';
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+declare const _default: (runtimeConfig: QPQAWSLambdaConfig) => {
+    "@quidproquo-core/Config/GetParameters": ConfigGetParametersActionProcessor;
+};
+export default _default;

package/lib/getActionProcessor/core/config/getConfigGetParametersActionProcessor.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const quidproquo_core_1 = require("quidproquo-core");
+const qpqAwsLambdaRuntimeConfigUtils_1 = require("../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils");
+const getParameters_1 = require("../../../logic/parametersManager/getParameters");
+const getProcessConfigGetParameters = (runtimeConfig) => {
+    return ({ parameterNames }) => __awaiter(void 0, void 0, void 0, function* () {
+        const awsParameterKeys = parameterNames.map((pn) => (0, qpqAwsLambdaRuntimeConfigUtils_1.resolveParameterKey)(pn, runtimeConfig));
+        const parameterValues = yield (0, getParameters_1.getParameters)(awsParameterKeys);
+        return (0, quidproquo_core_1.actionResult)(parameterValues);
+    });
+};
+exports.default = (runtimeConfig) => {
+    return {
+        [quidproquo_core_1.ConfigActionType.GetParameters]: getProcessConfigGetParameters(runtimeConfig),
+    };
+};

package/lib/getActionProcessor/core/config/getConfigGetSecretActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { ConfigGetSecretActionProcessor } from 'quidproquo-core';
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+declare const _default: (runtimeConfig: QPQAWSLambdaConfig) => {
+    "@quidproquo-core/Config/GetSecret": ConfigGetSecretActionProcessor;
+};
+export default _default;

package/lib/getActionProcessor/core/config/getConfigGetSecretActionProcessor.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const quidproquo_core_1 = require("quidproquo-core");
+const qpqAwsLambdaRuntimeConfigUtils_1 = require("../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils");
+const getSecret_1 = require("../../../logic/secretsManager/getSecret");
+const getProcessConfigActionType = (runtimeConfig) => {
+    return ({ secretName }) => __awaiter(void 0, void 0, void 0, function* () {
+        const awsSecretKey = (0, qpqAwsLambdaRuntimeConfigUtils_1.resolveSecretKey)(secretName, runtimeConfig);
+        const secretValue = yield (0, getSecret_1.getSecret)(awsSecretKey);
+        return (0, quidproquo_core_1.actionResult)(secretValue);
+    });
+};
+exports.default = (runtimeConfig) => {
+    return {
+        [quidproquo_core_1.ConfigActionType.GetSecret]: getProcessConfigActionType(runtimeConfig),
+    };
+};

package/lib/getActionProcessor/core/config/index.d.ts

@@ -0,0 +1,7 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+declare const _default: (runtimeConfig: QPQAWSLambdaConfig) => {
+    "@quidproquo-core/Config/GetSecret": import("quidproquo-core/lib").ConfigGetSecretActionProcessor;
+    "@quidproquo-core/Config/GetParameters": import("quidproquo-core/lib").ConfigGetParametersActionProcessor;
+    "@quidproquo-core/Config/GetParameter": import("quidproquo-core/lib").ConfigGetParameterActionProcessor;
+};
+export default _default;

package/lib/getActionProcessor/core/config/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getConfigGetParameterActionProcessor_1 = __importDefault(require("./getConfigGetParameterActionProcessor"));
+const getConfigGetParametersActionProcessor_1 = __importDefault(require("./getConfigGetParametersActionProcessor"));
+const getConfigGetSecretActionProcessor_1 = __importDefault(require("./getConfigGetSecretActionProcessor"));
+exports.default = (runtimeConfig) => (Object.assign(Object.assign(Object.assign({}, (0, getConfigGetParameterActionProcessor_1.default)(runtimeConfig)), (0, getConfigGetParametersActionProcessor_1.default)(runtimeConfig)), (0, getConfigGetSecretActionProcessor_1.default)(runtimeConfig)));

package/lib/getActionProcessor/core/event/getAPIGatewayEventActionProcessor.d.ts

@@ -0,0 +1,10 @@
+import { QPQConfig, EventMatchStoryActionProcessor, EventTransformEventParamsActionProcessor, EventTransformResponseResultActionProcessor, EventAutoRespondActionProcessor } from 'quidproquo-core';
+import { HTTPEventParams } from 'quidproquo-webserver';
+import { Context, APIGatewayProxyResult } from 'aws-lambda';
+declare const _default: (config: QPQConfig) => {
+    "@quidproquo-core/event/TransformEventParams": EventTransformEventParamsActionProcessor<[import("aws-lambda").APIGatewayProxyEvent, Context], HTTPEventParams<any>>;
+    "@quidproquo-core/event/TransformResponseResult": EventTransformResponseResultActionProcessor<APIGatewayProxyResult>;
+    "@quidproquo-core/event/AutoRespond": EventAutoRespondActionProcessor<HTTPEventParams<any>>;
+    "@quidproquo-core/event/MatchStory": EventMatchStoryActionProcessor<HTTPEventParams<any>>;
+};
+export default _default;

package/lib/getActionProcessor/core/event/getAPIGatewayEventActionProcessor.js

@@ -0,0 +1,95 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const quidproquo_core_1 = require("quidproquo-core");
+const quidproquo_webserver_1 = require("quidproquo-webserver");
+const awsLambdaUtils_1 = require("../../../awsLambdaUtils");
+const getProcessTransformEventParams = (appName) => {
+    return ({ eventParams: [apiGatewayEvent, context] }) => __awaiter(void 0, void 0, void 0, function* () {
+        const path = (apiGatewayEvent.path || '').replace(new RegExp(`^(\/${appName})/`), '/');
+        console.log('getProcessTransformEventParams', JSON.stringify(apiGatewayEvent));
+        return (0, quidproquo_core_1.actionResult)({
+            path,
+            query: Object.assign(Object.assign({}, (apiGatewayEvent.multiValueQueryStringParameters || {})), (apiGatewayEvent.queryStringParameters || {})),
+            body: apiGatewayEvent.body ? JSON.parse(apiGatewayEvent.body) : undefined,
+            headers: apiGatewayEvent.headers,
+            method: apiGatewayEvent.httpMethod,
+            correlation: context.awsRequestId,
+            sourceIp: apiGatewayEvent.requestContext.identity.sourceIp,
+        });
+    });
+};
+const getProcessTransformResponseResult = (configs) => {
+    // We might need to JSON.stringify the body.
+    return (payload) => __awaiter(void 0, void 0, void 0, function* () {
+        // Validate response
+        // if !valid actionResultError
+        console.log('getProcessTransformResponseResult', JSON.stringify(payload));
+        return (0, quidproquo_core_1.actionResult)({
+            statusCode: payload.response.result.statusCode,
+            body: payload.response.result.body,
+            headers: Object.assign(Object.assign({ 'Content-Type': 'application/json' }, quidproquo_webserver_1.qpqWebServerUtils.getCorsHeaders(configs, {}, payload.transformedEventParams.headers)), (payload.response.headers || {})),
+        });
+    });
+};
+const getProcessAutoRespond = (configs) => {
+    return (payload) => __awaiter(void 0, void 0, void 0, function* () {
+        if (payload.transformedEventParams.method === 'OPTIONS') {
+            return (0, quidproquo_core_1.actionResult)({
+                result: {
+                    statusCode: 200,
+                    headers: quidproquo_webserver_1.qpqWebServerUtils.getCorsHeaders(configs, {}, payload.transformedEventParams.headers),
+                },
+            });
+        }
+        return (0, quidproquo_core_1.actionResult)(null);
+    });
+};
+const getProcessMatchStory = (routes) => {
+    return (payload) => __awaiter(void 0, void 0, void 0, function* () {
+        // Sort the routes by string length
+        // Note: We may need to filter variable routes out {} as the variables are length independent
+        const sortedRoutes = routes
+            .filter((r) => r.method === payload.transformedEventParams.method)
+            .sort((a, b) => {
+            if (a.path.length < b.path.length)
+                return -1;
+            if (a.path.length > b.path.length)
+                return 1;
+            return 0;
+        });
+        // Find the most relevant match
+        const matchedRoute = sortedRoutes
+            .map((r) => ({
+            match: (0, awsLambdaUtils_1.matchUrl)(r.path, payload.transformedEventParams.path),
+            route: r,
+        }))
+            .find((m) => m.match.didMatch);
+        if (!matchedRoute) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, 'route not found');
+        }
+        return (0, quidproquo_core_1.actionResult)({
+            src: matchedRoute.route.src,
+            runtime: matchedRoute.route.runtime,
+            options: matchedRoute.match.params || {},
+        });
+    });
+};
+exports.default = (config) => {
+    const routes = quidproquo_webserver_1.qpqWebServerUtils.getAllRoutes(config);
+    const appName = quidproquo_core_1.qpqCoreUtils.getAppName(config);
+    return {
+        [quidproquo_core_1.EventActionType.TransformEventParams]: getProcessTransformEventParams(appName),
+        [quidproquo_core_1.EventActionType.TransformResponseResult]: getProcessTransformResponseResult(config),
+        [quidproquo_core_1.EventActionType.AutoRespond]: getProcessAutoRespond(config),
+        [quidproquo_core_1.EventActionType.MatchStory]: getProcessMatchStory(routes),
+    };
+};

package/lib/getActionProcessor/core/event/getEventBridgeEventActionProcessor.d.ts

@@ -0,0 +1,10 @@
+import { EventMatchStoryActionProcessor, EventTransformEventParamsActionProcessor, EventTransformResponseResultActionProcessor, EventAutoRespondActionProcessor, ScheduledEventParams } from 'quidproquo-core';
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { EventBridgeEvent, Context } from 'aws-lambda';
+declare const _default: (runtimeConfig: QPQAWSLambdaConfig) => {
+    "@quidproquo-core/event/TransformEventParams": EventTransformEventParamsActionProcessor<[EventBridgeEvent<any, any>, Context], ScheduledEventParams<any>>;
+    "@quidproquo-core/event/TransformResponseResult": EventTransformResponseResultActionProcessor<any>;
+    "@quidproquo-core/event/AutoRespond": EventAutoRespondActionProcessor<ScheduledEventParams<any>>;
+    "@quidproquo-core/event/MatchStory": EventMatchStoryActionProcessor<ScheduledEventParams<any>>;
+};
+export default _default;

package/lib/getActionProcessor/core/event/getEventBridgeEventActionProcessor.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const quidproquo_core_1 = require("quidproquo-core");
+const getProcessTransformEventParams = () => {
+    return ({ eventParams: [eventBridgeEvent, context] }) => __awaiter(void 0, void 0, void 0, function* () {
+        return (0, quidproquo_core_1.actionResult)({
+            time: eventBridgeEvent.time,
+            correlation: context.awsRequestId,
+            detail: eventBridgeEvent.detail,
+        });
+    });
+};
+// No transform
+const getProcessTransformResponseResult = () => {
+    return ({ response }) => __awaiter(void 0, void 0, void 0, function* () { return (0, quidproquo_core_1.actionResult)(response); });
+};
+// never early exit (maybe add validation?)
+const getProcessAutoRespond = () => {
+    return () => __awaiter(void 0, void 0, void 0, function* () { return (0, quidproquo_core_1.actionResult)(null); });
+};
+const getProcessMatchStory = (lambdaRuntimeConfig) => {
+    return (payload) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('Trying to match story');
+        console.log(JSON.stringify(lambdaRuntimeConfig));
+        if (!lambdaRuntimeConfig) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, 'event runtime not found');
+        }
+        return (0, quidproquo_core_1.actionResult)({
+            src: lambdaRuntimeConfig.src,
+            runtime: lambdaRuntimeConfig.runtime,
+            options: {},
+        });
+    });
+};
+exports.default = (runtimeConfig) => {
+    return {
+        [quidproquo_core_1.EventActionType.TransformEventParams]: getProcessTransformEventParams(),
+        [quidproquo_core_1.EventActionType.TransformResponseResult]: getProcessTransformResponseResult(),
+        [quidproquo_core_1.EventActionType.AutoRespond]: getProcessAutoRespond(),
+        [quidproquo_core_1.EventActionType.MatchStory]: getProcessMatchStory(runtimeConfig.lambdaRuntimeConfig),
+    };
+};

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const qpqAwsLambdaRuntimeConfigUtils_1 = require("../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils");
+const quidproquo_core_1 = require("quidproquo-core");
+const s3Utils_1 = require("../../../logic/s3/s3Utils");
+const getProcessFileDelete = (runtimeConfig) => {
+    return ({ drive, filepaths }) => __awaiter(void 0, void 0, void 0, function* () {
+        const s3BucketName = (0, qpqAwsLambdaRuntimeConfigUtils_1.resolveResourceName)(drive, runtimeConfig);
+        const errored = yield (0, s3Utils_1.deleteFiles)(s3BucketName, filepaths);
+        // errored deletes are a graceful success ~ Retry
+        // if (errored.length > 0) {
+        //   return actionResultError(
+        //     ErrorTypeEnum.GenericError,
+        //     `Could not delete files ${errored.length}`,
+        //   );
+        // }
+        return (0, quidproquo_core_1.actionResult)(errored);
+    });
+};
+exports.default = (runtimeConfig) => ({
+    [quidproquo_core_1.FileActionType.Delete]: getProcessFileDelete(runtimeConfig),
+});

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const qpqAwsLambdaRuntimeConfigUtils_1 = require("../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils");
+const quidproquo_core_1 = require("quidproquo-core");
+const s3Utils_1 = require("../../../logic/s3/s3Utils");
+const getProcessFileExists = (runtimeConfig) => {
+    return ({ drive, filepath }) => __awaiter(void 0, void 0, void 0, function* () {
+        const s3BucketName = (0, qpqAwsLambdaRuntimeConfigUtils_1.resolveResourceName)(drive, runtimeConfig);
+        return (0, quidproquo_core_1.actionResult)(yield (0, s3Utils_1.objectExists)(s3BucketName, filepath));
+    });
+};
+exports.default = (runtimeConfig) => ({
+    [quidproquo_core_1.FileActionType.Exists]: getProcessFileExists(runtimeConfig),
+});

package/lib/getActionProcessor/core/file/getFileListDirectoryActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { FileListDirectoryActionProcessor } from 'quidproquo-core';
+declare const _default: (runtimeConfig: QPQAWSLambdaConfig) => {
+    "@quidproquo-core/File/ListDirectory": FileListDirectoryActionProcessor;
+};
+export default _default;

package/lib/getActionProcessor/core/file/getFileListDirectoryActionProcessor.js

@@ -0,0 +1,29 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const qpqAwsLambdaRuntimeConfigUtils_1 = require("../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils");
+const quidproquo_core_1 = require("quidproquo-core");
+const s3Utils_1 = require("../../../logic/s3/s3Utils");
+const getProcessFileListDirectory = (runtimeConfig) => {
+    return ({ drive, folderPath, maxFiles, pageToken }) => __awaiter(void 0, void 0, void 0, function* () {
+        const s3BucketName = (0, qpqAwsLambdaRuntimeConfigUtils_1.resolveResourceName)(drive, runtimeConfig);
+        const s3FileList = yield (0, s3Utils_1.listFiles)(s3BucketName, folderPath, maxFiles, pageToken);
+        // Add the drive onto the list
+        const fileInfos = s3FileList.fileInfos.map((s3fi) => (Object.assign(Object.assign({}, s3fi), { drive: drive })));
+        return (0, quidproquo_core_1.actionResult)({
+            fileInfos,
+            pageToken: s3FileList.pageToken,
+        });
+    });
+};
+exports.default = (runtimeConfig) => ({
+    [quidproquo_core_1.FileActionType.ListDirectory]: getProcessFileListDirectory(runtimeConfig),
+});

package/lib/getActionProcessor/core/file/getFileReadTextContentsActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { FileReadTextContentsActionProcessor } from 'quidproquo-core';
+declare const _default: (runtimeConfig: QPQAWSLambdaConfig) => {
+    "@quidproquo-core/File/ReadTextContents": FileReadTextContentsActionProcessor;
+};
+export default _default;

package/lib/getActionProcessor/core/file/getFileReadTextContentsActionProcessor.js

@@ -0,0 +1,23 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const qpqAwsLambdaRuntimeConfigUtils_1 = require("../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils");
+const quidproquo_core_1 = require("quidproquo-core");
+const s3Utils_1 = require("../../../logic/s3/s3Utils");
+const getProcessFileReadTextContents = (runtimeConfig) => {
+    return ({ drive, filepath }) => __awaiter(void 0, void 0, void 0, function* () {
+        const s3BucketName = (0, qpqAwsLambdaRuntimeConfigUtils_1.resolveResourceName)(drive, runtimeConfig);
+        return (0, quidproquo_core_1.actionResult)(yield (0, s3Utils_1.readTextFile)(s3BucketName, filepath));
+    });
+};
+exports.default = (runtimeConfig) => ({
+    [quidproquo_core_1.FileActionType.ReadTextContents]: getProcessFileReadTextContents(runtimeConfig),
+});

package/lib/getActionProcessor/core/file/getFileWriteTextContentsActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+import { FileWriteTextContentsActionProcessor } from 'quidproquo-core';
+declare const _default: (runtimeConfig: QPQAWSLambdaConfig) => {
+    "@quidproquo-core/File/WriteTextContents": FileWriteTextContentsActionProcessor;
+};
+export default _default;

package/lib/getActionProcessor/core/file/getFileWriteTextContentsActionProcessor.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const qpqAwsLambdaRuntimeConfigUtils_1 = require("../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils");
+const quidproquo_core_1 = require("quidproquo-core");
+const s3Utils_1 = require("../../../logic/s3/s3Utils");
+const getProcessFileWriteTextContents = (runtimeConfig) => {
+    return ({ drive, filepath, data }) => __awaiter(void 0, void 0, void 0, function* () {
+        const s3BucketName = (0, qpqAwsLambdaRuntimeConfigUtils_1.resolveResourceName)(drive, runtimeConfig);
+        yield (0, s3Utils_1.writeTextFile)(s3BucketName, filepath, data);
+        return (0, quidproquo_core_1.actionResult)(void 0);
+    });
+};
+exports.default = (runtimeConfig) => ({
+    [quidproquo_core_1.FileActionType.WriteTextContents]: getProcessFileWriteTextContents(runtimeConfig),
+});

package/lib/getActionProcessor/core/file/index.d.ts

@@ -0,0 +1,9 @@
+import { QPQAWSLambdaConfig } from '../../../runtimeConfig/QPQAWSLambdaConfig';
+declare const _default: (runtimeConfig: QPQAWSLambdaConfig) => {
+    "@quidproquo-core/File/WriteTextContents": import("quidproquo-core/lib").FileWriteTextContentsActionProcessor;
+    "@quidproquo-core/File/ReadTextContents": import("quidproquo-core/lib").FileReadTextContentsActionProcessor;
+    "@quidproquo-core/File/ListDirectory": import("quidproquo-core/lib").FileListDirectoryActionProcessor;
+    "@quidproquo-core/File/Exists": import("quidproquo-core/lib").FileExistsActionProcessor;
+    "@quidproquo-core/File/Delete": import("quidproquo-core/lib").FileDeleteActionProcessor;
+};
+export default _default;

package/lib/getActionProcessor/core/file/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getFileDeleteActionProcessor_1 = __importDefault(require("./getFileDeleteActionProcessor"));
+const getFileExistsActionProcessor_1 = __importDefault(require("./getFileExistsActionProcessor"));
+const getFileListDirectoryActionProcessor_1 = __importDefault(require("./getFileListDirectoryActionProcessor"));
+const getFileReadTextContentsActionProcessor_1 = __importDefault(require("./getFileReadTextContentsActionProcessor"));
+const getFileWriteTextContentsActionProcessor_1 = __importDefault(require("./getFileWriteTextContentsActionProcessor"));
+exports.default = (runtimeConfig) => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (0, getFileDeleteActionProcessor_1.default)(runtimeConfig)), (0, getFileExistsActionProcessor_1.default)(runtimeConfig)), (0, getFileListDirectoryActionProcessor_1.default)(runtimeConfig)), (0, getFileReadTextContentsActionProcessor_1.default)(runtimeConfig)), (0, getFileWriteTextContentsActionProcessor_1.default)(runtimeConfig)));

package/lib/getActionProcessor/core/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileActionProcessor = exports.getSystemActionProcessor = exports.getEventBridgeEventActionProcessor = exports.getAPIGatewayEventActionProcessor = exports.getConfigGetParametersActionProcessor = exports.getConfigGetParameterActionProcessor = exports.getConfigGetSecretActionProcessor = void 0;
+var getConfigGetSecretActionProcessor_1 = require("./config/getConfigGetSecretActionProcessor");
+Object.defineProperty(exports, "getConfigGetSecretActionProcessor", { enumerable: true, get: function () { return __importDefault(getConfigGetSecretActionProcessor_1).default; } });
+var getConfigGetParameterActionProcessor_1 = require("./config/getConfigGetParameterActionProcessor");
+Object.defineProperty(exports, "getConfigGetParameterActionProcessor", { enumerable: true, get: function () { return __importDefault(getConfigGetParameterActionProcessor_1).default; } });
+var getConfigGetParametersActionProcessor_1 = require("./config/getConfigGetParametersActionProcessor");
+Object.defineProperty(exports, "getConfigGetParametersActionProcessor", { enumerable: true, get: function () { return __importDefault(getConfigGetParametersActionProcessor_1).default; } });
+var getAPIGatewayEventActionProcessor_1 = require("./event/getAPIGatewayEventActionProcessor");
+Object.defineProperty(exports, "getAPIGatewayEventActionProcessor", { enumerable: true, get: function () { return __importDefault(getAPIGatewayEventActionProcessor_1).default; } });
+var getEventBridgeEventActionProcessor_1 = require("./event/getEventBridgeEventActionProcessor");
+Object.defineProperty(exports, "getEventBridgeEventActionProcessor", { enumerable: true, get: function () { return __importDefault(getEventBridgeEventActionProcessor_1).default; } });
+var system_1 = require("./system");
+Object.defineProperty(exports, "getSystemActionProcessor", { enumerable: true, get: function () { return __importDefault(system_1).default; } });
+var file_1 = require("./file");
+Object.defineProperty(exports, "getFileActionProcessor", { enumerable: true, get: function () { return __importDefault(file_1).default; } });

package/lib/getActionProcessor/core/system/getExecuteStoryActionProcessor.d.ts

@@ -0,0 +1,7 @@
+import { SystemExecuteStoryActionProcessor } from 'quidproquo-core';
+import { DynamicModuleLoader } from '../../../types/DynamicLoader';
+export declare const getDateNow: () => string;
+declare const _default: (dynamicModuleLoader: DynamicModuleLoader) => {
+    "@quidproquo-core/System/ExecuteStory": SystemExecuteStoryActionProcessor<any[]>;
+};
+export default _default;

package/lib/getActionProcessor/core/system/getExecuteStoryActionProcessor.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDateNow = void 0;
+const quidproquo_core_1 = require("quidproquo-core");
+const awsLambdaUtils_1 = require("./../../../awsLambdaUtils");
+const getDateNow = () => new Date().toISOString();
+exports.getDateNow = getDateNow;
+const getProcessExecuteStory = (dynamicModuleLoader) => {
+    return (payload, session, actionProcessors) => __awaiter(void 0, void 0, void 0, function* () {
+        let module = yield dynamicModuleLoader(payload.src);
+        if (module === null) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `Module not found [${payload.src}]`);
+        }
+        const story = module[payload.runtime];
+        if (!story) {
+            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.NotFound, `[${payload.runtime}] not found in module [${payload.src}]`);
+        }
+        const logger = (result) => __awaiter(void 0, void 0, void 0, function* () {
+            // return await addResult(service, getDateNow(), payload.params[0][0].path, 'user-route', payload.src, payload.runtime, result);
+        });
+        const resolveStory = (0, quidproquo_core_1.createRuntime)(session, actionProcessors, exports.getDateNow, logger, awsLambdaUtils_1.randomGuid);
+        const storyResult = yield resolveStory(story, payload.params);
+        if (storyResult.error) {
+            return (0, quidproquo_core_1.actionResultError)(storyResult.error.errorType, `story error! in ${payload.src}::${payload.runtime} -> [${storyResult.error.errorText}]`, storyResult.error.errorStack);
+        }
+        return (0, quidproquo_core_1.actionResult)({
+            result: storyResult.result,
+            session: storyResult.session,
+        });
+    });
+};
+exports.default = (dynamicModuleLoader) => {
+    return {
+        [quidproquo_core_1.SystemActionType.ExecuteStory]: getProcessExecuteStory(dynamicModuleLoader),
+    };
+};

package/lib/getActionProcessor/core/system/index.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModuleLoader } from '../../../types/DynamicLoader';
+declare const _default: (dynamicModuleLoader: DynamicModuleLoader) => {
+    "@quidproquo-core/System/ExecuteStory": import("quidproquo-core/lib").SystemExecuteStoryActionProcessor<any[]>;
+};
+export default _default;

package/lib/getActionProcessor/core/system/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getExecuteStoryActionProcessor_1 = __importDefault(require("./getExecuteStoryActionProcessor"));
+exports.default = (dynamicModuleLoader) => (Object.assign({}, (0, getExecuteStoryActionProcessor_1.default)(dynamicModuleLoader)));