quidproquo-actionprocessor-awslambda 0.0.198 → 0.0.200

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

@@ -0,0 +1,36 @@
+import getUserDirectoryAuthenticateUserActionProcessor from './getUserDirectoryAuthenticateUserActionProcessor';
+import getUserDirectoryChangePasswordActionProcessor from './getUserDirectoryChangePasswordActionProcessor';
+import getUserDirectoryConfirmEmailVerificationActionProcessor from './getUserDirectoryConfirmEmailVerificationActionProcessor';
+import getUserDirectoryConfirmForgetPasswordActionProcessor from './getUserDirectoryConfirmForgetPasswordActionProcessor';
+import getUserDirectoryCreateUserActionProcessor from './getUserDirectoryCreateUserActionProcessor';
+import getUserDirectoryDecodeAccessTokenActionProcessor from './getUserDirectoryDecodeAccessTokenActionProcessor';
+import getUserDirectoryForgetPasswordActionProcessor from './getUserDirectoryForgetPasswordActionProcessor';
+import getUserDirectoryGetUserAttributesActionProcessor from './getUserDirectoryGetUserAttributesActionProcessor';
+import getUserDirectoryGetUserAttributesByUserIdActionProcessor from './getUserDirectoryGetUserAttributesByUserIdActionProcessor';
+import getUserDirectoryGetUsersActionProcessor from './getUserDirectoryGetUsersActionProcessor';
+import getUserDirectoryReadAccessTokenActionProcessor from './getUserDirectoryReadAccessTokenActionProcessor';
+import getUserDirectoryRefreshTokenActionProcessor from './getUserDirectoryRefreshTokenActionProcessor';
+import getUserDirectoryRequestEmailVerificationActionProcessor from './getUserDirectoryRequestEmailVerificationActionProcessor';
+import getUserDirectoryRespondToAuthChallengeActionProcessor from './getUserDirectoryRespondToAuthChallengeActionProcessor';
+import getUserDirectorySetAccessTokenActionProcessor from './getUserDirectorySetAccessTokenActionProcessor';
+import getUserDirectorySetPasswordActionProcessor from './getUserDirectorySetPasswordActionProcessor';
+import getUserDirectorySetUserAttributesActionProcessor from './getUserDirectorySetUserAttributesActionProcessor';
+export default (qpqConfig) => ({
+    ...getUserDirectoryAuthenticateUserActionProcessor(qpqConfig),
+    ...getUserDirectoryChangePasswordActionProcessor(qpqConfig),
+    ...getUserDirectoryConfirmEmailVerificationActionProcessor(qpqConfig),
+    ...getUserDirectoryConfirmForgetPasswordActionProcessor(qpqConfig),
+    ...getUserDirectoryCreateUserActionProcessor(qpqConfig),
+    ...getUserDirectoryDecodeAccessTokenActionProcessor(qpqConfig),
+    ...getUserDirectoryForgetPasswordActionProcessor(qpqConfig),
+    ...getUserDirectoryGetUserAttributesActionProcessor(qpqConfig),
+    ...getUserDirectoryGetUserAttributesByUserIdActionProcessor(qpqConfig),
+    ...getUserDirectoryGetUsersActionProcessor(qpqConfig),
+    ...getUserDirectoryReadAccessTokenActionProcessor(qpqConfig),
+    ...getUserDirectoryRefreshTokenActionProcessor(qpqConfig),
+    ...getUserDirectoryRequestEmailVerificationActionProcessor(qpqConfig),
+    ...getUserDirectoryRespondToAuthChallengeActionProcessor(qpqConfig),
+    ...getUserDirectorySetAccessTokenActionProcessor(qpqConfig),
+    ...getUserDirectorySetPasswordActionProcessor(qpqConfig),
+    ...getUserDirectorySetUserAttributesActionProcessor(qpqConfig),
+});

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

@@ -0,0 +1,2 @@
+export * from './core';
+export * from './webserver';

package/lib/esm/getActionProcessor/index.js

@@ -0,0 +1,2 @@
+export * from './core';
+export * from './webserver';

