quidproquo-actionprocessor-awslambda 0.0.254 → 0.0.256

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

@@ -1,16 +1,16 @@
-import { ApiGatewayManagementApiClient, PostToConnectionCommand } from '@aws-sdk/client-apigatewaymanagementapi';
-import { createAwsClient } from '../createAwsClient';
-export const sendMessageToWebSocketConnection = async (apiId, connectionId, region, payload) => {
-    // Create a new ApiGatewayManagementApiClient
-    const apiGatewayManagementApiClient = createAwsClient(ApiGatewayManagementApiClient, {
-        apiVersion: '2018-11-29',
-        endpoint: `https://${apiId}.execute-api.${region}.amazonaws.com/prod`,
-        region,
-    });
-    // Create a new PostToConnectionCommand with the connection ID and payload
-    const command = new PostToConnectionCommand({
-        ConnectionId: connectionId,
-        Data: JSON.stringify(payload), // Convert payload to string if necessary
-    });
-    await apiGatewayManagementApiClient.send(command);
-};
+import { ApiGatewayManagementApiClient, PostToConnectionCommand } from '@aws-sdk/client-apigatewaymanagementapi';
+import { createAwsClient } from '../createAwsClient';
+export const sendMessageToWebSocketConnection = async (apiId, connectionId, region, payload) => {
+    // Create a new ApiGatewayManagementApiClient
+    const apiGatewayManagementApiClient = createAwsClient(ApiGatewayManagementApiClient, {
+        apiVersion: '2018-11-29',
+        endpoint: `https://${apiId}.execute-api.${region}.amazonaws.com/prod`,
+        region,
+    });
+    // Create a new PostToConnectionCommand with the connection ID and payload
+    const command = new PostToConnectionCommand({
+        ConnectionId: connectionId,
+        Data: JSON.stringify(payload), // Convert payload to string if necessary
+    });
+    await apiGatewayManagementApiClient.send(command);
+};

package/lib/esm/logic/cache/memoFunc.d.ts

@@ -1,7 +1,7 @@
-/**
- * Memoizes a function by caching its return values.
- * @param func The function to memoize.
- * @param ttlInSeconds Time-to-live for the cached values in seconds.
- * @returns The memoized function.
- */
-export declare const memoFunc: <T extends (...args: any[]) => any>(func: T, ttlInSeconds?: number) => T;
+/**
+ * Memoizes a function by caching its return values.
+ * @param func The function to memoize.
+ * @param ttlInSeconds Time-to-live for the cached values in seconds.
+ * @returns The memoized function.
+ */
+export declare const memoFunc: <T extends (...args: any[]) => any>(func: T, ttlInSeconds?: number) => T;

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

@@ -1,28 +1,28 @@
-import NodeCache from 'node-cache';
-const cache = new WeakMap();
-/**
- * Memoizes a function by caching its return values.
- * @param func The function to memoize.
- * @param ttlInSeconds Time-to-live for the cached values in seconds.
- * @returns The memoized function.
- */
-export const memoFunc = (func, ttlInSeconds = 3600) => {
-    return ((...args) => {
-        // Check if the function has a corresponding cache entry
-        if (!cache.has(func)) {
-            // Create a new NodeCache instance and store it in the cache
-            cache.set(func, new NodeCache({ stdTTL: ttlInSeconds }));
-        }
-        const cacheKey = JSON.stringify(args);
-        const nodeCache = cache.get(func);
-        const cachedValue = nodeCache.get(cacheKey);
-        if (cachedValue) {
-            return cachedValue;
-        }
-        // Call the original function if the value is not cached
-        const result = func(...args);
-        // Cache the result for future use
-        nodeCache.set(cacheKey, result);
-        return result;
-    });
-};
+import NodeCache from 'node-cache';
+const cache = new WeakMap();
+/**
+ * Memoizes a function by caching its return values.
+ * @param func The function to memoize.
+ * @param ttlInSeconds Time-to-live for the cached values in seconds.
+ * @returns The memoized function.
+ */
+export const memoFunc = (func, ttlInSeconds = 3600) => {
+    return ((...args) => {
+        // Check if the function has a corresponding cache entry
+        if (!cache.has(func)) {
+            // Create a new NodeCache instance and store it in the cache
+            cache.set(func, new NodeCache({ stdTTL: ttlInSeconds }));
+        }
+        const cacheKey = JSON.stringify(args);
+        const nodeCache = cache.get(func);
+        const cachedValue = nodeCache.get(cacheKey);
+        if (cachedValue) {
+            return cachedValue;
+        }
+        // Call the original function if the value is not cached
+        const result = func(...args);
+        // Cache the result for future use
+        nodeCache.set(cacheKey, result);
+        return result;
+    });
+};

