quidproquo-actionprocessor-awslambda 0.0.253 → 0.0.255

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

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

@@ -1,19 +1,19 @@
-import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { getCFExportNameUserPoolIdFromConfig } from '../../awsNamingUtils';
-import { getExportedValue } from '../cloudformation/getExportedValue';
-import { decodeValidJwt } from './decodeValidJwt';
-export const decodeAccessToken = async (userDirectoryName, qpqConfig, accessToken, ignoreExpiration = false) => {
-    const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
-    const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
-    const decodedAuthToken = await decodeValidJwt(userPoolId, region, ignoreExpiration, accessToken);
-    if (!decodedAuthToken || !decodedAuthToken?.username) {
-        throw new Error('Unable to decode access token');
-    }
-    const wasValid = !ignoreExpiration || decodedAuthToken.exp > Math.floor(Date.now() / 1000);
-    const decodedAccesToken = {
-        ...decodedAuthToken,
-        wasValid,
-        userDirectory: userDirectoryName,
-    };
-    return decodedAccesToken;
-};
+import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
+import { getCFExportNameUserPoolIdFromConfig } from '../../awsNamingUtils';
+import { getExportedValue } from '../cloudformation/getExportedValue';
+import { decodeValidJwt } from './decodeValidJwt';
+export const decodeAccessToken = async (userDirectoryName, qpqConfig, accessToken, ignoreExpiration = false) => {
+    const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
+    const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
+    const decodedAuthToken = await decodeValidJwt(userPoolId, region, ignoreExpiration, accessToken);
+    if (!decodedAuthToken || !decodedAuthToken?.username) {
+        throw new Error('Unable to decode access token');
+    }
+    const wasValid = !ignoreExpiration || decodedAuthToken.exp > Math.floor(Date.now() / 1000);
+    const decodedAccesToken = {
+        ...decodedAuthToken,
+        wasValid,
+        userDirectory: userDirectoryName,
+    };
+    return decodedAccesToken;
+};

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

@@ -1,2 +1,2 @@
-import { DecodedAccessToken } from 'quidproquo-core';
-export declare const decodeValidJwt: (userPoolId: string, region: string, ignoreExpiration: boolean, accessToken?: string) => Promise<Omit<DecodedAccessToken, 'userDirectory'> | null>;
+import { DecodedAccessToken } from 'quidproquo-core';
+export declare const decodeValidJwt: (userPoolId: string, region: string, ignoreExpiration: boolean, accessToken?: string) => Promise<Omit<DecodedAccessToken, "userDirectory"> | null>;

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

@@ -1,33 +1,33 @@
-import { decode, verify } from 'jsonwebtoken';
-import jwksClient from 'jwks-rsa';
-export const decodeValidJwt = async (userPoolId, region, ignoreExpiration, accessToken) => {
-    if (!accessToken) {
-        return null;
-    }
-    try {
-        const decodedToken = decode(accessToken, { complete: true });
-        if (!decodedToken) {
-            return null;
-        }
-        const client = jwksClient({
-            jwksUri: `https://cognito-idp.${region}.amazonaws.com/${userPoolId}/.well-known/jwks.json`,
-        });
-        const key = await client.getSigningKey(decodedToken.header.kid);
-        const signingKey = key.getPublicKey();
-        const payload = verify(accessToken, signingKey, {
-            algorithms: ['RS256'],
-            ignoreExpiration,
-        });
-        const decodedAccessToken = {
-            userId: payload.sub,
-            username: payload.username,
-            exp: payload.exp,
-            wasValid: true,
-        };
-        return decodedAccessToken;
-    }
-    catch (e) {
-        console.log('Failed to decode jwt token', e);
-        return null;
-    }
-};
+import { decode, verify } from 'jsonwebtoken';
+import jwksClient from 'jwks-rsa';
+export const decodeValidJwt = async (userPoolId, region, ignoreExpiration, accessToken) => {
+    if (!accessToken) {
+        return null;
+    }
+    try {
+        const decodedToken = decode(accessToken, { complete: true });
+        if (!decodedToken) {
+            return null;
+        }
+        const client = jwksClient({
+            jwksUri: `https://cognito-idp.${region}.amazonaws.com/${userPoolId}/.well-known/jwks.json`,
+        });
+        const key = await client.getSigningKey(decodedToken.header.kid);
+        const signingKey = key.getPublicKey();
+        const payload = verify(accessToken, signingKey, {
+            algorithms: ['RS256'],
+            ignoreExpiration,
+        });
+        const decodedAccessToken = {
+            userId: payload.sub,
+            username: payload.username,
+            exp: payload.exp,
+            wasValid: true,
+        };
+        return decodedAccessToken;
+    }
+    catch (e) {
+        console.log('Failed to decode jwt token', e);
+        return null;
+    }
+};

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

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

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

@@ -1,26 +1,26 @@
-import { CognitoIdentityProviderClient, ForgotPasswordCommand } from '@aws-sdk/client-cognito-identity-provider';
-import { createAwsClient } from '../createAwsClient';
-import { calculateSecretHash } from './utils/calculateSecretHash';
-import { getUserPoolClientSecret } from './getUserPoolClientSecret';
-export const forgotPassword = async (userPoolId, clientId, region, username) => {
-    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
-        region,
-    });
-    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
-    const secretHash = calculateSecretHash(username, clientId, clientSecret);
-    const params = {
-        ClientId: clientId,
-        Username: username,
-        SecretHash: secretHash,
-        ClientMetadata: {
-            userInitiated: 'true',
-        },
-    };
-    const response = await cognitoClient.send(new ForgotPasswordCommand(params));
-    const deliveryInfo = {
-        attributeName: response.CodeDeliveryDetails.AttributeName || 'email',
-        destination: response.CodeDeliveryDetails.Destination || 'unknown@email.com',
-        deliveryMedium: response.CodeDeliveryDetails.DeliveryMedium || 'EMAIL',
-    };
-    return deliveryInfo;
-};
+import { CognitoIdentityProviderClient, ForgotPasswordCommand } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
+import { calculateSecretHash } from './utils/calculateSecretHash';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
+export const forgotPassword = async (userPoolId, clientId, region, username) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, {
+        region,
+    });
+    const clientSecret = await getUserPoolClientSecret(userPoolId, clientId, region);
+    const secretHash = calculateSecretHash(username, clientId, clientSecret);
+    const params = {
+        ClientId: clientId,
+        Username: username,
+        SecretHash: secretHash,
+        ClientMetadata: {
+            userInitiated: 'true',
+        },
+    };
+    const response = await cognitoClient.send(new ForgotPasswordCommand(params));
+    const deliveryInfo = {
+        attributeName: response.CodeDeliveryDetails.AttributeName || 'email',
+        destination: response.CodeDeliveryDetails.Destination || 'unknown@email.com',
+        deliveryMedium: response.CodeDeliveryDetails.DeliveryMedium || 'EMAIL',
+    };
+    return deliveryInfo;
+};