quidproquo-actionprocessor-awslambda 0.0.199 → 0.0.200

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

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

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

@@ -0,0 +1,14 @@
+import { CognitoIdentityProviderClient, AdminGetUserCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { getQpqAttributesFromCognitoUserAttributes } from './cognitoAttributeMap';
+import { createAwsClient } from '../createAwsClient';
+export const getUserAttributes = async (userPoolId, region, username) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const params = {
+        UserPoolId: userPoolId,
+        Username: username,
+    };
+    const response = await cognitoClient.send(new AdminGetUserCommand(params));
+    const validAttributes = (response.UserAttributes || []).filter((attr) => attr.Name && attr.Value);
+    const attributes = getQpqAttributesFromCognitoUserAttributes(validAttributes);
+    return attributes;
+};

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

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

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

@@ -0,0 +1,16 @@
+import { CognitoIdentityProviderClient, ListUsersCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { getQpqAttributesFromCognitoUserAttributes } from './cognitoAttributeMap';
+import { createAwsClient } from '../createAwsClient';
+export const getUserAttributesBySub = async (userPoolId, region, sub) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const response = await cognitoClient.send(new ListUsersCommand({
+        UserPoolId: userPoolId,
+        Filter: `sub = "${sub}"`,
+    }));
+    const [user] = response?.Users || [];
+    if (!user) {
+        throw new Error('User not found');
+    }
+    const validAttributes = (user.Attributes || []).filter((attr) => attr.Name && attr.Value);
+    return getQpqAttributesFromCognitoUserAttributes(validAttributes);
+};

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

@@ -0,0 +1 @@
+export declare const getUserPoolClientSecret: (userPoolId: string, clientId: string, region: string) => Promise<string>;

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

@@ -0,0 +1,14 @@
+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 params = {
+        ClientId: clientId,
+        UserPoolId: userPoolId,
+    };
+    const response = await cognitoClient.send(new DescribeUserPoolClientCommand(params));
+    if (!response.UserPoolClient?.ClientSecret) {
+        throw new Error('Can not find client secret for Cognito user pool client');
+    }
+    return response.UserPoolClient?.ClientSecret;
+};

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

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

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

@@ -0,0 +1,19 @@
+import { CognitoIdentityProviderClient, ListUsersCommand, } from '@aws-sdk/client-cognito-identity-provider';
+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 response = await cognitoClient.send(new ListUsersCommand({
+        UserPoolId: userPoolId,
+        PaginationToken: pageKeyToPaginationToken(pageKey),
+    }));
+    const users = (response.Users || []).map((user) => {
+        const validAttributes = (user.Attributes || []).filter((attr) => attr.Name && attr.Value);
+        return getQpqAttributesFromCognitoUserAttributes(validAttributes);
+    });
+    return {
+        nextPageKey: paginationTokenToPageKey(response.PaginationToken),
+        items: users,
+    };
+};

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+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 params = {
+        AccessToken: accessToken,
+        AttributeName: 'email', // Request verification for the email attribute
+    };
+    const requestEmailVerificationCodeResponse = await cognitoClient.send(new GetUserAttributeVerificationCodeCommand(params));
+};

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

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

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

@@ -0,0 +1,24 @@
+import { CognitoIdentityProviderClient, RespondToAuthChallengeCommand, ChallengeNameType, } from '@aws-sdk/client-cognito-identity-provider';
+import { calculateSecretHash } from './utils/calculateSecretHash';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
+import { cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo } from './utils/transformCognitoResponse';
+import { createAwsClient } from '../createAwsClient';
+export const respondToAuthChallengeChallenge = async (userPoolId, clientId, region, username, session, attributes) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
+    const secretHash = calculateSecretHash(username, clientId, clientSecret);
+    const params = {
+        ChallengeName: ChallengeNameType.NEW_PASSWORD_REQUIRED,
+        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

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

@@ -0,0 +1,13 @@
+import { CognitoIdentityProviderClient, AdminUpdateUserAttributesCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { getCognitoUserAttributesFromQpqUserAttributes } from './cognitoAttributeMap';
+import { createAwsClient } from '../createAwsClient';
+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

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

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

@@ -0,0 +1,13 @@
+import { CognitoIdentityProviderClient, AdminSetUserPasswordCommand, } 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+import { AuthenticateUserResponse, AuthenticationInfo, AuthenticateUserChallenge } from 'quidproquo-core';
+import { AuthenticationResultType, AdminInitiateAuthResponse, 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

@@ -0,0 +1,37 @@
+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,
+    };
+    // TODO: handle the NOT-IMP cases
+    const challenge = map[cognitoChallengeName] || `NOT-IMP-${cognitoChallengeName}`;
+    return challenge;
+};
+export const cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo = (authResponse, issueDateTime) => {
+    const res = {
+        session: authResponse.Session,
+        challenge: cognitoChallengeNameTypeToQpqAuthenticateUserChallenge(authResponse.ChallengeName),
+    };
+    if (authResponse.AuthenticationResult) {
+        res.authenticationInfo = cognitoAuthenticationResultTypeToQpqAuthenticationInfo(authResponse.AuthenticationResult, issueDateTime);
+    }
+    return res;
+};

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

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

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

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

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

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

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

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

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

@@ -0,0 +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);
+}

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { DynamoDBClient, DeleteItemCommand, } from '@aws-sdk/client-dynamodb';
+import { buildAttributeValue } from './qpqDynamoOrm';
+import { createAwsClient } from '../createAwsClient';
+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

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

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