package/lib/esm/logic/cache/memoFuncAsync.d.ts

@@ -1,7 +1,7 @@
-/**
- * Memoizes a function by caching its return values.
- * @param func The function to memoize.
- * @param ttlInSeconds Time-to-live for the cached values in seconds.
- * @returns The memoized function.
- */
-export declare const memoFuncAsync: <T extends (...args: any[]) => any>(func: T, ttlInSeconds?: number) => T;
+/**
+ * Memoizes a function by caching its return values.
+ * @param func The function to memoize.
+ * @param ttlInSeconds Time-to-live for the cached values in seconds.
+ * @returns The memoized function.
+ */
+export declare const memoFuncAsync: <T extends (...args: any[]) => any>(func: T, ttlInSeconds?: number) => T;

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

@@ -1,25 +1,25 @@
-import NodeCache from 'node-cache';
-const cache = new WeakMap();
-/**
- * Memoizes a function by caching its return values.
- * @param func The function to memoize.
- * @param ttlInSeconds Time-to-live for the cached values in seconds.
- * @returns The memoized function.
- */
-export const memoFuncAsync = (func, ttlInSeconds = 3600) => {
-    return (async (...args) => {
-        if (!cache.has(func)) {
-            cache.set(func, new NodeCache({ stdTTL: ttlInSeconds }));
-        }
-        const cacheKey = JSON.stringify(args);
-        const nodeCache = cache.get(func);
-        if (nodeCache.has(cacheKey)) {
-            return nodeCache.get(cacheKey);
-        }
-        // Await the result
-        const result = await func(...args);
-        // and then cache it
-        nodeCache.set(cacheKey, result);
-        return result;
-    });
-};
+import NodeCache from 'node-cache';
+const cache = new WeakMap();
+/**
+ * Memoizes a function by caching its return values.
+ * @param func The function to memoize.
+ * @param ttlInSeconds Time-to-live for the cached values in seconds.
+ * @returns The memoized function.
+ */
+export const memoFuncAsync = (func, ttlInSeconds = 3600) => {
+    return (async (...args) => {
+        if (!cache.has(func)) {
+            cache.set(func, new NodeCache({ stdTTL: ttlInSeconds }));
+        }
+        const cacheKey = JSON.stringify(args);
+        const nodeCache = cache.get(func);
+        if (nodeCache.has(cacheKey)) {
+            return nodeCache.get(cacheKey);
+        }
+        // Await the result
+        const result = await func(...args);
+        // and then cache it
+        nodeCache.set(cacheKey, result);
+        return result;
+    });
+};

package/lib/esm/logic/cloudFront/invalidateCache.d.ts

@@ -1,2 +1,2 @@
-export declare const getInvalidationCallerReference: (paths: string[]) => string;
-export declare const invalidateCache: (distributionId: string, region: string, paths: string[]) => Promise<void>;
+export declare const getInvalidationCallerReference: (paths: string[]) => string;
+export declare const invalidateCache: (distributionId: string, region: string, paths: string[]) => Promise<void>;

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

@@ -1,24 +1,24 @@
-import crypto from 'crypto';
-import { CloudFrontClient, CreateInvalidationCommand } from '@aws-sdk/client-cloudfront';
-import { createAwsClient } from '../createAwsClient';
-export const getInvalidationCallerReference = (paths) => {
-    const allPaths = paths.join('');
-    // All paths as a hash
-    const allPathHash = crypto.createHash('md5').update(allPaths).digest('hex');
-    // Unique key is the now time with all paths hash
-    return allPathHash + new Date().toISOString();
-};
-export const invalidateCache = async (distributionId, region, paths) => {
-    const cloudFrontClient = createAwsClient(CloudFrontClient, { region });
-    const input = {
-        DistributionId: distributionId,
-        InvalidationBatch: {
-            Paths: {
-                Quantity: paths.length,
-                Items: paths,
-            },
-            CallerReference: getInvalidationCallerReference(paths),
-        },
-    };
-    await cloudFrontClient.send(new CreateInvalidationCommand(input));
-};
+import crypto from 'crypto';
+import { CloudFrontClient, CreateInvalidationCommand } from '@aws-sdk/client-cloudfront';
+import { createAwsClient } from '../createAwsClient';
+export const getInvalidationCallerReference = (paths) => {
+    const allPaths = paths.join('');
+    // All paths as a hash
+    const allPathHash = crypto.createHash('md5').update(allPaths).digest('hex');
+    // Unique key is the now time with all paths hash
+    return allPathHash + new Date().toISOString();
+};
+export const invalidateCache = async (distributionId, region, paths) => {
+    const cloudFrontClient = createAwsClient(CloudFrontClient, { region });
+    const input = {
+        DistributionId: distributionId,
+        InvalidationBatch: {
+            Paths: {
+                Quantity: paths.length,
+                Items: paths,
+            },
+            CallerReference: getInvalidationCallerReference(paths),
+        },
+    };
+    await cloudFrontClient.send(new CreateInvalidationCommand(input));
+};

