quidproquo-actionprocessor-awslambda 0.0.254 → 0.0.255

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[]>;

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

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

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

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

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

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

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

@@ -1,39 +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;
-    }
-}
+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', // use the GSI
+        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

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