quidproquo-actionprocessor-awslambda 0.0.199 → 0.0.200

package/lib/esm/getActionProcessor/webserver/serviceFunction/index.d.ts

@@ -0,0 +1,5 @@
+import { QPQConfig } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-webserver/ServiceFunction/Execute": import("quidproquo-webserver").ServiceFunctionExecuteActionProcessor<any, any>;
+};
+export default _default;

package/lib/esm/getActionProcessor/webserver/serviceFunction/index.js

@@ -0,0 +1,4 @@
+import getServiceFunctionActionProcessor from './getServiceFunctionActionProcessor';
+export default (qpqConfig) => ({
+    ...getServiceFunctionActionProcessor(qpqConfig),
+});

package/lib/esm/getActionProcessor/webserver/webEntry/getWebEntryInvalidateCacheActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig } from 'quidproquo-core';
+import { WebEntryInvalidateCacheActionProcessor } from 'quidproquo-webserver';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-webserver/WebEntry/InvalidateCache": WebEntryInvalidateCacheActionProcessor;
+};
+export default _default;

package/lib/esm/getActionProcessor/webserver/webEntry/getWebEntryInvalidateCacheActionProcessor.js

@@ -0,0 +1,18 @@
+import { actionResult, qpqCoreUtils } from 'quidproquo-core';
+import { WebEntryActionType } from 'quidproquo-webserver';
+import { getCFExportNameDistributionIdArnFromConfig } from '../../../awsNamingUtils';
+import { invalidateCache } from '../../../logic/cloudFront/invalidateCache';
+import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
+const getWebEntryInvalidteCacheActionProcessor = (qpqConfig) => {
+    return async ({ paths, webEntryName }) => {
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const distributionId = await getExportedValue(getCFExportNameDistributionIdArnFromConfig(webEntryName, qpqConfig), region);
+        await invalidateCache(distributionId, region, paths);
+        return actionResult(void 0);
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [WebEntryActionType.InvalidateCache]: getWebEntryInvalidteCacheActionProcessor(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/webserver/webEntry/index.d.ts

@@ -0,0 +1,5 @@
+import { QPQConfig } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-webserver/WebEntry/InvalidateCache": import("quidproquo-webserver").WebEntryInvalidateCacheActionProcessor;
+};
+export default _default;

package/lib/esm/getActionProcessor/webserver/webEntry/index.js

@@ -0,0 +1,4 @@
+import getWebEntryInvalidateCacheActionProcessor from './getWebEntryInvalidateCacheActionProcessor';
+export default (qpqConfig) => ({
+    ...getWebEntryInvalidateCacheActionProcessor(qpqConfig),
+});

package/lib/esm/getActionProcessor/webserver/websocket/getWebsocketSendMessageActionProcessor.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig } from 'quidproquo-core';
+import { WebsocketSendMessageActionProcessor } from 'quidproquo-webserver';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-webserver/Websocket/SendMessage": WebsocketSendMessageActionProcessor<any>;
+};
+export default _default;

package/lib/esm/getActionProcessor/webserver/websocket/getWebsocketSendMessageActionProcessor.js

@@ -0,0 +1,26 @@
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, qpqCoreUtils } from 'quidproquo-core';
+import { WebsocketActionType, WebsocketSendMessageErrorTypeEnum } from 'quidproquo-webserver';
+import { getCFExportNameWebsocketApiIdFromConfig } from '../../../awsNamingUtils';
+import { sendMessageToWebSocketConnection } from '../../../logic/apiGateway/websocketSendMessage';
+import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
+const getWebsocketSendMessageActionProcessor = (qpqConfig) => {
+    return async ({ connectionId, payload, websocketApiName }) => {
+        const region = qpqCoreUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const apiId = await getExportedValue(getCFExportNameWebsocketApiIdFromConfig(websocketApiName, qpqConfig), region);
+        try {
+            await sendMessageToWebSocketConnection(apiId, connectionId, region, payload);
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                ThrottlingException: () => actionResultError(WebsocketSendMessageErrorTypeEnum.Throttled, 'Rate exceeded'),
+                GoneException: () => actionResultError(WebsocketSendMessageErrorTypeEnum.Disconnected, 'Connection no longer exists'),
+            });
+        }
+    };
+};
+export default (qpqConfig) => {
+    return {
+        [WebsocketActionType.SendMessage]: getWebsocketSendMessageActionProcessor(qpqConfig),
+    };
+};