package/lib/esm/logic/cloudformation/getExportedValue.d.ts

@@ -1 +1 @@
-export declare const getExportedValue: (variableName: string, region: string) => Promise<string>;
+export declare const getExportedValue: (variableName: string, region: string) => Promise<string>;

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

@@ -1,17 +1,17 @@
-import { CloudFormationClient, ListExportsCommand } from '@aws-sdk/client-cloudformation';
-import { memoFuncAsync } from '../cache/memoFuncAsync';
-import { createAwsClient } from '../createAwsClient';
-export const getExportedValue = memoFuncAsync(async (variableName, region) => {
-    const cloudformation = createAwsClient(CloudFormationClient, { region });
-    const listCommandParams = {};
-    do {
-        const result = await cloudformation.send(new ListExportsCommand(listCommandParams));
-        const value = (result.Exports || []).find((e) => e.Name === variableName)?.Value;
-        if (value !== undefined) {
-            console.log(`CF Found: [${variableName}] = [${value}]`);
-            return value;
-        }
-        listCommandParams.NextToken = result.NextToken;
-    } while (listCommandParams.NextToken);
-    throw new Error(`CF could not find: [${variableName}]`);
-});
+import { CloudFormationClient, ListExportsCommand } from '@aws-sdk/client-cloudformation';
+import { memoFuncAsync } from '../cache/memoFuncAsync';
+import { createAwsClient } from '../createAwsClient';
+export const getExportedValue = memoFuncAsync(async (variableName, region) => {
+    const cloudformation = createAwsClient(CloudFormationClient, { region });
+    const listCommandParams = {};
+    do {
+        const result = await cloudformation.send(new ListExportsCommand(listCommandParams));
+        const value = (result.Exports || []).find((e) => e.Name === variableName)?.Value;
+        if (value !== undefined) {
+            console.log(`CF Found: [${variableName}] = [${value}]`);
+            return value;
+        }
+        listCommandParams.NextToken = result.NextToken;
+    } while (listCommandParams.NextToken);
+    throw new Error(`CF could not find: [${variableName}]`);
+});

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

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

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

@@ -1,29 +1,29 @@
-import { AdminInitiateAuthCommand, AuthFlowType, CognitoIdentityProviderClient, } 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';
-// TODO: retry for TooManyRequestsException
-export const authenticateUser = async (userPoolId, clientId, region, isCustom, username, password) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
-        region,
-    });
-    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
-    const secretHash = calculateSecretHash(username, clientId, clientSecret);
-    // Time we issued the request
-    const issueDateTime = new Date().toISOString();
-    const params = {
-        AuthFlow: isCustom ? AuthFlowType.CUSTOM_AUTH : AuthFlowType.ADMIN_USER_PASSWORD_AUTH,
-        UserPoolId: userPoolId,
-        ClientId: clientId,
-        AuthParameters: {
-            USERNAME: username,
-            SECRET_HASH: secretHash,
-        },
-    };
-    if (password) {
-        params.AuthParameters.PASSWORD = password;
-    }
-    const response = await cognitoClient.send(new AdminInitiateAuthCommand(params));
-    return cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo(response, issueDateTime);
-};
+import { AdminInitiateAuthCommand, AuthFlowType, CognitoIdentityProviderClient, } 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';
+// TODO: retry for TooManyRequestsException
+export const authenticateUser = async (userPoolId, clientId, region, isCustom, username, password) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
+    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
+    const secretHash = calculateSecretHash(username, clientId, clientSecret);
+    // Time we issued the request
+    const issueDateTime = new Date().toISOString();
+    const params = {
+        AuthFlow: isCustom ? AuthFlowType.CUSTOM_AUTH : AuthFlowType.ADMIN_USER_PASSWORD_AUTH,
+        UserPoolId: userPoolId,
+        ClientId: clientId,
+        AuthParameters: {
+            USERNAME: username,
+            SECRET_HASH: secretHash,
+        },
+    };
+    if (password) {
+        params.AuthParameters.PASSWORD = password;
+    }
+    const response = await cognitoClient.send(new AdminInitiateAuthCommand(params));
+    return cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo(response, issueDateTime);
+};

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

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

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

