quidproquo-actionprocessor-awslambda 0.0.254 → 0.0.256

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

@@ -1,26 +1,26 @@
-import { CognitoIdentityProviderClient, RespondToAuthChallengeCommand, } from '@aws-sdk/client-cognito-identity-provider';
-import { createAwsClient } from '../createAwsClient';
-import { calculateSecretHash } from './utils/calculateSecretHash';
-import { cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo } from './utils/transformCognitoResponse';
-import { getUserPoolClientSecret } from './getUserPoolClientSecret';
-export const respondToAuthChallengeChallenge = async (userPoolId, clientId, region, username, session, challengeNameType, attributes) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
-        region,
-    });
-    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
-    const secretHash = calculateSecretHash(username, clientId, clientSecret);
-    const params = {
-        ChallengeName: challengeNameType,
-        ClientId: clientId,
-        Session: session,
-        ChallengeResponses: {
-            USERNAME: username,
-            SECRET_HASH: secretHash,
-            ...attributes,
-        },
-    };
-    const issueDateTime = new Date().toISOString();
-    const response = await cognitoClient.send(new RespondToAuthChallengeCommand(params));
-    // transform the response into your custom format, similar to your refreshToken function
-    return cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo(response, issueDateTime);
-};
+import { CognitoIdentityProviderClient, RespondToAuthChallengeCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
+import { calculateSecretHash } from './utils/calculateSecretHash';
+import { cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo } from './utils/transformCognitoResponse';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
+export const respondToAuthChallengeChallenge = async (userPoolId, clientId, region, username, session, challengeNameType, attributes) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
+    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
+    const secretHash = calculateSecretHash(username, clientId, clientSecret);
+    const params = {
+        ChallengeName: challengeNameType,
+        ClientId: clientId,
+        Session: session,
+        ChallengeResponses: {
+            USERNAME: username,
+            SECRET_HASH: secretHash,
+            ...attributes,
+        },
+    };
+    const issueDateTime = new Date().toISOString();
+    const response = await cognitoClient.send(new RespondToAuthChallengeCommand(params));
+    // transform the response into your custom format, similar to your refreshToken function
+    return cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo(response, issueDateTime);
+};

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

@@ -1,2 +1,2 @@
-import { UserAttributes } from 'quidproquo-core';
-export declare const setUserAttributes: (userPoolId: string, region: string, username: string, userAttributes: UserAttributes) => Promise<void>;
+import { UserAttributes } from 'quidproquo-core';
+export declare const setUserAttributes: (userPoolId: string, region: string, username: string, userAttributes: UserAttributes) => Promise<void>;

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

@@ -1,15 +1,15 @@
-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 { userId, ...writeableUserAttributes } = userAttributes;
-    const params = {
-        UserPoolId: userPoolId,
-        Username: username,
-        UserAttributes: getCognitoUserAttributesFromQpqUserAttributes(writeableUserAttributes),
-    };
-    await cognitoClient.send(new AdminUpdateUserAttributesCommand(params));
-};
+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 { userId, ...writeableUserAttributes } = userAttributes;
+    const params = {
+        UserPoolId: userPoolId,
+        Username: username,
+        UserAttributes: getCognitoUserAttributesFromQpqUserAttributes(writeableUserAttributes),
+    };
+    await cognitoClient.send(new AdminUpdateUserAttributesCommand(params));
+};

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

@@ -1 +1 @@
-export declare const setUserPassword: (region: string, userPoolId: string, username: string, password: string) => Promise<void>;
+export declare const setUserPassword: (region: string, userPoolId: string, username: string, password: string) => Promise<void>;

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

@@ -1,15 +1,15 @@
-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,
-    });
-    // There has to be a better way than this?
-    const passwordParams = {
-        Password: password,
-        Username: username,
-        UserPoolId: userPoolId,
-        Permanent: true,
-    };
-    await cognitoClient.send(new AdminSetUserPasswordCommand(passwordParams));
-};
+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,
+    });
+    // There has to be a better way than this?
+    const passwordParams = {
+        Password: password,
+        Username: username,
+        UserPoolId: userPoolId,
+        Permanent: true,
+    };
+    await cognitoClient.send(new AdminSetUserPasswordCommand(passwordParams));
+};

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

@@ -1 +1 @@
-export declare const calculateSecretHash: (username: string, clientId: string, clientSecret: string) => string;
+export declare const calculateSecretHash: (username: string, clientId: string, clientSecret: string) => string;

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

