quidproquo-actionprocessor-awslambda 0.0.232 → 0.0.233

package/lib/esm/lambdas/anyExecuteServiceFunctionEvent_serviceFunction.js

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

package/lib/esm/lambdas/apiGatewayEventHandler.js

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

package/lib/esm/lambdas/apiGatwayEventWebsocketWithIdentity_websocketEvent.js

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

package/lib/esm/lambdas/cloudFrontRequestEvent_originRequest.js

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

package/lib/esm/lambdas/customMessageTriggerEvent_createAuthChallenge.js

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

package/lib/esm/lambdas/customMessageTriggerEvent_customMessage.js

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

package/lib/esm/lambdas/customMessageTriggerEvent_defineAuthChallenge.js

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

package/lib/esm/lambdas/customMessageTriggerEvent_verifyAuthChallenge.js

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

package/lib/esm/lambdas/dynamicModuleLoader/dynamicModuleLoader.js

@@ -1,4 +1,4 @@
-// @ts-ignore - Special webpack file injected
+// @ts-expect-error - Special webpack file injected
 import { qpqDynamicModuleLoader } from 'quidproquo-dynamic-loader';
 export const dynamicModuleLoader = async (modulePath) => {
     return qpqDynamicModuleLoader(modulePath);

package/lib/esm/lambdas/eventBridgeEvent_recurringSchedule.js

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

package/lib/esm/lambdas/eventBridgeEvent_stackDeploy.js

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

package/lib/esm/lambdas/lambda-utils/getQpqConfig.js

@@ -1,4 +1,4 @@
-// @ts-ignore - Special webpack file injected
+// @ts-expect-error - Special webpack file injected
 import { qpqConfig } from 'quidproquo-dynamic-loader';
 export const getQpqConfig = () => {
     return qpqConfig;

package/lib/esm/lambdas/lambda-utils/index.d.ts

@@ -1,2 +1,2 @@
-export * from './logger';
 export * from './getQpqConfig';
+export * from './logger';

package/lib/esm/lambdas/lambda-utils/index.js

@@ -1,2 +1,2 @@
-export * from './logger';
 export * from './getQpqConfig';
+export * from './logger';

package/lib/esm/lambdas/lambda-utils/logger.d.ts

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

package/lib/esm/lambdas/lambda-utils/logger.js

@@ -1,9 +1,9 @@
+import { qpqCoreUtils } from 'quidproquo-core';
 import fs from 'fs';
 import path from 'path';
-import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
-import { qpqCoreUtils } from 'quidproquo-core';
+import { PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
 const tempDirectory = '/tmp/qpqlogs';
-import { getAwsServiceAccountInfoConfig, getAwsServiceAccountInfoByDeploymentInfo } from 'quidproquo-config-aws';
+import { getAwsServiceAccountInfoByDeploymentInfo, getAwsServiceAccountInfoConfig } from 'quidproquo-config-aws';
 import { getConfigRuntimeResourceName } from '../../awsNamingUtils';
 export const storyLogger = async (result, bucketName, region) => {
     try {

package/lib/esm/lambdas/lambdaSQSEvent.js

@@ -1,8 +1,8 @@
 import { QpqRuntimeType } from 'quidproquo-core';
-import { getQpqConfig } from './lambda-utils';
-import { dynamicModuleLoader } from './dynamicModuleLoader';
-import { getQpqLambdaRuntimeForEvent } from '../lambdaHandlers/helpers/getQpqLambdaRuntimeForEvent';
 import { getSqsQueueEventProcessor } from '../getActionProcessor';
+import { getQpqLambdaRuntimeForEvent } from '../lambdaHandlers/helpers/getQpqLambdaRuntimeForEvent';
+import { dynamicModuleLoader } from './dynamicModuleLoader';
+import { getQpqConfig } from './lambda-utils';
 // Default executor
 export const executeSQSEvent = getQpqLambdaRuntimeForEvent(QpqRuntimeType.QUEUE_EVENT, (event) => {
     return {

package/lib/esm/lambdas/sqsEvent_queueEvent.js

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

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

@@ -15,8 +15,7 @@ export const findMatchingCertificates = async (domainName, region, retryCount =
             });
             const listResult = await acmClient.send(listCommand);
             for (const certificate of listResult.CertificateSummaryList || []) {
-                if (certificate.CertificateArn &&
-                    certificate.DomainName?.toLowerCase() === lowerCaseDomainName) {
+                if (certificate.CertificateArn && certificate.DomainName?.toLowerCase() === lowerCaseDomainName) {
                     certificateArns.push(certificate.CertificateArn);
                 }
             }

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

@@ -1,4 +1,4 @@
-import { APIGatewayClient, GetApiKeysCommand, } from '@aws-sdk/client-api-gateway';
+import { APIGatewayClient, GetApiKeysCommand } from '@aws-sdk/client-api-gateway';
 import { createAwsClient } from '../createAwsClient';
 export const getApiKeys = async (region, ...keyNames) => {
     const apiGatewayClient = createAwsClient(APIGatewayClient, { region });
@@ -9,5 +9,9 @@ export const getApiKeys = async (region, ...keyNames) => {
     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 })) || []);
+        .map((i) => ({
+        name: i.name,
+        value: i.value,
+        description: i.description,
+    })) || []);
 };

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

@@ -1,16 +1,16 @@
-import { ApiGatewayManagementApiClient, PostToConnectionCommand } from "@aws-sdk/client-apigatewaymanagementapi";
+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",
+        apiVersion: '2018-11-29',
         endpoint: `https://${apiId}.execute-api.${region}.amazonaws.com/prod`,
-        region
+        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
+        Data: JSON.stringify(payload), // Convert payload to string if necessary
     });
     await apiGatewayManagementApiClient.send(command);
 };

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

@@ -16,14 +16,10 @@ export const memoFuncAsync = (func, ttlInSeconds = 3600) => {
         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
-        }
+        // Await the result
+        const result = await func(...args);
+        // and then cache it
+        nodeCache.set(cacheKey, result);
+        return result;
     });
 };

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