@@ -1,13 +1,13 @@
-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 params = {
-        AccessToken: accessToken,
-        PreviousPassword: previousPassword,
-        ProposedPassword: proposedPassword,
-    };
-    await cognitoClient.send(new ChangePasswordCommand(params));
-};
+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 params = {
+        AccessToken: accessToken,
+        PreviousPassword: previousPassword,
+        ProposedPassword: proposedPassword,
+    };
+    await cognitoClient.send(new ChangePasswordCommand(params));
+};

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

@@ -1,11 +1,11 @@
-import { UserAttributes } from 'quidproquo-core';
-export declare const cognitoAttributeMap: Record<keyof UserAttributes, string>;
-export declare const getCognitoUserAttributesFromQpqUserAttributes: (userAttributes: UserAttributes) => {
-    Name: string;
-    Value: string;
-}[];
-export declare const getQpqAttributesFromCognitoUserAttributes: (cognitoUserAttributes: {
-    Name: string;
-    Value: string;
-}[]) => UserAttributes;
-export declare const getQpqAttributesFromCognitoStringMap: (cognitoUserAttributes: Record<string, string>) => UserAttributes;
+import { UserAttributes } from 'quidproquo-core';
+export declare const cognitoAttributeMap: Record<keyof UserAttributes, string>;
+export declare const getCognitoUserAttributesFromQpqUserAttributes: (userAttributes: UserAttributes) => {
+    Name: string;
+    Value: string;
+}[];
+export declare const getQpqAttributesFromCognitoUserAttributes: (cognitoUserAttributes: {
+    Name: string;
+    Value: string;
+}[]) => UserAttributes;
+export declare const getQpqAttributesFromCognitoStringMap: (cognitoUserAttributes: Record<string, string>) => UserAttributes;

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