@@ -1,10 +1,10 @@
-import { createHmac } from 'crypto';
-import { memoFunc } from '../../cache/memoFunc';
-export const calculateSecretHash = memoFunc((username, clientId, clientSecret) => {
-    // create the hmac with the sha256 algorithm and a secret key
-    const hasher = createHmac('sha256', clientSecret);
-    // add the value we want to hash
-    hasher.update(`${username}${clientId}`);
-    // get the hashed value as base64
-    return hasher.digest('base64');
-});
+import { createHmac } from 'crypto';
+import { memoFunc } from '../../cache/memoFunc';
+export const calculateSecretHash = memoFunc((username, clientId, clientSecret) => {
+    // create the hmac with the sha256 algorithm and a secret key
+    const hasher = createHmac('sha256', clientSecret);
+    // add the value we want to hash
+    hasher.update(`${username}${clientId}`);
+    // get the hashed value as base64
+    return hasher.digest('base64');
+});

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

@@ -1,4 +1,4 @@
-export * from './calculateSecretHash';
-export * from './pageKeyToPaginationToken';
-export * from './paginationTokenToPageKey';
-export * from './transformCognitoResponse';
+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 './pageKeyToPaginationToken';
-export * from './paginationTokenToPageKey';
-export * from './transformCognitoResponse';
+export * from './calculateSecretHash';
+export * from './pageKeyToPaginationToken';
+export * from './paginationTokenToPageKey';
+export * from './transformCognitoResponse';

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

@@ -1 +1 @@
-export declare function pageKeyToPaginationToken(pageKey?: string): string | undefined;
+export declare function pageKeyToPaginationToken(pageKey?: string): string | undefined;

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

@@ -1,6 +1,6 @@
-export function pageKeyToPaginationToken(pageKey) {
-    if (!pageKey) {
-        return undefined;
-    }
-    return Buffer.from(pageKey, 'base64').toString();
-}
+export function pageKeyToPaginationToken(pageKey) {
+    if (!pageKey) {
+        return undefined;
+    }
+    return Buffer.from(pageKey, 'base64').toString();
+}

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

@@ -1 +1 @@
-export declare function paginationTokenToPageKey(paginationToken?: string): string | undefined;
+export declare function paginationTokenToPageKey(paginationToken?: string): string | undefined;

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

@@ -1,6 +1,6 @@
-export function paginationTokenToPageKey(paginationToken) {
-    if (!paginationToken) {
-        return undefined;
-    }
-    return Buffer.from(paginationToken).toString('base64');
-}
+export function paginationTokenToPageKey(paginationToken) {
+    if (!paginationToken) {
+        return undefined;
+    }
+    return Buffer.from(paginationToken).toString('base64');
+}

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

@@ -1,5 +1,5 @@
-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;
+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/utils/transformCognitoResponse.js