package/lib/esm/getActionProcessor/webserver/websocket/index.d.ts

@@ -0,0 +1,5 @@
+import { QPQConfig } from 'quidproquo-core';
+declare const _default: (qpqConfig: QPQConfig) => {
+    "@quidproquo-webserver/Websocket/SendMessage": import("quidproquo-webserver").WebsocketSendMessageActionProcessor<any>;
+};
+export default _default;

package/lib/esm/getActionProcessor/webserver/websocket/index.js

@@ -0,0 +1,4 @@
+import getWebsocketSendMessageActionProcessor from './getWebsocketSendMessageActionProcessor';
+export default (qpqConfig) => ({
+    ...getWebsocketSendMessageActionProcessor(qpqConfig),
+});

package/lib/esm/index.d.ts

@@ -0,0 +1,8 @@
+export * from './getActionProcessor';
+export * as awsLambdaUtils from './awsLambdaUtils';
+export * as awsNamingUtils from './awsNamingUtils';
+export * from './runtimeConfig/QPQAWSResourceMap';
+export * from './types';
+export * from './logic/parametersManager/getParameter';
+export * from './logic/parametersManager/getParameters';
+export * from './logic/cache/memoFunc';

package/lib/esm/index.js

@@ -0,0 +1,8 @@
+export * from './getActionProcessor';
+export * as awsLambdaUtils from './awsLambdaUtils';
+export * as awsNamingUtils from './awsNamingUtils';
+export * from './runtimeConfig/QPQAWSResourceMap';
+export * from './types';
+export * from './logic/parametersManager/getParameter';
+export * from './logic/parametersManager/getParameters';
+export * from './logic/cache/memoFunc';

package/lib/esm/logic/acm/findMatchingCertificates.d.ts

@@ -0,0 +1 @@
+export declare const findMatchingCertificates: (domainName: string, region: string, retryCount?: number, delayMs?: number) => Promise<string[]>;

package/lib/esm/logic/acm/findMatchingCertificates.js

@@ -0,0 +1,39 @@
+import { ACMClient, ListCertificatesCommand } from '@aws-sdk/client-acm';
+import { createAwsClient } from '../createAwsClient';
+export const findMatchingCertificates = async (domainName, region, retryCount = 3, delayMs = 5000) => {
+    const lowerCaseDomainName = domainName.toLowerCase();
+    const acmClient = createAwsClient(ACMClient, {
+        region,
+    });
+    let remainingRetries = retryCount;
+    while (remainingRetries > 0) {
+        let certificateArns = [];
+        let NextToken;
+        do {
+            const listCommand = new ListCertificatesCommand({
+                NextToken,
+            });
+            const listResult = await acmClient.send(listCommand);
+            for (const certificate of listResult.CertificateSummaryList || []) {
+                if (certificate.CertificateArn &&
+                    certificate.DomainName?.toLowerCase() === lowerCaseDomainName) {
+                    certificateArns.push(certificate.CertificateArn);
+                }
+            }
+            NextToken = listResult.NextToken;
+        } while (NextToken);
+        if (certificateArns.length > 0) {
+            return certificateArns;
+        }
+        remainingRetries--;
+        if (remainingRetries != 0) {
+            // Don't wait after the last try
+            await new Promise((res) => setTimeout(res, delayMs));
+        }
+    }
+    return []; // Return an empty array after max retries
+};
+// (async () => {
+//   const matchingCerts = await findMatchingCertificates('example.com', 'us-east-1');
+//   console.log('Matching certificates:', matchingCerts);
+// })();