package/lib/esm/getActionProcessor/webserver/admin/getAdminActionProcessor.d.ts

@@ -0,0 +1,9 @@
+import { QPQConfig } from 'quidproquo-core';
+import { AdminGetLogsActionProcessor, AdminGetLogActionProcessor, AdminGetLogMetadataChildrenActionProcessor, AdminGetLogMetadataActionProcessor } from 'quidproquo-webserver';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-webserver/Admin/GetLogs": AdminGetLogsActionProcessor;
+    "@quidproquo-webserver/Admin/GetLog": AdminGetLogActionProcessor;
+    "@quidproquo-webserver/Admin/GetLogMetadataChildren": AdminGetLogMetadataChildrenActionProcessor;
+    "@quidproquo-webserver/Admin/GetLogMetadata": AdminGetLogMetadataActionProcessor;
+};
+export default _default;

package/lib/esm/getActionProcessor/webserver/admin/getAdminActionProcessor.js

@@ -0,0 +1,50 @@
+import { actionResult, qpqCoreUtils } from 'quidproquo-core';
+import { AdminActionType, } from 'quidproquo-webserver';
+import { getQpqRuntimeResourceNameFromConfig } from '../../../awsNamingUtils';
+import { getPagedItemsOverRange } from '../../../logic/dynamo/getPagedItemsOverRange';
+import { getLogChildrenByFromCorrelation } from '../../../logic/dynamo/getLogChildrenByFromCorrelation';
+import { getLogByCorrelation } from '../../../logic/dynamo/getLogByCorrelation';
+import { readTextFile } from '../../../logic/s3/readTextFile';
+// TODO: Centralize this
+const QPQ_LOG_BUCKET_NAME = 'logs';
+const getAdminGetLogsActionProcessor = (qpqConfig) => {
+    return async ({ runtimeType, nextPageKey, startIsoDateTime, endIsoDateTime }) => {
+        const tableName = getQpqRuntimeResourceNameFromConfig(QPQ_LOG_BUCKET_NAME, qpqConfig, 'log');
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const response = await getPagedItemsOverRange(tableName, region, runtimeType, startIsoDateTime, endIsoDateTime, nextPageKey);
+        return actionResult(response);
+    };
+};
+const getLogMetadataChildrenActionProcessor = (qpqConfig) => {
+    return async ({ correlationId }) => {
+        const tableName = getQpqRuntimeResourceNameFromConfig(QPQ_LOG_BUCKET_NAME, qpqConfig, 'flog');
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const response = await getLogChildrenByFromCorrelation(tableName, region, correlationId);
+        return actionResult(response);
+    };
+};
+const getLogMetadataActionProcessor = (qpqConfig) => {
+    return async ({ correlationId }) => {
+        const tableName = getQpqRuntimeResourceNameFromConfig(QPQ_LOG_BUCKET_NAME, qpqConfig, 'log');
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const response = await getLogByCorrelation(tableName, region, correlationId);
+        return actionResult(response);
+    };
+};
+const getAdminGetLogActionProcessor = (qpqConfig) => {
+    return async ({ correlationId }) => {
+        const bucketName = getQpqRuntimeResourceNameFromConfig(QPQ_LOG_BUCKET_NAME, qpqConfig, 'log');
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const logJson = await readTextFile(bucketName, `${correlationId}.json`, region);
+        const response = JSON.parse(logJson);
+        return actionResult(response);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [AdminActionType.GetLogs]: getAdminGetLogsActionProcessor(qpqConfig),
+        [AdminActionType.GetLog]: getAdminGetLogActionProcessor(qpqConfig),
+        [AdminActionType.GetLogMetadataChildren]: getLogMetadataChildrenActionProcessor(qpqConfig),
+        [AdminActionType.GetLogMetadata]: getLogMetadataActionProcessor(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/webserver/admin/index.d.ts

@@ -0,0 +1,8 @@
+import { QPQConfig } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-webserver/Admin/GetLogs": import("quidproquo-webserver").AdminGetLogsActionProcessor;
+    "@quidproquo-webserver/Admin/GetLog": import("quidproquo-webserver").AdminGetLogActionProcessor;
+    "@quidproquo-webserver/Admin/GetLogMetadataChildren": import("quidproquo-webserver").AdminGetLogMetadataChildrenActionProcessor;
+    "@quidproquo-webserver/Admin/GetLogMetadata": import("quidproquo-webserver").AdminGetLogMetadataActionProcessor;
+};
+export default _default;

package/lib/esm/getActionProcessor/webserver/admin/index.js

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

package/lib/esm/getActionProcessor/webserver/index.d.ts

@@ -0,0 +1,4 @@
+export { default as getWebEntryActionProcessor } from './webEntry';
+export { default as getServiceFunctionActionProcessor } from './serviceFunction';
+export { default as getAdminActionProcessor } from './admin';
+export { default as getWebsocketActionProcessor } from './websocket';

package/lib/esm/getActionProcessor/webserver/index.js

@@ -0,0 +1,4 @@
+export { default as getWebEntryActionProcessor } from './webEntry';
+export { default as getServiceFunctionActionProcessor } from './serviceFunction';
+export { default as getAdminActionProcessor } from './admin';
+export { default as getWebsocketActionProcessor } from './websocket';

package/lib/esm/getActionProcessor/webserver/serviceFunction/getServiceFunctionActionProcessor.d.ts

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

package/lib/esm/getActionProcessor/webserver/serviceFunction/getServiceFunctionActionProcessor.js

@@ -0,0 +1,34 @@
+import { actionResult, actionResultError, qpqCoreUtils } from 'quidproquo-core';
+import { ServiceFunctionActionType } from 'quidproquo-webserver';
+import { executeLambdaByName } from '../../../logic/lambda/executeLambdaByName';
+import { getConfigRuntimeResourceName } from '../../../awsNamingUtils';
+const getServiceFunctionExecuteActionProcessor = (qpqConfig) => {
+    return async ({ functionName, service, payload, context, isAsync }, session) => {
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const appName = qpqCoreUtils.getApplicationName(qpqConfig);
+        const environment = qpqCoreUtils.getApplicationModuleEnvironment(qpqConfig);
+        const feature = qpqCoreUtils.getApplicationModuleFeature(qpqConfig);
+        const awsFunctionName = getConfigRuntimeResourceName(`${functionName}-sfunc`, appName, service, environment, feature);
+        const serviceFunctionEvent = {
+            functionName: functionName,
+            payload: payload,
+            storySession: {
+                ...session,
+                context,
+            },
+        };
+        const result = await executeLambdaByName(awsFunctionName, region, serviceFunctionEvent, isAsync);
+        if (!result) {
+            return actionResult(void 0);
+        }
+        if (!result.success) {
+            return actionResultError(result.error.errorType, result.error.errorText, `${service}::${functionName}: ${result?.error.errorStack || ''}`);
+        }
+        return actionResult(result.result);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [ServiceFunctionActionType.Execute]: getServiceFunctionExecuteActionProcessor(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/webserver/serviceFunction/index.d.ts

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

package/lib/esm/getActionProcessor/webserver/serviceFunction/index.js

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

package/lib/esm/getActionProcessor/webserver/webEntry/getWebEntryInvalidateCacheActionProcessor.d.ts

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

package/lib/esm/getActionProcessor/webserver/webEntry/getWebEntryInvalidateCacheActionProcessor.js

@@ -0,0 +1,18 @@
+import { actionResult, qpqCoreUtils } from 'quidproquo-core';
+import { WebEntryActionType } from 'quidproquo-webserver';
+import { getCFExportNameDistributionIdArnFromConfig } from '../../../awsNamingUtils';
+import { invalidateCache } from '../../../logic/cloudFront/invalidateCache';
+import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
+const getWebEntryInvalidteCacheActionProcessor = (qpqConfig) => {
+    return async ({ paths, webEntryName }) => {
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const distributionId = await getExportedValue(getCFExportNameDistributionIdArnFromConfig(webEntryName, qpqConfig), region);
+        await invalidateCache(distributionId, region, paths);
+        return actionResult(void 0);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [WebEntryActionType.InvalidateCache]: getWebEntryInvalidteCacheActionProcessor(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/webserver/webEntry/index.d.ts

@@ -0,0 +1,5 @@
+import { QPQConfig } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-webserver/WebEntry/InvalidateCache": import("quidproquo-webserver").WebEntryInvalidateCacheActionProcessor;
+};
+export default _default;

package/lib/esm/getActionProcessor/webserver/webEntry/index.js

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

package/lib/esm/getActionProcessor/webserver/websocket/getWebsocketSendMessageActionProcessor.d.ts

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

package/lib/esm/getActionProcessor/webserver/websocket/getWebsocketSendMessageActionProcessor.js

@@ -0,0 +1,26 @@
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, qpqCoreUtils } from 'quidproquo-core';
+import { WebsocketActionType, WebsocketSendMessageErrorTypeEnum } from 'quidproquo-webserver';
+import { getCFExportNameWebsocketApiIdFromConfig } from '../../../awsNamingUtils';
+import { sendMessageToWebSocketConnection } from '../../../logic/apiGateway/websocketSendMessage';
+import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
+const getWebsocketSendMessageActionProcessor = (qpqConfig) => {
+    return async ({ connectionId, payload, websocketApiName }) => {
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const apiId = await getExportedValue(getCFExportNameWebsocketApiIdFromConfig(websocketApiName, qpqConfig), region);
+        try {
+            await sendMessageToWebSocketConnection(apiId, connectionId, region, payload);
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                ThrottlingException: () => actionResultError(WebsocketSendMessageErrorTypeEnum.Throttled, 'Rate exceeded'),
+                GoneException: () => actionResultError(WebsocketSendMessageErrorTypeEnum.Disconnected, 'Connection no longer exists'),
+            });
+        }
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [WebsocketActionType.SendMessage]: getWebsocketSendMessageActionProcessor(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/webserver/websocket/index.d.ts

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

package/lib/esm/getActionProcessor/webserver/websocket/index.js

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

package/lib/esm/index.d.ts

@@ -0,0 +1,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';

package/lib/esm/index.js

@@ -0,0 +1,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';

package/lib/esm/logic/acm/findMatchingCertificates.d.ts

@@ -0,0 +1 @@
+export declare const findMatchingCertificates: (domainName: string, region: string, retryCount?: number, delayMs?: number) => Promise<string[]>;

package/lib/esm/logic/acm/findMatchingCertificates.js

@@ -0,0 +1,39 @@
+import { ACMClient, ListCertificatesCommand } from '@aws-sdk/client-acm';
+import { createAwsClient } from '../createAwsClient';
+export const findMatchingCertificates = async (domainName, region, retryCount = 3, delayMs = 5000) => {
+    const lowerCaseDomainName = domainName.toLowerCase();
+    const acmClient = createAwsClient(ACMClient, {
+        region,
+    });
+    let remainingRetries = retryCount;
+    while (remainingRetries > 0) {
+        let certificateArns = [];
+        let NextToken;
+        do {
+            const listCommand = new ListCertificatesCommand({
+                NextToken,
+            });
+            const listResult = await acmClient.send(listCommand);
+            for (const certificate of listResult.CertificateSummaryList || []) {
+                if (certificate.CertificateArn &&
+                    certificate.DomainName?.toLowerCase() === lowerCaseDomainName) {
+                    certificateArns.push(certificate.CertificateArn);
+                }
+            }
+            NextToken = listResult.NextToken;
+        } while (NextToken);
+        if (certificateArns.length > 0) {
+            return certificateArns;
+        }
+        remainingRetries--;
+        if (remainingRetries != 0) {
+            // Don't wait after the last try
+            await new Promise((res) => setTimeout(res, delayMs));
+        }
+    }
+    return []; // Return an empty array after max retries
+};
+// (async () => {
+//   const matchingCerts = await findMatchingCertificates('example.com', 'us-east-1');
+//   console.log('Matching certificates:', matchingCerts);
+// })();

package/lib/esm/logic/acm/getDomainValidationOptions.d.ts

@@ -0,0 +1,2 @@
+import { CloudflareDnsEntries } from 'quidproquo-webserver';
+export declare const getDomainValidationOptions: (certificateArn: string, region: string) => Promise<CloudflareDnsEntries>;

package/lib/esm/logic/acm/getDomainValidationOptions.js

@@ -0,0 +1,26 @@
+import { ACMClient, DescribeCertificateCommand } from '@aws-sdk/client-acm';
+import { createAwsClient } from '../createAwsClient';
+export const getDomainValidationOptions = async (certificateArn, region) => {
+    const acmClient = createAwsClient(ACMClient, {
+        region,
+    });
+    const command = new DescribeCertificateCommand({
+        CertificateArn: certificateArn,
+    });
+    const result = await acmClient.send(command);
+    const entries = {};
+    console.log('DescribeCertificateCommand: ', JSON.stringify(result, null, 2));
+    // Extract the DomainValidationOptions and populate the entries
+    if (result.Certificate && result.Certificate.DomainValidationOptions) {
+        for (const option of result.Certificate.DomainValidationOptions) {
+            if (option.ResourceRecord?.Name && option.ResourceRecord?.Value) {
+                entries[option.ResourceRecord.Name] = {
+                    proxied: false,
+                    type: 'CNAME',
+                    value: option.ResourceRecord.Value,
+                };
+            }
+        }
+    }
+    return entries;
+};

package/lib/esm/logic/apiGateway/getApiKeys.d.ts

@@ -0,0 +1,2 @@
+import { ApiKey } from 'quidproquo-webserver';
+export declare const getApiKeys: (region: string, ...keyNames: string[]) => Promise<ApiKey[]>;

package/lib/esm/logic/apiGateway/getApiKeys.js

@@ -0,0 +1,13 @@
+import { APIGatewayClient, GetApiKeysCommand, } from '@aws-sdk/client-api-gateway';
+import { createAwsClient } from '../createAwsClient';
+export const getApiKeys = async (region, ...keyNames) => {
+    const apiGatewayClient = createAwsClient(APIGatewayClient, { region });
+    const input = {
+        includeValues: true,
+        limit: 500,
+    };
+    const res = await apiGatewayClient.send(new GetApiKeysCommand(input));
+    return (res.items
+        ?.filter((i) => keyNames.indexOf(i.name) >= 0)
+        .map((i) => ({ name: i.name, value: i.value, description: i.description })) || []);
+};

package/lib/esm/logic/apiGateway/websocketSendMessage.d.ts

@@ -0,0 +1 @@
+export declare const sendMessageToWebSocketConnection: (apiId: string, connectionId: string, region: string, payload: any) => Promise<void>;

package/lib/esm/logic/apiGateway/websocketSendMessage.js

@@ -0,0 +1,16 @@
+import { ApiGatewayManagementApiClient, PostToConnectionCommand } from "@aws-sdk/client-apigatewaymanagementapi";
+import { createAwsClient } from '../createAwsClient';
+export const sendMessageToWebSocketConnection = async (apiId, connectionId, region, payload) => {
+    // Create a new ApiGatewayManagementApiClient
+    const apiGatewayManagementApiClient = createAwsClient(ApiGatewayManagementApiClient, {
+        apiVersion: "2018-11-29",
+        endpoint: `https://${apiId}.execute-api.${region}.amazonaws.com/prod`,
+        region
+    });
+    // Create a new PostToConnectionCommand with the connection ID and payload
+    const command = new PostToConnectionCommand({
+        ConnectionId: connectionId,
+        Data: JSON.stringify(payload) // Convert payload to string if necessary
+    });
+    await apiGatewayManagementApiClient.send(command);
+};

package/lib/esm/logic/cache/memoFunc.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Memoizes a function by caching its return values.
+ * @param func The function to memoize.
+ * @param ttlInSeconds Time-to-live for the cached values in seconds.
+ * @returns The memoized function.
+ */
+export declare const memoFunc: <T extends (...args: any[]) => any>(func: T, ttlInSeconds?: number) => T;

package/lib/esm/logic/cache/memoFunc.js

@@ -0,0 +1,28 @@
+import NodeCache from 'node-cache';
+const cache = new WeakMap();
+/**
+ * Memoizes a function by caching its return values.
+ * @param func The function to memoize.
+ * @param ttlInSeconds Time-to-live for the cached values in seconds.
+ * @returns The memoized function.
+ */
+export const memoFunc = (func, ttlInSeconds = 3600) => {
+    return ((...args) => {
+        // Check if the function has a corresponding cache entry
+        if (!cache.has(func)) {
+            // Create a new NodeCache instance and store it in the cache
+            cache.set(func, new NodeCache({ stdTTL: ttlInSeconds }));
+        }
+        const cacheKey = JSON.stringify(args);
+        const nodeCache = cache.get(func);
+        const cachedValue = nodeCache.get(cacheKey);
+        if (cachedValue) {
+            return cachedValue;
+        }
+        // Call the original function if the value is not cached
+        const result = func(...args);
+        // Cache the result for future use
+        nodeCache.set(cacheKey, result);
+        return result;
+    });
+};

package/lib/esm/logic/cache/memoFuncAsync.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Memoizes a function by caching its return values.
+ * @param func The function to memoize.
+ * @param ttlInSeconds Time-to-live for the cached values in seconds.
+ * @returns The memoized function.
+ */
+export declare const memoFuncAsync: <T extends (...args: any[]) => any>(func: T, ttlInSeconds?: number) => T;

package/lib/esm/logic/cache/memoFuncAsync.js

@@ -0,0 +1,29 @@
+import NodeCache from 'node-cache';
+const cache = new WeakMap();
+/**
+ * Memoizes a function by caching its return values.
+ * @param func The function to memoize.
+ * @param ttlInSeconds Time-to-live for the cached values in seconds.
+ * @returns The memoized function.
+ */
+export const memoFuncAsync = (func, ttlInSeconds = 3600) => {
+    return (async (...args) => {
+        if (!cache.has(func)) {
+            cache.set(func, new NodeCache({ stdTTL: ttlInSeconds }));
+        }
+        const cacheKey = JSON.stringify(args);
+        const nodeCache = cache.get(func);
+        if (nodeCache.has(cacheKey)) {
+            return nodeCache.get(cacheKey);
+        }
+        try {
+            // Await the result and then cache it
+            const result = await func(...args);
+            nodeCache.set(cacheKey, result);
+            return result;
+        }
+        catch (err) {
+            throw err; // re-throw the error to be caught by caller
+        }
+    });
+};

package/lib/esm/logic/cloudFront/invalidateCache.d.ts

@@ -0,0 +1,2 @@
+export declare const getInvalidationCallerReference: (paths: string[]) => string;
+export declare const invalidateCache: (distributionId: string, region: string, paths: string[]) => Promise<void>;

package/lib/esm/logic/cloudFront/invalidateCache.js

@@ -0,0 +1,24 @@
+import { CloudFrontClient, CreateInvalidationCommand, } from '@aws-sdk/client-cloudfront';
+import crypto from 'crypto';
+import { createAwsClient } from '../createAwsClient';
+export const getInvalidationCallerReference = (paths) => {
+    const allPaths = paths.join('');
+    // All paths as a hash
+    const allPathHash = crypto.createHash('md5').update(allPaths).digest('hex');
+    // Unique key is the now time with all paths hash
+    return allPathHash + new Date().toISOString();
+};
+export const invalidateCache = async (distributionId, region, paths) => {
+    const cloudFrontClient = createAwsClient(CloudFrontClient, { region });
+    const input = {
+        DistributionId: distributionId,
+        InvalidationBatch: {
+            Paths: {
+                Quantity: paths.length,
+                Items: paths,
+            },
+            CallerReference: getInvalidationCallerReference(paths),
+        },
+    };
+    await cloudFrontClient.send(new CreateInvalidationCommand(input));
+};

package/lib/esm/logic/cloudformation/getExportedValue.d.ts

@@ -0,0 +1 @@
+export declare const getExportedValue: (variableName: string, region: string) => Promise<string>;

package/lib/esm/logic/cloudformation/getExportedValue.js

@@ -0,0 +1,17 @@
+import { CloudFormationClient, ListExportsCommand, } from '@aws-sdk/client-cloudformation';
+import { memoFuncAsync } from '../cache/memoFuncAsync';
+import { createAwsClient } from '../createAwsClient';
+export const getExportedValue = memoFuncAsync(async (variableName, region) => {
+    const cloudformation = createAwsClient(CloudFormationClient, { region });
+    const listCommandParams = {};
+    do {
+        const result = await cloudformation.send(new ListExportsCommand(listCommandParams));
+        const value = (result.Exports || []).find((e) => e.Name === variableName)?.Value;
+        if (value !== undefined) {
+            console.log(`CF Found: [${variableName}] = [${value}]`);
+            return value;
+        }
+        listCommandParams.NextToken = result.NextToken;
+    } while (!!listCommandParams.NextToken);
+    throw new Error(`CF could not find: [${variableName}]`);
+});

package/lib/esm/logic/cognito/authenticateUser.d.ts

@@ -0,0 +1,2 @@
+import { AuthenticateUserResponse } from 'quidproquo-core';
+export declare const authenticateUser: (userPoolId: string, clientId: string, region: string, username: string, password: string) => Promise<AuthenticateUserResponse>;

package/lib/esm/logic/cognito/authenticateUser.js

@@ -0,0 +1,25 @@
+import { CognitoIdentityProviderClient, AdminInitiateAuthCommand, AuthFlowType, } from '@aws-sdk/client-cognito-identity-provider';
+import { calculateSecretHash } from './utils/calculateSecretHash';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
+import { cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo } from './utils/transformCognitoResponse';
+import { createAwsClient } from '../createAwsClient';
+// TODO: retry for TooManyRequestsException
+export const authenticateUser = async (userPoolId, clientId, region, username, password) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
+    const secretHash = calculateSecretHash(username, clientId, clientSecret);
+    // Time we issued the request
+    const issueDateTime = new Date().toISOString();
+    const params = {
+        AuthFlow: AuthFlowType.ADMIN_USER_PASSWORD_AUTH,
+        UserPoolId: userPoolId,
+        ClientId: clientId,
+        AuthParameters: {
+            USERNAME: username,
+            PASSWORD: password,
+            SECRET_HASH: secretHash,
+        },
+    };
+    const response = await cognitoClient.send(new AdminInitiateAuthCommand(params));
+    return cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo(response, issueDateTime);
+};

package/lib/esm/logic/cognito/changePassword.d.ts

@@ -0,0 +1 @@
+export declare const changePassword: (accessToken: string, previousPassword: string, proposedPassword: string, region: string) => Promise<void>;

package/lib/esm/logic/cognito/changePassword.js

@@ -0,0 +1,11 @@
+import { CognitoIdentityProviderClient, ChangePasswordCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
+export const changePassword = async (accessToken, previousPassword, proposedPassword, region) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const params = {
+        AccessToken: accessToken,
+        PreviousPassword: previousPassword,
+        ProposedPassword: proposedPassword,
+    };
+    await cognitoClient.send(new ChangePasswordCommand(params));
+};

package/lib/esm/logic/cognito/cognitoAttributeMap.d.ts

@@ -0,0 +1,10 @@
+import { UserAttributes } from 'quidproquo-core';
+export declare const cognitoAttributeMap: Record<keyof UserAttributes, string>;
+export declare const getCognitoUserAttributesFromQpqUserAttributes: (userAttributes: UserAttributes) => {
+    Name: string;
+    Value: string;
+}[];
+export declare const getQpqAttributesFromCognitoUserAttributes: (cognitoUserAttributes: {
+    Name: string;
+    Value: string;
+}[]) => UserAttributes;