quidproquo-actionprocessor-awslambda 0.0.232 → 0.0.234

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/decodeAccessToken.js

@@ -1,9 +1,9 @@
-import { qpqCoreUtils } from 'quidproquo-core';
+import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
 import { getCFExportNameUserPoolIdFromConfig } from '../../awsNamingUtils';
 import { getExportedValue } from '../cloudformation/getExportedValue';
 import { decodeValidJwt } from './decodeValidJwt';
 export const decodeAccessToken = async (userDirectoryName, qpqConfig, accessToken, ignoreExpiration = false) => {
-    const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+    const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
     const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
     const decodedAuthToken = await decodeValidJwt(userPoolId, region, ignoreExpiration, accessToken);
     if (!decodedAuthToken || !decodedAuthToken?.username) {

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 = {

package/lib/esm/logic/dynamo/getPagedItemsOverRange.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 getPagedItemsOverRange(tableName, region, runtimeType, startIsoDateTime, endIsoDateTime, pageKey) {
     const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
     const queryParams = {
@@ -8,8 +8,12 @@ export async function getPagedItemsOverRange(tableName, region, runtimeType, sta
         KeyConditionExpression: 'runtimeType = :runtimeType AND startedAtWithCorrelation BETWEEN :startIsoDateTime AND :endIsoDateTime',
         ExpressionAttributeValues: {
             ':runtimeType': { S: runtimeType },
-            ':startIsoDateTime': { S: startIsoDateTime + '#00000000-0000-0000-0000-000000000000' },
-            ':endIsoDateTime': { S: endIsoDateTime + '#ffffffff-ffff-ffff-ffff-ffffffffffff' },
+            ':startIsoDateTime': {
+                S: startIsoDateTime + '#00000000-0000-0000-0000-000000000000',
+            },
+            ':endIsoDateTime': {
+                S: endIsoDateTime + '#ffffffff-ffff-ffff-ffff-ffffffffffff',
+            },
         },
         ScanIndexForward: false,
     };

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

@@ -2,5 +2,5 @@ export * from './deleteItem';
 export * from './getAllItems';
 export * from './getItem';
 export * from './putItem';
-export * from './updateItem';
 export * from './query';
+export * from './updateItem';

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

@@ -2,5 +2,5 @@ export * from './deleteItem';
 export * from './getAllItems';
 export * from './getItem';
 export * from './putItem';
-export * from './updateItem';
 export * from './query';
+export * from './updateItem';

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

@@ -1,6 +1,6 @@
 import { DynamoDBClient, PutItemCommand } from '@aws-sdk/client-dynamodb';
-import { buildAttributeValue } from './qpqDynamoOrm';
 import { createAwsClient } from '../createAwsClient';
+import { buildAttributeValue } from './qpqDynamoOrm';
 // We currently only support objects as root items in dynamo
 // Storing a list (array) as the root of your DynamoDB record is indeed possible,
 // but there are some caveats. One of the main challenges is that DynamoDB doesn't support

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoQuery.d.ts

@@ -1,4 +1,4 @@
-import { KvsQueryOperation, KvsQueryCondition, KvsLogicalOperator, KvsAdvancedDataType } from 'quidproquo-core';
+import { KvsAdvancedDataType, KvsLogicalOperator, KvsQueryCondition, KvsQueryOperation } from 'quidproquo-core';
 import { AttributeValue } from '@aws-sdk/client-dynamodb';
 export declare const getItemName: (name: string) => string;
 export declare const getValueName: (value: KvsAdvancedDataType) => string;

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoQuery.js

@@ -1,5 +1,5 @@
+import { KvsLogicalOperatorType, KvsQueryOperationType, } from 'quidproquo-core';
 import crypto from 'crypto';
-import { KvsQueryOperationType, KvsLogicalOperatorType, } from 'quidproquo-core';
 // TODO: Come up with a better way of generating item name / values
 // probably a map ~ however this will most likely never fail.
 const getHash = (name) => {
@@ -37,9 +37,7 @@ const buildDynamoQueryExpressionGreaterThanOrEqual = (query) => {
     return `${getItemName(query.key)} >= ${getValueName(query.valueA)}`;
 };
 const buildDynamoQueryExpressionIn = (query) => {
-    return `${getItemName(query.key)} IN (${query.valueA
-        .map((v) => getValueName(v))
-        .join(', ')})`;
+    return `${getItemName(query.key)} IN (${query.valueA.map((v) => getValueName(v)).join(', ')})`;
 };
 const buildDynamoQueryExpressionExists = (query) => {
     return `attribute_exists(${getItemName(query.key)})`;

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoUpdate.d.ts

@@ -1,5 +1,5 @@
+import { KvsUpdate, KvsUpdateActionType } from 'quidproquo-core';
 import { AttributeValue } from '@aws-sdk/client-dynamodb';
-import { KvsUpdateActionType, KvsUpdate } from 'quidproquo-core';
 interface ExpressionAttributeNameMap {
     [key: string]: string;
 }

package/lib/esm/logic/dynamo/qpqDynamoOrm/buildDynamoUpdate.js

@@ -1,5 +1,5 @@
 import { KvsUpdateActionType } from 'quidproquo-core';
-import { getItemName, getValueName, buildAttributeValue } from './buildDynamoQuery';
+import { buildAttributeValue, getItemName, getValueName } from './buildDynamoQuery';
 export const buildUpdateExpressionAttributeNames = (updates) => {
     let attributeNames = {};
     for (let update of updates) {
@@ -94,9 +94,7 @@ export const buildDynamoUpdateExpressionForType = (type, kvsUpdate) => {
     if (actions.length === 0) {
         return '';
     }
-    const expressions = actions
-        .map((update, index) => buildDynamoUpdateExpressionPart(update, index))
-        .join(', ');
+    const expressions = actions.map((update, index) => buildDynamoUpdateExpressionPart(update, index)).join(', ');
     switch (type) {
         case KvsUpdateActionType.Set:
             return `SET ${expressions}`;
@@ -111,12 +109,7 @@ export const buildDynamoUpdateExpressionForType = (type, kvsUpdate) => {
     }
 };
 export const buildDynamoUpdateExpression = (updates) => {
-    const updatesExpressions = [
-        KvsUpdateActionType.Set,
-        KvsUpdateActionType.Remove,
-        KvsUpdateActionType.Add,
-        KvsUpdateActionType.Delete,
-    ]
+    const updatesExpressions = [KvsUpdateActionType.Set, KvsUpdateActionType.Remove, KvsUpdateActionType.Add, KvsUpdateActionType.Delete]
         .map((kvsUpdateActionType) => buildDynamoUpdateExpressionForType(kvsUpdateActionType, updates))
         .filter((expression) => !!expression);
     const result = updatesExpressions.join(' ');

package/lib/esm/logic/dynamo/qpqDynamoOrm/getDynamoTableIndexByConfigAndQuery.js

@@ -1,4 +1,4 @@
-import { isKvsQueryCondition, isKvsLogicalOperator } from './buildDynamoQuery';
+import { isKvsLogicalOperator, isKvsQueryCondition } from './buildDynamoQuery';
 export const getDynamoTableIndexByConfigAndQuery = (setting, query) => {
     // Function to extract keys from a query
     const extractKeysFromQuery = (query) => {

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

@@ -1,9 +1,9 @@
 import { DynamoDBClient, QueryCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+import { itemsToQpqPagedData } from './utils/itemsToQpqPagedData';
 import { convertDynamoMapToObject } from './convertObjectToDynamoMap';
 import { stringToLastEvaluatedKey } from './logs';
-import { itemsToQpqPagedData } from './utils/itemsToQpqPagedData';
-import { buildExpressionAttributeValues, buildExpressionAttributeNames, buildDynamoQueryExpression, } from './qpqDynamoOrm';
-import { createAwsClient } from '../createAwsClient';
+import { buildDynamoQueryExpression, buildExpressionAttributeNames, buildExpressionAttributeValues } from './qpqDynamoOrm';
 export async function query(tableName, region, keyExpression, filterExpression, pageKey, indexName, limit, sortAscending) {
     // Instantiate DynamoDB client
     const dynamoDBClient = createAwsClient(DynamoDBClient, { region });

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

@@ -1,9 +1,9 @@
 import { DynamoDBClient, ScanCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+import { itemsToQpqPagedData } from './utils/itemsToQpqPagedData';
 import { convertDynamoMapToObject } from './convertObjectToDynamoMap';
 import { stringToLastEvaluatedKey } from './logs';
-import { itemsToQpqPagedData } from './utils/itemsToQpqPagedData';
-import { buildExpressionAttributeValues, buildExpressionAttributeNames, buildDynamoQueryExpression, } from './qpqDynamoOrm';
-import { createAwsClient } from '../createAwsClient';
+import { buildDynamoQueryExpression, buildExpressionAttributeNames, buildExpressionAttributeValues } from './qpqDynamoOrm';
 export async function scan(tableName, region, filterExpression, pageKey) {
     // Instantiate DynamoDB client
     const dynamoDBClient = createAwsClient(DynamoDBClient, { region });

package/lib/esm/logic/dynamo/updateItem.d.ts

@@ -1,2 +1,2 @@
-import { KvsUpdate, KvsCoreDataType } from 'quidproquo-core';
+import { KvsCoreDataType, KvsUpdate } from 'quidproquo-core';
 export declare function updateItem<Item>(tableName: string, region: string, update: KvsUpdate, keyName: string, key: KvsCoreDataType, sortkeyName?: string, sortKey?: KvsCoreDataType): Promise<Item>;

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

@@ -1,7 +1,7 @@
 import { DynamoDBClient, ReturnValue, UpdateItemCommand } from '@aws-sdk/client-dynamodb';
-import { buildAttributeValue, buildDynamoUpdateExpression, buildUpdateExpressionAttributeNames, buildUpdateExpressionAttributeValues, } from './qpqDynamoOrm';
 import { createAwsClient } from '../createAwsClient';
 import { convertDynamoMapToObject } from './convertObjectToDynamoMap';
+import { buildAttributeValue, buildDynamoUpdateExpression, buildUpdateExpressionAttributeNames, buildUpdateExpressionAttributeValues, } from './qpqDynamoOrm';
 export async function updateItem(tableName, region, update, keyName, key, sortkeyName, sortKey) {
     const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
     const params = {

package/lib/esm/logic/lambda/executeLambdaByName.js

@@ -1,4 +1,4 @@
-import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
+import { InvokeCommand, LambdaClient } from '@aws-sdk/client-lambda';
 import { createAwsClient } from '../createAwsClient';
 export const executeLambdaByName = async (functionName, region, payload, isAsync) => {
     const lambdaClient = createAwsClient(LambdaClient, { region });

package/lib/esm/logic/neptune/getNeptuneEndpoints.js

@@ -1,4 +1,4 @@
-import { NeptuneClient, DescribeDBClustersCommand } from '@aws-sdk/client-neptune';
+import { DescribeDBClustersCommand, NeptuneClient } from '@aws-sdk/client-neptune';
 import { createAwsClient } from '../createAwsClient';
 export const getNeptuneEndpoints = async (clusterIdentifier, region) => {
     const neptuneClient = createAwsClient(NeptuneClient, { region });

package/lib/esm/logic/parametersManager/getParameter.js

@@ -1,4 +1,4 @@
-import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm';
+import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
 import { memoFuncAsync } from '../cache/memoFuncAsync';
 import { createAwsClient } from '../createAwsClient';
 export const getParameter = memoFuncAsync(async (parameterName, region) => {

package/lib/esm/logic/parametersManager/getParameters.js

@@ -1,4 +1,4 @@
-import { SSMClient, GetParametersCommand } from '@aws-sdk/client-ssm';
+import { GetParametersCommand, SSMClient } from '@aws-sdk/client-ssm';
 import { memoFuncAsync } from '../cache/memoFuncAsync';
 import { createAwsClient } from '../createAwsClient';
 export const getParameters = memoFuncAsync(async (parameterNames, region) => {