package/lib/esm/logic/acm/getDomainValidationOptions.d.ts

@@ -0,0 +1,2 @@
+import { CloudflareDnsEntries } from 'quidproquo-webserver';
+export declare const getDomainValidationOptions: (certificateArn: string, region: string) => Promise<CloudflareDnsEntries>;

package/lib/esm/logic/acm/getDomainValidationOptions.js

@@ -0,0 +1,26 @@
+import { ACMClient, DescribeCertificateCommand } from '@aws-sdk/client-acm';
+import { createAwsClient } from '../createAwsClient';
+export const getDomainValidationOptions = async (certificateArn, region) => {
+    const acmClient = createAwsClient(ACMClient, {
+        region,
+    });
+    const command = new DescribeCertificateCommand({
+        CertificateArn: certificateArn,
+    });
+    const result = await acmClient.send(command);
+    const entries = {};
+    console.log('DescribeCertificateCommand: ', JSON.stringify(result, null, 2));
+    // Extract the DomainValidationOptions and populate the entries
+    if (result.Certificate && result.Certificate.DomainValidationOptions) {
+        for (const option of result.Certificate.DomainValidationOptions) {
+            if (option.ResourceRecord?.Name && option.ResourceRecord?.Value) {
+                entries[option.ResourceRecord.Name] = {
+                    proxied: false,
+                    type: 'CNAME',
+                    value: option.ResourceRecord.Value,
+                };
+            }
+        }
+    }
+    return entries;
+};

package/lib/esm/logic/apiGateway/getApiKeys.d.ts

@@ -0,0 +1,2 @@
+import { ApiKey } from 'quidproquo-webserver';
+export declare const getApiKeys: (region: string, ...keyNames: string[]) => Promise<ApiKey[]>;

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

@@ -0,0 +1,13 @@
+import { APIGatewayClient, GetApiKeysCommand, } from '@aws-sdk/client-api-gateway';
+import { createAwsClient } from '../createAwsClient';
+export const getApiKeys = async (region, ...keyNames) => {
+    const apiGatewayClient = createAwsClient(APIGatewayClient, { region });
+    const input = {
+        includeValues: true,
+        limit: 500,
+    };
+    const res = await apiGatewayClient.send(new GetApiKeysCommand(input));
+    return (res.items
+        ?.filter((i) => keyNames.indexOf(i.name) >= 0)
+        .map((i) => ({ name: i.name, value: i.value, description: i.description })) || []);
+};

package/lib/esm/logic/apiGateway/websocketSendMessage.d.ts

@@ -0,0 +1 @@
+export declare const sendMessageToWebSocketConnection: (apiId: string, connectionId: string, region: string, payload: any) => Promise<void>;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+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);
+        }
+        try {
+            // Await the result and then cache it
+            const result = await func(...args);
+            nodeCache.set(cacheKey, result);
+            return result;
+        }
+        catch (err) {
+            throw err; // re-throw the error to be caught by caller
+        }
+    });
+};

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

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

@@ -0,0 +1,24 @@
+import { CloudFrontClient, CreateInvalidationCommand, } from '@aws-sdk/client-cloudfront';
+import crypto from 'crypto';
+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

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

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

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

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

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

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

@@ -0,0 +1,25 @@
+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';
+// TODO: retry for TooManyRequestsException
+export const authenticateUser = async (userPoolId, clientId, region, 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: AuthFlowType.ADMIN_USER_PASSWORD_AUTH,
+        UserPoolId: userPoolId,
+        ClientId: clientId,
+        AuthParameters: {
+            USERNAME: username,
+            PASSWORD: password,
+            SECRET_HASH: secretHash,
+        },
+    };
+    const response = await cognitoClient.send(new AdminInitiateAuthCommand(params));
+    return cognitoAdminInitiateAuthResponseToQpqAuthenticationInfo(response, issueDateTime);
+};

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

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

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

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

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

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