@@ -1,39 +1,39 @@
-import { AuthenticateUserChallenge } from 'quidproquo-core';
-import { ChallengeNameType } from '@aws-sdk/client-cognito-identity-provider';
-export const cognitoAuthenticationResultTypeToQpqAuthenticationInfo = (authResult, issueDateTime) => {
-    // Parse the issueDateTime and add the expiresIn to get the expiration date
-    let issueDate = new Date(issueDateTime);
-    issueDate.setSeconds(issueDate.getSeconds() + (authResult.ExpiresIn || 0));
-    const expiresAt = issueDate.toISOString();
-    return {
-        accessToken: authResult.AccessToken,
-        idToken: authResult.IdToken,
-        refreshToken: authResult.RefreshToken,
-        tokenType: authResult.TokenType,
-        expirationDurationInSeconds: authResult.ExpiresIn,
-        expiresAt,
-    };
-};
-export const cognitoChallengeNameTypeToQpqAuthenticateUserChallenge = (cognitoChallengeName) => {
-    if (!cognitoChallengeName) {
-        return AuthenticateUserChallenge.NONE;
-    }
-    const map = {
-        [ChallengeNameType.NEW_PASSWORD_REQUIRED]: AuthenticateUserChallenge.NEW_PASSWORD_REQUIRED,
-        [ChallengeNameType.CUSTOM_CHALLENGE]: AuthenticateUserChallenge.CUSTOM_CHALLENGE,
-    };
-    // TODO: handle the NOT-IMP cases
-    const challenge = map[cognitoChallengeName] || `QPQ-NOT-IMP-${cognitoChallengeName}`;
-    return challenge;
-};
-export const cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo = (authResponse, issueDateTime) => {
-    const res = {
-        session: authResponse.Session,
-        challenge: cognitoChallengeNameTypeToQpqAuthenticateUserChallenge(authResponse.ChallengeName),
-        challengeParameters: authResponse.ChallengeParameters,
-    };
-    if (authResponse.AuthenticationResult) {
-        res.authenticationInfo = cognitoAuthenticationResultTypeToQpqAuthenticationInfo(authResponse.AuthenticationResult, issueDateTime);
-    }
-    return res;
-};
+import { AuthenticateUserChallenge } from 'quidproquo-core';
+import { ChallengeNameType } from '@aws-sdk/client-cognito-identity-provider';
+export const cognitoAuthenticationResultTypeToQpqAuthenticationInfo = (authResult, issueDateTime) => {
+    // Parse the issueDateTime and add the expiresIn to get the expiration date
+    let issueDate = new Date(issueDateTime);
+    issueDate.setSeconds(issueDate.getSeconds() + (authResult.ExpiresIn || 0));
+    const expiresAt = issueDate.toISOString();
+    return {
+        accessToken: authResult.AccessToken,
+        idToken: authResult.IdToken,
+        refreshToken: authResult.RefreshToken,
+        tokenType: authResult.TokenType,
+        expirationDurationInSeconds: authResult.ExpiresIn,
+        expiresAt,
+    };
+};
+export const cognitoChallengeNameTypeToQpqAuthenticateUserChallenge = (cognitoChallengeName) => {
+    if (!cognitoChallengeName) {
+        return AuthenticateUserChallenge.NONE;
+    }
+    const map = {
+        [ChallengeNameType.NEW_PASSWORD_REQUIRED]: AuthenticateUserChallenge.NEW_PASSWORD_REQUIRED,
+        [ChallengeNameType.CUSTOM_CHALLENGE]: AuthenticateUserChallenge.CUSTOM_CHALLENGE,
+    };
+    // TODO: handle the NOT-IMP cases
+    const challenge = map[cognitoChallengeName] || `QPQ-NOT-IMP-${cognitoChallengeName}`;
+    return challenge;
+};
+export const cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo = (authResponse, issueDateTime) => {
+    const res = {
+        session: authResponse.Session,
+        challenge: cognitoChallengeNameTypeToQpqAuthenticateUserChallenge(authResponse.ChallengeName),
+        challengeParameters: authResponse.ChallengeParameters,
+    };
+    if (authResponse.AuthenticationResult) {
+        res.authenticationInfo = cognitoAuthenticationResultTypeToQpqAuthenticationInfo(authResponse.AuthenticationResult, issueDateTime);
+    }
+    return res;
+};

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

@@ -1 +1 @@
-export declare const verifyJwt: (accessToken: string, userPoolId: string, region: string, ignoreExpiration?: boolean) => Promise<boolean>;
+export declare const verifyJwt: (accessToken: string, userPoolId: string, region: string, ignoreExpiration?: boolean) => Promise<boolean>;

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

@@ -1,6 +1,6 @@
-import { decodeValidJwt } from './decodeValidJwt';
-export const verifyJwt = async (accessToken, userPoolId, region, ignoreExpiration = false) => {
-    const info = await decodeValidJwt(userPoolId, region, ignoreExpiration, accessToken);
-    // if we hav info, its valid
-    return !!info;
-};
+import { decodeValidJwt } from './decodeValidJwt';
+export const verifyJwt = async (accessToken, userPoolId, region, ignoreExpiration = false) => {
+    const info = await decodeValidJwt(userPoolId, region, ignoreExpiration, accessToken);
+    // if we hav info, its valid
+    return !!info;
+};

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

@@ -1 +1 @@
-export declare const verifyUserEmail: (region: string, accessToken: string, verificationCode: string) => Promise<void>;
+export declare const verifyUserEmail: (region: string, accessToken: string, verificationCode: string) => Promise<void>;

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