@@ -0,0 +1,23 @@
+import { DynamoDBClient, ScanCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+export async function getAllItems(tableName, region) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    let records = [];
+    let lastEvaluatedKey;
+    do {
+        const scanParams = {
+            TableName: tableName,
+            ExclusiveStartKey: lastEvaluatedKey,
+        };
+        try {
+            const result = await dynamoDBClient.send(new ScanCommand(scanParams));
+            records = records.concat(result.Items);
+            lastEvaluatedKey = result.LastEvaluatedKey;
+        }
+        catch (error) {
+            console.error('Error scanning DynamoDB table:', error);
+            throw error;
+        }
+    } while (lastEvaluatedKey);
+    return records;
+}

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

@@ -0,0 +1 @@
+export declare function getItem(tableName: string, key: string, region: string): Promise<any | null>;

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

@@ -0,0 +1,21 @@
+import { DynamoDBClient, GetItemCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+export async function getItem(tableName, key, region) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const getItemParams = {
+        TableName: tableName,
+        Key: {
+            key: {
+                S: key,
+            },
+        },
+    };
+    try {
+        const result = await dynamoDBClient.send(new GetItemCommand(getItemParams));
+        return result.Item ? JSON.parse(result.Item.value.S) : null;
+    }
+    catch (error) {
+        console.error('Error getting item from DynamoDB:', error);
+        throw error;
+    }
+}

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

@@ -0,0 +1,2 @@
+import { StoryResultMetadata } from 'quidproquo-core';
+export declare function getLogByCorrelation(tableName: string, region: string, correlation: string): Promise<StoryResultMetadata>;

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

@@ -0,0 +1,39 @@
+import { DynamoDBClient, QueryCommand } from '@aws-sdk/client-dynamodb';
+import { createAwsClient } from '../createAwsClient';
+export async function getLogByCorrelation(tableName, region, correlation) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const queryParams = {
+        TableName: tableName,
+        IndexName: 'CorrelationIndex',
+        KeyConditionExpression: 'correlation = :correlation',
+        ExpressionAttributeValues: {
+            ':correlation': { S: correlation },
+        },
+    };
+    try {
+        const queryResult = await dynamoDBClient.send(new QueryCommand(queryParams));
+        const items = (queryResult.Items || []).map((i) => {
+            const [startedAt, correlation] = i.startedAtWithCorrelation.S?.split('#') || [];
+            const metaData = {
+                generic: i.generic.S || '',
+                runtimeType: i.runtimeType.S,
+                error: i.error?.S,
+                startedAt: startedAt,
+                correlation,
+                moduleName: i.moduleName.S || '',
+                fromCorrelation: i.fromCorrelation?.S,
+                executionTimeMs: i.executionTimeMs?.N ? parseInt(i.executionTimeMs.N) : 0,
+            };
+            return metaData;
+        });
+        const [result] = items;
+        if (!result) {
+            throw new Error(`Failed to find log with correlation: ${correlation}`);
+        }
+        return result;
+    }
+    catch (err) {
+        console.error(`Failed to find log: ${err}`);
+        throw err;
+    }
+}

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

@@ -0,0 +1,2 @@
+import { QpqLogList } from 'quidproquo-webserver';
+export declare function getLogChildrenByFromCorrelation(tableName: string, region: string, fromCorrelation: string, pageKey?: string): Promise<QpqLogList>;

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

@@ -0,0 +1,49 @@
+import { DynamoDBClient, QueryCommand } from '@aws-sdk/client-dynamodb';
+import { lastEvaluatedKeyToString, stringToLastEvaluatedKey } from './logs';
+import { createAwsClient } from '../createAwsClient';
+export async function getLogChildrenByFromCorrelation(tableName, region, fromCorrelation, pageKey) {
+    const dynamoDBClient = createAwsClient(DynamoDBClient, { region });
+    const queryParams = {
+        TableName: tableName,
+        // removed IndexName
+        KeyConditionExpression: '#fromCorrelation = :fromCorrelation',
+        ExpressionAttributeNames: {
+            '#fromCorrelation': 'fromCorrelation', // define attribute name
+        },
+        ExpressionAttributeValues: {
+            ':fromCorrelation': { S: fromCorrelation },
+        },
+    };
+    if (pageKey) {
+        queryParams.ExclusiveStartKey = stringToLastEvaluatedKey(pageKey);
+    }
+    try {
+        const queryResult = await dynamoDBClient.send(new QueryCommand(queryParams));
+        const items = (queryResult.Items || []).map((i) => {
+            const [startedAt, correlation] = i.startedAtWithCorrelation.S?.split('#') || [];
+            const metaData = {
+                generic: i.generic.S || '',
+                runtimeType: i.runtimeType.S,
+                error: i.error?.S,
+                startedAt: startedAt,
+                correlation,
+                moduleName: i.moduleName.S || '',
+                fromCorrelation: i.fromCorrelation?.S,
+                executionTimeMs: i.executionTimeMs?.N ? parseInt(i.executionTimeMs.N) : 0,
+            };
+            return metaData;
+        });
+        if (queryResult.LastEvaluatedKey) {
+            const nextPageKey = lastEvaluatedKeyToString(queryResult.LastEvaluatedKey);
+            // You can return the nextPageKey along with the items, so it can be used for the next query.
+            return { items, nextPageKey };
+        }
+        else {
+            return { items };
+        }
+    }
+    catch (err) {
+        console.error(`Failed to query items with the specified fromCorrelation: ${err}`);
+        throw err;
+    }
+}

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

@@ -0,0 +1,2 @@
+import { QpqLogList } from 'quidproquo-webserver';
+export declare function getPagedItemsOverRange(tableName: string, region: string, runtimeType: string, startIsoDateTime: string, endIsoDateTime: string, pageKey?: string): Promise<QpqLogList>;