@@ -1,58 +1,58 @@
-export const cognitoAttributeMap = {
-    email: 'email',
-    emailVerified: 'email_verified',
-    userId: 'sub',
-    address: 'address',
-    birthDate: 'birthdate',
-    familyName: 'family_name',
-    gender: 'gender',
-    givenName: 'given_name',
-    locale: 'locale',
-    middleName: 'middle_name',
-    name: 'name',
-    nickname: 'nickname',
-    phoneNumber: 'phone_number',
-    picture: 'picture',
-    preferredUsername: 'preferred_username',
-    profile: 'profile',
-    website: 'website',
-    zoneInfo: 'zoneinfo',
-};
-// Flip the cognitoAttributeMap for reverse mapping
-const reversedCognitoAttributeMap = Object.entries(cognitoAttributeMap).reduce((acc, [key, value]) => ({ ...acc, [value]: key }), {});
-export const getCognitoUserAttributesFromQpqUserAttributes = (userAttributes) => {
-    return Object.keys(userAttributes)
-        .map((key) => ({
-        Name: cognitoAttributeMap[key],
-        Value: `${userAttributes[key]}`,
-    }))
-        .filter((attribute) => !!attribute.Name && !!attribute.Value);
-};
-const getQpqAttributeObjectFromCognitoKeyValue = (key, value) => {
-    const userAttributeKey = reversedCognitoAttributeMap[key];
-    if (!userAttributeKey) {
-        return {}; // If there's no matching key in your mapping, just return nothing
-    }
-    if (userAttributeKey === 'emailVerified') {
-        // Assume the value of 'email_verified' is a string of 'true' or 'false'
-        return { [userAttributeKey]: value === 'true' };
-    }
-    return { [userAttributeKey]: value };
-};
-export const getQpqAttributesFromCognitoUserAttributes = (cognitoUserAttributes) => {
-    // Map cognitoUserAttributes to your UserAttributes format
-    const userAttributes = cognitoUserAttributes.reduce((acc, { Name, Value }) => {
-        return {
-            ...acc,
-            ...getQpqAttributeObjectFromCognitoKeyValue(Name, Value),
-        };
-    }, {});
-    return userAttributes;
-};
-export const getQpqAttributesFromCognitoStringMap = (cognitoUserAttributes) => {
-    const userAttributes = Object.keys(cognitoUserAttributes).reduce((acc, key) => ({
-        ...acc,
-        ...getQpqAttributeObjectFromCognitoKeyValue(key, cognitoUserAttributes[key]),
-    }), {});
-    return userAttributes;
-};
+export const cognitoAttributeMap = {
+    email: 'email',
+    emailVerified: 'email_verified',
+    userId: 'sub',
+    address: 'address',
+    birthDate: 'birthdate',
+    familyName: 'family_name',
+    gender: 'gender',
+    givenName: 'given_name',
+    locale: 'locale',
+    middleName: 'middle_name',
+    name: 'name',
+    nickname: 'nickname',
+    phoneNumber: 'phone_number',
+    picture: 'picture',
+    preferredUsername: 'preferred_username',
+    profile: 'profile',
+    website: 'website',
+    zoneInfo: 'zoneinfo',
+};
+// Flip the cognitoAttributeMap for reverse mapping
+const reversedCognitoAttributeMap = Object.entries(cognitoAttributeMap).reduce((acc, [key, value]) => ({ ...acc, [value]: key }), {});
+export const getCognitoUserAttributesFromQpqUserAttributes = (userAttributes) => {
+    return Object.keys(userAttributes)
+        .map((key) => ({
+        Name: cognitoAttributeMap[key],
+        Value: `${userAttributes[key]}`,
+    }))
+        .filter((attribute) => !!attribute.Name && !!attribute.Value);
+};
+const getQpqAttributeObjectFromCognitoKeyValue = (key, value) => {
+    const userAttributeKey = reversedCognitoAttributeMap[key];
+    if (!userAttributeKey) {
+        return {}; // If there's no matching key in your mapping, just return nothing
+    }
+    if (userAttributeKey === 'emailVerified') {
+        // Assume the value of 'email_verified' is a string of 'true' or 'false'
+        return { [userAttributeKey]: value === 'true' };
+    }
+    return { [userAttributeKey]: value };
+};
+export const getQpqAttributesFromCognitoUserAttributes = (cognitoUserAttributes) => {
+    // Map cognitoUserAttributes to your UserAttributes format
+    const userAttributes = cognitoUserAttributes.reduce((acc, { Name, Value }) => {
+        return {
+            ...acc,
+            ...getQpqAttributeObjectFromCognitoKeyValue(Name, Value),
+        };
+    }, {});
+    return userAttributes;
+};
+export const getQpqAttributesFromCognitoStringMap = (cognitoUserAttributes) => {
+    const userAttributes = Object.keys(cognitoUserAttributes).reduce((acc, key) => ({
+        ...acc,
+        ...getQpqAttributeObjectFromCognitoKeyValue(key, cognitoUserAttributes[key]),
+    }), {});
+    return userAttributes;
+};

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

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

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

@@ -1,23 +1,23 @@
-import { CognitoIdentityProviderClient, ConfirmForgotPasswordCommand, } from '@aws-sdk/client-cognito-identity-provider';
-import { createAwsClient } from '../createAwsClient';
-import { calculateSecretHash } from './utils/calculateSecretHash';
-import { authenticateUser } from './authenticateUser';
-import { getUserPoolClientSecret } from './getUserPoolClientSecret';
-export const confirmForgotPassword = async (userPoolId, clientId, region, code, username, password) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
-        region,
-    });
-    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
-    const secretHash = calculateSecretHash(username, clientId, clientSecret);
-    const params = {
-        ClientId: clientId,
-        ConfirmationCode: code,
-        SecretHash: secretHash,
-        Password: password,
-        Username: username,
-    };
-    await cognitoClient.send(new ConfirmForgotPasswordCommand(params));
-    // Authenticate the user
-    const authResponse = await authenticateUser(userPoolId, clientId, region, false, username, password);
-    return authResponse;
-};
+import { CognitoIdentityProviderClient, ConfirmForgotPasswordCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
+import { calculateSecretHash } from './utils/calculateSecretHash';
+import { authenticateUser } from './authenticateUser';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
+export const confirmForgotPassword = async (userPoolId, clientId, region, code, username, password) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
+    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
+    const secretHash = calculateSecretHash(username, clientId, clientSecret);
+    const params = {
+        ClientId: clientId,
+        ConfirmationCode: code,
+        SecretHash: secretHash,
+        Password: password,
+        Username: username,
+    };
+    await cognitoClient.send(new ConfirmForgotPasswordCommand(params));
+    // Authenticate the user
+    const authResponse = await authenticateUser(userPoolId, clientId, region, false, username, password);
+    return authResponse;
+};

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