@@ -1,13 +1,13 @@
-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 params = {
-        AccessToken: accessToken,
-        AttributeName: 'email',
-        Code: verificationCode,
-    };
-    await cognitoClient.send(new VerifyUserAttributeCommand(params));
-};
+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 params = {
+        AccessToken: accessToken,
+        AttributeName: 'email',
+        Code: verificationCode,
+    };
+    await cognitoClient.send(new VerifyUserAttributeCommand(params));
+};

package/lib/esm/logic/createAwsClient.d.ts

@@ -1,3 +1,3 @@
-type ClientConstructor<T> = new (args: any) => T;
-export declare function createAwsClient<T>(ClientClass: ClientConstructor<T>, args: any): T;
-export {};
+type ClientConstructor<T> = new (args: any) => T;
+export declare function createAwsClient<T>(ClientClass: ClientConstructor<T>, args: any): T;
+export {};

package/lib/esm/logic/createAwsClient.js

@@ -1,32 +1,32 @@
-const cache = new WeakMap();
-export function createAwsClient(ClientClass, args) {
-    // Get or create the Map for the ClientClass
-    let argsCache = cache.get(ClientClass);
-    if (!argsCache) {
-        argsCache = new Map();
-        cache.set(ClientClass, argsCache);
-    }
-    // Generate a key for the arguments
-    const argsKey = JSON.stringify(args);
-    // Check if the instance already exists in the cache
-    if (!argsCache.has(argsKey)) {
-        const newClient = new ClientClass(args);
-        // If the send method exists, wrap it with error handling so we can see it in the logs
-        if (typeof newClient.send === 'function') {
-            const originalSend = newClient.send;
-            newClient.send = async function (...sendArgs) {
-                try {
-                    return await originalSend.apply(this, sendArgs);
-                }
-                catch (error) {
-                    console.log(ClientClass.name || 'aws client', args, 'send args', sendArgs, 'error', error.message);
-                    throw error;
-                }
-            };
-        }
-        // Create a new instance and store it in the cache
-        argsCache.set(argsKey, newClient);
-    }
-    // Return the cached instance
-    return argsCache.get(argsKey);
-}
+const cache = new WeakMap();
+export function createAwsClient(ClientClass, args) {
+    // Get or create the Map for the ClientClass
+    let argsCache = cache.get(ClientClass);
+    if (!argsCache) {
+        argsCache = new Map();
+        cache.set(ClientClass, argsCache);
+    }
+    // Generate a key for the arguments
+    const argsKey = JSON.stringify(args);
+    // Check if the instance already exists in the cache
+    if (!argsCache.has(argsKey)) {
+        const newClient = new ClientClass(args);
+        // If the send method exists, wrap it with error handling so we can see it in the logs
+        if (typeof newClient.send === 'function') {
+            const originalSend = newClient.send;
+            newClient.send = async function (...sendArgs) {
+                try {
+                    return await originalSend.apply(this, sendArgs);
+                }
+                catch (error) {
+                    console.log(ClientClass.name || 'aws client', args, 'send args', sendArgs, 'error', error.message);
+                    throw error;
+                }
+            };
+        }
+        // Create a new instance and store it in the cache
+        argsCache.set(argsKey, newClient);
+    }
+    // Return the cached instance
+    return argsCache.get(argsKey);
+}

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

@@ -1 +1 @@
-export declare function convertDynamoMapToObject(dynamoMap: any): any;
+export declare function convertDynamoMapToObject(dynamoMap: any): any;

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

