quidproquo-actionprocessor-awslambda 0.0.198 → 0.0.200

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

@@ -0,0 +1,45 @@
+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);
+};
+export const getQpqAttributesFromCognitoUserAttributes = (cognitoUserAttributes) => {
+    // Map cognitoUserAttributes to your UserAttributes format
+    const userAttributes = cognitoUserAttributes.reduce((acc, { Name, Value }) => {
+        const userAttributeKey = reversedCognitoAttributeMap[Name];
+        if (!userAttributeKey) {
+            return acc; // If there's no matching key in your mapping, just continue with the current accumulation
+        }
+        if (userAttributeKey === 'emailVerified') {
+            // Assume the value of 'email_verified' is a string of 'true' or 'false'
+            return { ...acc, [userAttributeKey]: Value === 'true' };
+        }
+        return { ...acc, [userAttributeKey]: Value };
+    }, {});
+    return userAttributes;
+};

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

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

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

@@ -0,0 +1,21 @@
+import { CognitoIdentityProviderClient, ConfirmForgotPasswordCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { calculateSecretHash } from './utils/calculateSecretHash';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
+import { authenticateUser } from './authenticateUser';
+import { createAwsClient } from '../createAwsClient';
+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, username, password);
+    return authResponse;
+};

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

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

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

@@ -0,0 +1,26 @@
+import { CognitoIdentityProviderClient, AdminCreateUserCommand, DeliveryMediumType, MessageActionType, } from '@aws-sdk/client-cognito-identity-provider';
+import { authenticateUser } from './authenticateUser';
+import { setUserPassword } from './setUserPassword';
+import { getCognitoUserAttributesFromQpqUserAttributes } from './cognitoAttributeMap';
+import { createAwsClient } from '../createAwsClient';
+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, username, createUserRequest.password);
+    return authResponse;
+};

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

@@ -0,0 +1,5 @@
+export type AuthInfo = {
+    userId: string;
+    username: string;
+};
+export declare const decodeValidJwt: (userPoolId: string, region: string, ignoreExpiration: boolean, accessToken?: string) => Promise<AuthInfo | null>;

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

@@ -0,0 +1,30 @@
+import { verify, decode } 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,
+        });
+        return {
+            userId: payload.sub,
+            username: payload.username,
+        };
+    }
+    catch (e) {
+        console.log('Failed to decode jwt token', e);
+        return null;
+    }
+};

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

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

@@ -0,0 +1,24 @@
+import { CognitoIdentityProviderClient, ForgotPasswordCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { calculateSecretHash } from './utils/calculateSecretHash';
+import { getUserPoolClientSecret } from './getUserPoolClientSecret';
+import { createAwsClient } from '../createAwsClient';
+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;
+};

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

@@ -0,0 +1,10 @@
+export interface UserAttributes {
+    [attribute: string]: string;
+}
+export interface User {
+    id: string;
+    username: string;
+    email: string;
+    userAttributes: UserAttributes;
+}
+export declare const getUser: (accessToken: string, region: string) => Promise<User>;

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

@@ -0,0 +1,23 @@
+import { CognitoIdentityProviderClient, GetUserCommand, } from '@aws-sdk/client-cognito-identity-provider';
+import { createAwsClient } from '../createAwsClient';
+const getUserAttribute = (attributeName, userAttributes) => {
+    const lowerAttributeName = attributeName.toLowerCase();
+    const attribute = userAttributes.find((k) => k.Name?.toLowerCase() === lowerAttributeName);
+    return attribute?.Value;
+};
+export const getUser = async (accessToken, region) => {
+    const cognitoClient = createAwsClient(CognitoIdentityProviderClient, { region });
+    const params = {
+        AccessToken: accessToken,
+    };
+    const response = await cognitoClient.send(new GetUserCommand(params));
+    const attributeTypes = (response.UserAttributes || []).filter((ua) => !!ua.Value);
+    const userAttributes = attributeTypes.reduce((acc, ua) => ({ ...acc, [ua.Name]: ua.Value }), {});
+    const user = {
+        username: response.Username,
+        id: getUserAttribute('sub', attributeTypes),
+        email: getUserAttribute('email', attributeTypes),
+        userAttributes,
+    };
+    return user;
+};

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