@@ -1,5 +1,5 @@
-import { CloudFrontClient, CreateInvalidationCommand, } from '@aws-sdk/client-cloudfront';
 import crypto from 'crypto';
+import { CloudFrontClient, CreateInvalidationCommand } from '@aws-sdk/client-cloudfront';
 import { createAwsClient } from '../createAwsClient';
 export const getInvalidationCallerReference = (paths) => {
     const allPaths = paths.join('');

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

@@ -1,4 +1,4 @@
-import { CloudFormationClient, ListExportsCommand, } from '@aws-sdk/client-cloudformation';
+import { CloudFormationClient, ListExportsCommand } from '@aws-sdk/client-cloudformation';
 import { memoFuncAsync } from '../cache/memoFuncAsync';
 import { createAwsClient } from '../createAwsClient';
 export const getExportedValue = memoFuncAsync(async (variableName, region) => {
@@ -12,6 +12,6 @@ export const getExportedValue = memoFuncAsync(async (variableName, region) => {
             return value;
         }
         listCommandParams.NextToken = result.NextToken;
-    } while (!!listCommandParams.NextToken);
+    } while (listCommandParams.NextToken);
     throw new Error(`CF could not find: [${variableName}]`);
 });

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

@@ -1,11 +1,13 @@
-import { CognitoIdentityProviderClient, AdminInitiateAuthCommand, AuthFlowType, } from '@aws-sdk/client-cognito-identity-provider';
+import { AdminInitiateAuthCommand, AuthFlowType, CognitoIdentityProviderClient, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
 import { calculateSecretHash } from './utils/calculateSecretHash';
-import { getUserPoolClientSecret } from './getUserPoolClientSecret';
 import { cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo } from './utils/transformCognitoResponse';
-import { createAwsClient } from '../createAwsClient';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
 // TODO: retry for TooManyRequestsException
 export const authenticateUser = async (userPoolId, clientId, region, isCustom, username, password) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
     const secretHash = calculateSecretHash(username, clientId, clientSecret);
     // Time we issued the request

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

@@ -1,7 +1,9 @@
-import { CognitoIdentityProviderClient, ChangePasswordCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { ChangePasswordCommand, CognitoIdentityProviderClient } 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 cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const params = {
         AccessToken: accessToken,
         PreviousPassword: previousPassword,

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

@@ -42,7 +42,10 @@ const getQpqAttributeObjectFromCognitoKeyValue = (key, value) => {
 export const getQpqAttributesFromCognitoUserAttributes = (cognitoUserAttributes) => {
     // Map cognitoUserAttributes to your UserAttributes format
     const userAttributes = cognitoUserAttributes.reduce((acc, { Name, Value }) => {
-        return { ...acc, ...getQpqAttributeObjectFromCognitoKeyValue(Name, Value) };
+        return {
+            ...acc,
+            ...getQpqAttributeObjectFromCognitoKeyValue(Name, Value),
+        };
     }, {});
     return userAttributes;
 };

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

@@ -1,10 +1,12 @@
 import { CognitoIdentityProviderClient, ConfirmForgotPasswordCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
 import { calculateSecretHash } from './utils/calculateSecretHash';
-import { getUserPoolClientSecret } from './getUserPoolClientSecret';
 import { authenticateUser } from './authenticateUser';
-import { createAwsClient } from '../createAwsClient';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
 export const confirmForgotPassword = async (userPoolId, clientId, region, code, username, password) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
     const secretHash = calculateSecretHash(username, clientId, clientSecret);
     const params = {

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

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

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

@@ -1,10 +1,12 @@
-import { CognitoIdentityProviderClient, AdminCreateUserCommand, DeliveryMediumType, MessageActionType, } from '@aws-sdk/client-cognito-identity-provider';
+import { AdminCreateUserCommand, CognitoIdentityProviderClient, DeliveryMediumType, MessageActionType, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
 import { authenticateUser } from './authenticateUser';
-import { setUserPassword } from './setUserPassword';
 import { getCognitoUserAttributesFromQpqUserAttributes } from './cognitoAttributeMap';
-import { createAwsClient } from '../createAwsClient';
+import { setUserPassword } from './setUserPassword';
 export const createUser = async (userPoolId, region, clientId, createUserRequest) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const params = {
         UserPoolId: userPoolId,
         Username: createUserRequest.email,

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

@@ -1,4 +1,4 @@
-import { verify, decode } from 'jsonwebtoken';
+import { decode, verify } from 'jsonwebtoken';
 import jwksClient from 'jwks-rsa';
 export const decodeValidJwt = async (userPoolId, region, ignoreExpiration, accessToken) => {
     if (!accessToken) {

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

@@ -1,9 +1,11 @@
-import { CognitoIdentityProviderClient, ForgotPasswordCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { CognitoIdentityProviderClient, ForgotPasswordCommand } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
 import { calculateSecretHash } from './utils/calculateSecretHash';
 import { getUserPoolClientSecret } from './getUserPoolClientSecret';
-import { createAwsClient } from '../createAwsClient';
 export const forgotPassword = async (userPoolId, clientId, region, username) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
     const secretHash = calculateSecretHash(username, clientId, clientSecret);
     const params = {

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

@@ -1,4 +1,4 @@
-import { CognitoIdentityProviderClient, GetUserCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { CognitoIdentityProviderClient, GetUserCommand } from '@aws-sdk/client-cognito-identity-provider';
 import { createAwsClient } from '../createAwsClient';
 const getUserAttribute = (attributeName, userAttributes) => {
     const lowerAttributeName = attributeName.toLowerCase();
@@ -6,7 +6,9 @@ const getUserAttribute = (attributeName, userAttributes) => {
     return attribute?.Value;
 };
 export const getUser = async (accessToken, region) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const params = {
         AccessToken: accessToken,
     };

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

@@ -1,8 +1,10 @@
-import { CognitoIdentityProviderClient, AdminGetUserCommand, } from '@aws-sdk/client-cognito-identity-provider';
-import { getQpqAttributesFromCognitoUserAttributes } from './cognitoAttributeMap';
+import { AdminGetUserCommand, CognitoIdentityProviderClient } from '@aws-sdk/client-cognito-identity-provider';
 import { createAwsClient } from '../createAwsClient';
+import { getQpqAttributesFromCognitoUserAttributes } from './cognitoAttributeMap';
 export const getUserAttributes = async (userPoolId, region, username) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const params = {
         UserPoolId: userPoolId,
         Username: username,

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

@@ -1,8 +1,10 @@
-import { CognitoIdentityProviderClient, ListUsersCommand, } from '@aws-sdk/client-cognito-identity-provider';
-import { getQpqAttributesFromCognitoUserAttributes } from './cognitoAttributeMap';
+import { CognitoIdentityProviderClient, ListUsersCommand } from '@aws-sdk/client-cognito-identity-provider';
 import { createAwsClient } from '../createAwsClient';
+import { getQpqAttributesFromCognitoUserAttributes } from './cognitoAttributeMap';
 export const getUserAttributesBySub = async (userPoolId, region, sub) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const response = await cognitoClient.send(new ListUsersCommand({
         UserPoolId: userPoolId,
         Filter: `sub = "${sub}"`,

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

@@ -1,7 +1,9 @@
 import { CognitoIdentityProviderClient, DescribeUserPoolClientCommand, } from '@aws-sdk/client-cognito-identity-provider';
 import { createAwsClient } from '../createAwsClient';
 export const getUserPoolClientSecret = async (userPoolId, clientId, region) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const params = {
         ClientId: clientId,
         UserPoolId: userPoolId,

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

@@ -1,2 +1,2 @@
-export * from './decodeValidJwt';
 export * from './decodeAccessToken';
+export * from './decodeValidJwt';

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

@@ -1,2 +1,2 @@
-export * from './decodeValidJwt';
 export * from './decodeAccessToken';
+export * from './decodeValidJwt';

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

@@ -1,2 +1,2 @@
-import { UserAttributes, QpqPagedData } from 'quidproquo-core';
+import { QpqPagedData, UserAttributes } from 'quidproquo-core';
 export declare const listPagedUsers: (userPoolId: string, region: string, pageKey?: string) => Promise<QpqPagedData<UserAttributes>>;

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

@@ -1,9 +1,11 @@
-import { CognitoIdentityProviderClient, ListUsersCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { CognitoIdentityProviderClient, ListUsersCommand } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
 import { getQpqAttributesFromCognitoUserAttributes } from './cognitoAttributeMap';
 import { pageKeyToPaginationToken, paginationTokenToPageKey } from './utils';
-import { createAwsClient } from '../createAwsClient';
 export const listPagedUsers = async (userPoolId, region, pageKey) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const response = await cognitoClient.send(new ListUsersCommand({
         UserPoolId: userPoolId,
         PaginationToken: pageKeyToPaginationToken(pageKey),

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

@@ -1,2 +1,2 @@
-import { UserAttributes, QpqPagedData } from 'quidproquo-core';
+import { QpqPagedData, UserAttributes } from 'quidproquo-core';
 export declare const listPagedUsersByAttribute: (userPoolId: string, region: string, attributeName: string, attributeValue: string, limit?: number, pageKey?: string) => Promise<QpqPagedData<UserAttributes>>;

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

@@ -1,9 +1,11 @@
 import { CognitoIdentityProviderClient, ListUsersCommand } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
 import { getQpqAttributesFromCognitoUserAttributes } from './cognitoAttributeMap';
 import { pageKeyToPaginationToken, paginationTokenToPageKey } from './utils';
-import { createAwsClient } from '../createAwsClient';
 export const listPagedUsersByAttribute = async (userPoolId, region, attributeName, attributeValue, limit, pageKey) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const response = await cognitoClient.send(new ListUsersCommand({
         UserPoolId: userPoolId,
         Limit: limit,

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

@@ -1,10 +1,12 @@
-import { CognitoIdentityProviderClient, AdminInitiateAuthCommand, AuthFlowType, } from '@aws-sdk/client-cognito-identity-provider';
+import { AdminInitiateAuthCommand, AuthFlowType, CognitoIdentityProviderClient, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
 import { calculateSecretHash } from './utils/calculateSecretHash';
-import { getUserPoolClientSecret } from './getUserPoolClientSecret';
 import { cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo } from './utils/transformCognitoResponse';
-import { createAwsClient } from '../createAwsClient';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
 export const refreshToken = async (userPoolId, clientId, region, username, refreshToken) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
     const secretHash = calculateSecretHash(username, clientId, clientSecret);
     const params = {

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

@@ -1,7 +1,9 @@
 import { CognitoIdentityProviderClient, GetUserAttributeVerificationCodeCommand, } from '@aws-sdk/client-cognito-identity-provider';
 import { createAwsClient } from '../createAwsClient';
 export const requestEmailVerificationCode = async (region, accessToken) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const params = {
         AccessToken: accessToken,
         AttributeName: 'email', // Request verification for the email attribute

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

@@ -1,10 +1,12 @@
 import { CognitoIdentityProviderClient, RespondToAuthChallengeCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
 import { calculateSecretHash } from './utils/calculateSecretHash';
-import { getUserPoolClientSecret } from './getUserPoolClientSecret';
 import { cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo } from './utils/transformCognitoResponse';
-import { createAwsClient } from '../createAwsClient';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
 export const respondToAuthChallengeChallenge = async (userPoolId, clientId, region, username, session, challengeNameType, attributes) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
     const secretHash = calculateSecretHash(username, clientId, clientSecret);
     const params = {

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

@@ -1,8 +1,10 @@
-import { CognitoIdentityProviderClient, AdminUpdateUserAttributesCommand, } from '@aws-sdk/client-cognito-identity-provider';
-import { getCognitoUserAttributesFromQpqUserAttributes } from './cognitoAttributeMap';
+import { AdminUpdateUserAttributesCommand, CognitoIdentityProviderClient } from '@aws-sdk/client-cognito-identity-provider';
 import { createAwsClient } from '../createAwsClient';
+import { getCognitoUserAttributesFromQpqUserAttributes } from './cognitoAttributeMap';
 export const setUserAttributes = async (userPoolId, region, username, userAttributes) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const { userId, ...writeableUserAttributes } = userAttributes;
     const params = {
         UserPoolId: userPoolId,

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

@@ -1,7 +1,9 @@
-import { CognitoIdentityProviderClient, AdminSetUserPasswordCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { AdminSetUserPasswordCommand, CognitoIdentityProviderClient, } from '@aws-sdk/client-cognito-identity-provider';
 import { createAwsClient } from '../createAwsClient';
 export const setUserPassword = async (region, userPoolId, username, password) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     // There has to be a better way than this?
     const passwordParams = {
         Password: password,

package/lib/esm/logic/cognito/utils/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./calculateSecretHash";
+export * from './calculateSecretHash';
 export * from './pageKeyToPaginationToken';
 export * from './paginationTokenToPageKey';
 export * from './transformCognitoResponse';

package/lib/esm/logic/cognito/utils/index.js

@@ -1,4 +1,4 @@
-export * from "./calculateSecretHash";
+export * from './calculateSecretHash';
 export * from './pageKeyToPaginationToken';
 export * from './paginationTokenToPageKey';
 export * from './transformCognitoResponse';

package/lib/esm/logic/cognito/utils/transformCognitoResponse.d.ts

@@ -1,5 +1,5 @@
-import { AuthenticateUserResponse, AuthenticationInfo, AuthenticateUserChallenge } from 'quidproquo-core';
-import { AuthenticationResultType, AdminInitiateAuthResponse, ChallengeNameType } from '@aws-sdk/client-cognito-identity-provider';
+import { AuthenticateUserChallenge, AuthenticateUserResponse, AuthenticationInfo } from 'quidproquo-core';
+import { AdminInitiateAuthResponse, AuthenticationResultType, ChallengeNameType } from '@aws-sdk/client-cognito-identity-provider';
 export declare const cognitoAuthenticationResultTypeToQpqAuthenticationInfo: (authResult: AuthenticationResultType, issueDateTime: string) => AuthenticationInfo;
 export declare const cognitoChallengeNameTypeToQpqAuthenticateUserChallenge: (cognitoChallengeName: ChallengeNameType | string | undefined) => AuthenticateUserChallenge;
 export declare const cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo: (authResponse: AdminInitiateAuthResponse, issueDateTime: string) => AuthenticateUserResponse;

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

@@ -1,7 +1,9 @@
 import { CognitoIdentityProviderClient, VerifyUserAttributeCommand, } from '@aws-sdk/client-cognito-identity-provider';
 import { createAwsClient } from '../createAwsClient';
 export const verifyUserEmail = async (region, accessToken, verificationCode) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
     const params = {
         AccessToken: accessToken,
         AttributeName: 'email',

package/lib/esm/logic/dynamo/deleteItem.js

@@ -1,6 +1,6 @@
-import { DynamoDBClient, DeleteItemCommand, } from '@aws-sdk/client-dynamodb';
-import { buildAttributeValue } from './qpqDynamoOrm';
+import { DeleteItemCommand, DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { createAwsClient } from '../createAwsClient';
+import { buildAttributeValue } from './qpqDynamoOrm';
 export async function deleteItem(tableName, region, key, keyName, sortKey, sortKeyName) {
     const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
     const deleteItemParams = {

package/lib/esm/logic/dynamo/getLogChildrenByFromCorrelation.js

@@ -1,6 +1,6 @@
 import { DynamoDBClient, QueryCommand } from '@aws-sdk/client-dynamodb';
-import { lastEvaluatedKeyToString, stringToLastEvaluatedKey } from './logs';
 import { createAwsClient } from '../createAwsClient';
+import { lastEvaluatedKeyToString, stringToLastEvaluatedKey } from './logs';
 export async function getLogChildrenByFromCorrelation(tableName, region, fromCorrelation, pageKey) {
     const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
     const queryParams = {