@@ -1,63 +1,63 @@
-// Deprecated: 2021-06-01
-// export function convertObjectToDynamoMap(obj: any) {
-//   const map: any = {};
-//   for (const property in obj) {
-//     const value = obj[property];
-//     const valueType = typeof value;
-//     switch (valueType) {
-//       case 'string':
-//         map[property] = { S: value };
-//         break;
-//       case 'number':
-//         map[property] = { N: value.toString() };
-//         break;
-//       case 'boolean':
-//         map[property] = { BOOL: value };
-//         break;
-//       case 'object':
-//         if (Array.isArray(value)) {
-//           map[property] = {
-//             L: value.map((item) => convertObjectToDynamoMap({ temp: item }).temp),
-//           };
-//         } else if (value !== null) {
-//           map[property] = { M: convertObjectToDynamoMap(value) };
-//         } else {
-//           map[property] = { NULL: true };
-//         }
-//         break;
-//       default:
-//         throw new Error(`Unsupported data type: ${valueType}`);
-//     }
-//   }
-//   return map;
-// }
-export function convertDynamoMapToObject(dynamoMap) {
-    const obj = {};
-    for (const property in dynamoMap) {
-        const value = dynamoMap[property];
-        const valueType = Object.keys(value)[0];
-        switch (valueType) {
-            case 'S':
-                obj[property] = value.S;
-                break;
-            case 'N':
-                obj[property] = parseFloat(value.N);
-                break;
-            case 'BOOL':
-                obj[property] = value.BOOL;
-                break;
-            case 'NULL':
-                obj[property] = null;
-                break;
-            case 'L':
-                obj[property] = value.L.map((item) => convertDynamoMapToObject({ temp: item }).temp);
-                break;
-            case 'M':
-                obj[property] = convertDynamoMapToObject(value.M);
-                break;
-            default:
-                throw new Error(`Unsupported DynamoDB data type: ${valueType}`);
-        }
-    }
-    return obj;
-}
+// Deprecated: 2021-06-01
+// export function convertObjectToDynamoMap(obj: any) {
+//   const map: any = {};
+//   for (const property in obj) {
+//     const value = obj[property];
+//     const valueType = typeof value;
+//     switch (valueType) {
+//       case 'string':
+//         map[property] = { S: value };
+//         break;
+//       case 'number':
+//         map[property] = { N: value.toString() };
+//         break;
+//       case 'boolean':
+//         map[property] = { BOOL: value };
+//         break;
+//       case 'object':
+//         if (Array.isArray(value)) {
+//           map[property] = {
+//             L: value.map((item) => convertObjectToDynamoMap({ temp: item }).temp),
+//           };
+//         } else if (value !== null) {
+//           map[property] = { M: convertObjectToDynamoMap(value) };
+//         } else {
+//           map[property] = { NULL: true };
+//         }
+//         break;
+//       default:
+//         throw new Error(`Unsupported data type: ${valueType}`);
+//     }
+//   }
+//   return map;
+// }
+export function convertDynamoMapToObject(dynamoMap) {
+    const obj = {};
+    for (const property in dynamoMap) {
+        const value = dynamoMap[property];
+        const valueType = Object.keys(value)[0];
+        switch (valueType) {
+            case 'S':
+                obj[property] = value.S;
+                break;
+            case 'N':
+                obj[property] = parseFloat(value.N);
+                break;
+            case 'BOOL':
+                obj[property] = value.BOOL;
+                break;
+            case 'NULL':
+                obj[property] = null;
+                break;
+            case 'L':
+                obj[property] = value.L.map((item) => convertDynamoMapToObject({ temp: item }).temp);
+                break;
+            case 'M':
+                obj[property] = convertDynamoMapToObject(value.M);
+                break;
+            default:
+                throw new Error(`Unsupported DynamoDB data type: ${valueType}`);
+        }
+    }
+    return obj;
+}

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

@@ -1,2 +1,2 @@
-import { KvsCoreDataType } from 'quidproquo-core';
-export declare function deleteItem(tableName: string, region: string, key: KvsCoreDataType, keyName: string, sortKey?: KvsCoreDataType, sortKeyName?: string): Promise<void>;
+import { KvsCoreDataType } from 'quidproquo-core';
+export declare function deleteItem(tableName: string, region: string, key: KvsCoreDataType, keyName: string, sortKey?: KvsCoreDataType, sortKeyName?: string): Promise<void>;

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

@@ -1,16 +1,16 @@
-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 = {
-        TableName: tableName,
-        Key: {
-            [keyName]: buildAttributeValue(key),
-        },
-    };
-    if (sortKey && sortKeyName) {
-        deleteItemParams.Key[sortKeyName] = buildAttributeValue(sortKey);
-    }
-    await dynamoDBClient.send(new DeleteItemCommand(deleteItemParams));
-}
+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 = {
+        TableName: tableName,
+        Key: {
+            [keyName]: buildAttributeValue(key),
+        },
+    };
+    if (sortKey && sortKeyName) {
+        deleteItemParams.Key[sortKeyName] = buildAttributeValue(sortKey);
+    }
+    await dynamoDBClient.send(new DeleteItemCommand(deleteItemParams));
+}

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

@@ -1 +1 @@
-export declare function getAllItems(tableName: string, region: string): Promise<any[]>;
+export declare function getAllItems(tableName: string, region: string): Promise<any[]>;