@@ -1,2 +1,2 @@
-import { AuthenticateUserResponse, CreateUserRequest } from 'quidproquo-core';
-export declare const createUser: (userPoolId: string, region: string, clientId: string, createUserRequest: CreateUserRequest) => Promise<AuthenticateUserResponse>;
+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,28 +1,28 @@
-import { AdminCreateUserCommand, CognitoIdentityProviderClient, DeliveryMediumType, MessageActionType, } from '@aws-sdk/client-cognito-identity-provider';
-import { createAwsClient } from '../createAwsClient';
-import { authenticateUser } from './authenticateUser';
-import { getCognitoUserAttributesFromQpqUserAttributes } from './cognitoAttributeMap';
-import { setUserPassword } from './setUserPassword';
-export const createUser = async (userPoolId, region, clientId, createUserRequest) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
-        region,
-    });
-    const params = {
-        UserPoolId: userPoolId,
-        Username: createUserRequest.email,
-        MessageAction: MessageActionType.SUPPRESS,
-        DesiredDeliveryMediums: [DeliveryMediumType.EMAIL],
-        UserAttributes: getCognitoUserAttributesFromQpqUserAttributes(createUserRequest),
-        ForceAliasCreation: false,
-    };
-    if (createUserRequest.phoneNumber) {
-        params.DesiredDeliveryMediums.push(DeliveryMediumType.SMS);
-    }
-    const response = await cognitoClient.send(new AdminCreateUserCommand(params));
-    const username = response.User?.Username || '';
-    // Set the user's password
-    await setUserPassword(region, userPoolId, username, createUserRequest.password);
-    // Authenticate the user
-    const authResponse = await authenticateUser(userPoolId, clientId, region, false, username, createUserRequest.password);
-    return authResponse;
-};
+import { AdminCreateUserCommand, CognitoIdentityProviderClient, DeliveryMediumType, MessageActionType, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
+import { authenticateUser } from './authenticateUser';
+import { getCognitoUserAttributesFromQpqUserAttributes } from './cognitoAttributeMap';
+import { setUserPassword } from './setUserPassword';
+export const createUser = async (userPoolId, region, clientId, createUserRequest) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
+    const params = {
+        UserPoolId: userPoolId,
+        Username: createUserRequest.email,
+        MessageAction: MessageActionType.SUPPRESS, // Don't contact the user
+        DesiredDeliveryMediums: [DeliveryMediumType.EMAIL],
+        UserAttributes: getCognitoUserAttributesFromQpqUserAttributes(createUserRequest),
+        ForceAliasCreation: false,
+    };
+    if (createUserRequest.phoneNumber) {
+        params.DesiredDeliveryMediums.push(DeliveryMediumType.SMS);
+    }
+    const response = await cognitoClient.send(new AdminCreateUserCommand(params));
+    const username = response.User?.Username || '';
+    // Set the user's password
+    await setUserPassword(region, userPoolId, username, createUserRequest.password);
+    // Authenticate the user
+    const authResponse = await authenticateUser(userPoolId, clientId, region, false, username, createUserRequest.password);
+    return authResponse;
+};

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

@@ -1,2 +1,2 @@
-import { DecodedAccessToken, QPQConfig } from 'quidproquo-core';
-export declare const decodeAccessToken: (userDirectoryName: string, qpqConfig: QPQConfig, accessToken?: string, ignoreExpiration?: boolean) => Promise<DecodedAccessToken>;
+import { DecodedAccessToken, QPQConfig } from 'quidproquo-core';
+export declare const decodeAccessToken: (userDirectoryName: string, qpqConfig: QPQConfig, accessToken?: string, ignoreExpiration?: boolean) => Promise<DecodedAccessToken>;