quidproquo-actionprocessor-awslambda 0.0.262 → 0.1.0

package/lib/esm/getActionProcessor/core/file/getFileWriteBinaryContentsActionProcessor.js

@@ -1,13 +1,22 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, FileActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, FileActionType, FileWriteBinaryContentsErrorTypeEnum, } from 'quidproquo-core';
 import { getS3BucketStorageClassFromStorageDriveTier } from '../../../awsLambdaUtils';
 import { writeBinaryFile } from '../../../logic/s3/s3Utils';
 import { resolveStorageDriveBucketName } from './utils';
 const getProcessFileWriteBinaryContents = (qpqConfig) => {
     return async ({ drive, filepath, data, storageDriveAdvancedWriteOptions }) => {
         const s3BucketName = resolveStorageDriveBucketName(drive, qpqConfig);
-        await writeBinaryFile(s3BucketName, filepath, data, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), getS3BucketStorageClassFromStorageDriveTier(storageDriveAdvancedWriteOptions?.storageDriveTier));
-        return actionResult(void 0);
+        try {
+            await writeBinaryFile(s3BucketName, filepath, data, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), getS3BucketStorageClassFromStorageDriveTier(storageDriveAdvancedWriteOptions?.storageDriveTier));
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                AccessDenied: () => actionResultError(FileWriteBinaryContentsErrorTypeEnum.AccessDenied, 'Access denied writing file'),
+                Forbidden: () => actionResultError(FileWriteBinaryContentsErrorTypeEnum.AccessDenied, 'Access denied writing file'),
+                NoSuchBucket: () => actionResultError(FileWriteBinaryContentsErrorTypeEnum.DriveNotFound, `Storage drive not found: ${drive}`),
+            });
+        }
     };
 };
 export const getFileWriteBinaryContentsActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/file/getFileWriteObjectJsonActionProcessor.js

@@ -1,5 +1,5 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, FileActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, FileActionType, FileWriteObjectJsonErrorTypeEnum, } from 'quidproquo-core';
 import { getS3BucketStorageClassFromStorageDriveTier } from '../../../awsLambdaUtils';
 import { writeTextFile } from '../../../logic/s3/s3Utils';
 import { resolveStorageDriveBucketName } from './utils';
@@ -7,8 +7,17 @@ const getProcessFileWriteObjectJson = (qpqConfig) => {
     return async ({ drive, filepath, data, storageDriveAdvancedWriteOptions }) => {
         const s3BucketName = resolveStorageDriveBucketName(drive, qpqConfig);
         const dataJson = JSON.stringify(data);
-        await writeTextFile(s3BucketName, filepath, dataJson, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), getS3BucketStorageClassFromStorageDriveTier(storageDriveAdvancedWriteOptions?.storageDriveTier));
-        return actionResult(void 0);
+        try {
+            await writeTextFile(s3BucketName, filepath, dataJson, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), getS3BucketStorageClassFromStorageDriveTier(storageDriveAdvancedWriteOptions?.storageDriveTier));
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                AccessDenied: () => actionResultError(FileWriteObjectJsonErrorTypeEnum.AccessDenied, 'Access denied writing file'),
+                Forbidden: () => actionResultError(FileWriteObjectJsonErrorTypeEnum.AccessDenied, 'Access denied writing file'),
+                NoSuchBucket: () => actionResultError(FileWriteObjectJsonErrorTypeEnum.DriveNotFound, `Storage drive not found: ${drive}`),
+            });
+        }
     };
 };
 export const getFileWriteObjectJsonActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/file/getFileWriteTextContentsActionProcessor.js

@@ -1,13 +1,22 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, FileActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, FileActionType, FileWriteTextContentsErrorTypeEnum, } from 'quidproquo-core';
 import { getS3BucketStorageClassFromStorageDriveTier } from '../../../awsLambdaUtils';
 import { writeTextFile } from '../../../logic/s3/s3Utils';
 import { resolveStorageDriveBucketName } from './utils';
 const getProcessFileWriteTextContents = (qpqConfig) => {
     return async ({ drive, filepath, data, storageDriveAdvancedWriteOptions }) => {
         const s3BucketName = resolveStorageDriveBucketName(drive, qpqConfig);
-        await writeTextFile(s3BucketName, filepath, data, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), getS3BucketStorageClassFromStorageDriveTier(storageDriveAdvancedWriteOptions?.storageDriveTier));
-        return actionResult(void 0);
+        try {
+            await writeTextFile(s3BucketName, filepath, data, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), getS3BucketStorageClassFromStorageDriveTier(storageDriveAdvancedWriteOptions?.storageDriveTier));
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                AccessDenied: () => actionResultError(FileWriteTextContentsErrorTypeEnum.AccessDenied, 'Access denied writing file'),
+                Forbidden: () => actionResultError(FileWriteTextContentsErrorTypeEnum.AccessDenied, 'Access denied writing file'),
+                NoSuchBucket: () => actionResultError(FileWriteTextContentsErrorTypeEnum.DriveNotFound, `Storage drive not found: ${drive}`),
+            });
+        }
     };
 };
 export const getFileWriteTextContentsActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/file/index.js

@@ -7,6 +7,7 @@ import { getFileListDirectoryActionProcessor } from './getFileListDirectoryActio
 import { getFileReadBinaryContentsActionProcessor } from './getFileReadBinaryContentsActionProcessor';
 import { getFileReadObjectJsonActionProcessor } from './getFileReadObjectJsonActionProcessor';
 import { getFileReadTextContentsActionProcessor } from './getFileReadTextContentsActionProcessor';
+import { getFileStreamOpenActionProcessor } from './getFileStreamOpenActionProcessor';
 import { getFileWriteBinaryContentsActionProcessor } from './getFileWriteBinaryContentsActionProcessor';
 import { getFileWriteObjectJsonActionProcessor } from './getFileWriteObjectJsonActionProcessor';
 import { getFileWriteTextContentsActionProcessor } from './getFileWriteTextContentsActionProcessor';
@@ -23,4 +24,5 @@ export const getFileActionProcessor = async (qpqConfig, dynamicModuleLoader) =>
     ...(await getFileReadBinaryContentsActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileWriteObjectJsonActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileWriteBinaryContentsActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getFileStreamOpenActionProcessor(qpqConfig, dynamicModuleLoader)),
 });

package/lib/esm/getActionProcessor/core/index.d.ts

@@ -1,3 +1,5 @@
+export * from './ai';
+export * from './apiKeyValidation';
 export * from './config';
 export * from './event';
 export * from './eventBus';

package/lib/esm/getActionProcessor/core/index.js

@@ -1,3 +1,5 @@
+export * from './ai';
+export * from './apiKeyValidation';
 export * from './config';
 export * from './event';
 export * from './eventBus';
@@ -7,6 +9,9 @@ export * from './keyValueStore';
 export * from './queue';
 export * from './system';
 export * from './userDirectory';
+import { getRouteAuthValidationActionProcessor } from 'quidproquo-webserver';
+import { getAiActionProcessor } from './ai';
+import { getApiKeyValidationActionProcessor } from './apiKeyValidation';
 import { getConfigActionProcessor } from './config';
 import { getApiGatewayApiEventEventProcessor } from './event';
 import { getEventBusActionProcessor } from './eventBus';
@@ -17,6 +22,8 @@ import { getQueueActionProcessor } from './queue';
 import { getSystemActionProcessor } from './system';
 import { getUserDirectoryActionProcessor } from './userDirectory';
 export const getCoreActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getAiActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getApiKeyValidationActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getFileActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getKeyValueStoreActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getQueueActionProcessor(qpqConfig, dynamicModuleLoader)),
@@ -26,4 +33,5 @@ export const getCoreActionProcessor = async (qpqConfig, dynamicModuleLoader) =>
     ...(await getConfigActionProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getApiGatewayApiEventEventProcessor(qpqConfig, dynamicModuleLoader)),
     ...(await getGraphDatabaseActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getRouteAuthValidationActionProcessor(qpqConfig, dynamicModuleLoader)),
 });

package/lib/esm/getActionProcessor/core/keyValueStore/getKeyValueStoreDeleteActionProcessor.js

@@ -1,6 +1,6 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
 import { qpqCoreUtils } from 'quidproquo-core';
-import { actionResult, KeyValueStoreActionType } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, KeyValueStoreActionType, KeyValueStoreDeleteErrorTypeEnum } from 'quidproquo-core';
 import { getKvsDynamoTableNameFromConfig } from '../../../awsNamingUtils';
 import { deleteItem } from '../../../logic/dynamo';
 const getProcessKeyValueStoreDelete = (qpqConfig) => {
@@ -8,8 +8,16 @@ const getProcessKeyValueStoreDelete = (qpqConfig) => {
         const dynamoTableName = getKvsDynamoTableNameFromConfig(keyValueStoreName, qpqConfig, 'kvs');
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const storeConfig = qpqCoreUtils.getKeyValueStoreByName(qpqConfig, keyValueStoreName);
-        await deleteItem(dynamoTableName, region, key, storeConfig.partitionKey.key, sortKey, storeConfig.sortKeys[0]?.key);
-        return actionResult(void 0);
+        try {
+            await deleteItem(dynamoTableName, region, key, storeConfig.partitionKey.key, sortKey, storeConfig.sortKeys[0]?.key);
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                InternalServerError: () => actionResultError(KeyValueStoreDeleteErrorTypeEnum.ServiceUnavailable, 'KVS Service Unavailable'),
+                ResourceNotFoundException: () => actionResultError(KeyValueStoreDeleteErrorTypeEnum.ResourceNotFound, 'KVS Resource Not Found'),
+            });
+        }
     };
 };
 export const getKeyValueStoreDeleteActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/keyValueStore/getKeyValueStoreGetActionProcessor.js

@@ -1,13 +1,21 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, KeyValueStoreActionType } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, KeyValueStoreActionType, KeyValueStoreGetErrorTypeEnum } from 'quidproquo-core';
 import { getKvsDynamoTableNameFromConfig } from '../../../awsNamingUtils';
 import { getItem } from '../../../logic/dynamo';
 const getProcessKeyValueStoreGet = (qpqConfig) => {
     return async ({ keyValueStoreName, key }) => {
         const dynamoTableName = getKvsDynamoTableNameFromConfig(keyValueStoreName, qpqConfig, 'kvs');
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
-        const result = await getItem(dynamoTableName, key, region);
-        return actionResult(result);
+        try {
+            const result = await getItem(dynamoTableName, key, region);
+            return actionResult(result);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                InternalServerError: () => actionResultError(KeyValueStoreGetErrorTypeEnum.ServiceUnavailable, 'KVS Service Unavailable'),
+                ResourceNotFoundException: () => actionResultError(KeyValueStoreGetErrorTypeEnum.ResourceNotFound, 'KVS Resource Not Found'),
+            });
+        }
     };
 };
 export const getKeyValueStoreGetActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/keyValueStore/getKeyValueStoreGetAllActionProcessor.js

@@ -1,13 +1,21 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, KeyValueStoreActionType } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, KeyValueStoreActionType, KeyValueStoreGetAllErrorTypeEnum } from 'quidproquo-core';
 import { getKvsDynamoTableNameFromConfig } from '../../../awsNamingUtils';
 import { getAllItems } from '../../../logic/dynamo';
 const getProcessKeyValueStoreGetAll = (qpqConfig) => {
     return async ({ keyValueStoreName }) => {
         const dynamoTableName = getKvsDynamoTableNameFromConfig(keyValueStoreName, qpqConfig, 'kvs');
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
-        const result = await getAllItems(dynamoTableName, region);
-        return actionResult(result);
+        try {
+            const result = await getAllItems(dynamoTableName, region);
+            return actionResult(result);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                InternalServerError: () => actionResultError(KeyValueStoreGetAllErrorTypeEnum.ServiceUnavailable, 'KVS Service Unavailable'),
+                ResourceNotFoundException: () => actionResultError(KeyValueStoreGetAllErrorTypeEnum.ResourceNotFound, 'KVS Resource Not Found'),
+            });
+        }
     };
 };
 export const getKeyValueStoreGetAllActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/keyValueStore/getKeyValueStoreQueryActionProcessor.js

@@ -1,6 +1,6 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResultError, ErrorTypeEnum, qpqCoreUtils } from 'quidproquo-core';
-import { actionResult, KeyValueStoreActionType } from 'quidproquo-core';
+import { actionResultError, actionResultErrorFromCaughtError, ErrorTypeEnum, qpqCoreUtils } from 'quidproquo-core';
+import { actionResult, KeyValueStoreActionType, KeyValueStoreQueryErrorTypeEnum } from 'quidproquo-core';
 import { getKvsDynamoTableNameFromConfig } from '../../../awsNamingUtils';
 import { query } from '../../../logic/dynamo';
 import { getDynamoTableIndexByConfigAndQuery } from '../../../logic/dynamo/qpqDynamoOrm';
@@ -12,8 +12,16 @@ const getProcessKeyValueStoreQuery = (qpqConfig) => {
         if (!storeConfig) {
             return actionResultError(ErrorTypeEnum.NotFound, `Could not find key value store with name "${keyValueStoreName}"`);
         }
-        const items = await query(dynamoTableName, region, keyCondition, options?.filter, options?.nextPageKey, getDynamoTableIndexByConfigAndQuery(storeConfig, keyCondition), options?.limit, options?.sortAscending);
-        return actionResult(items);
+        try {
+            const items = await query(dynamoTableName, region, keyCondition, options?.filter, options?.nextPageKey, getDynamoTableIndexByConfigAndQuery(storeConfig, keyCondition), options?.limit, options?.sortAscending);
+            return actionResult(items);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                InternalServerError: () => actionResultError(KeyValueStoreQueryErrorTypeEnum.ServiceUnavailable, 'KVS Service Unavailable'),
+                ResourceNotFoundException: () => actionResultError(KeyValueStoreQueryErrorTypeEnum.ResourceNotFound, 'KVS Resource Not Found'),
+            });
+        }
     };
 };
 export const getKeyValueStoreQueryActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/keyValueStore/getKeyValueStoreScanActionProcessor.js

@@ -1,13 +1,22 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, KeyValueStoreActionType } from 'quidproquo-core';
+import { actionResultError, actionResultErrorFromCaughtError } from 'quidproquo-core';
+import { actionResult, KeyValueStoreActionType, KeyValueStoreScanErrorTypeEnum } from 'quidproquo-core';
 import { getKvsDynamoTableNameFromConfig } from '../../../awsNamingUtils';
 import { scan } from '../../../logic/dynamo/scan';
 const getProcessKeyValueStoreScan = (qpqConfig) => {
     return async ({ keyValueStoreName, filterCondition, nextPageKey }) => {
         const dynamoTableName = getKvsDynamoTableNameFromConfig(keyValueStoreName, qpqConfig, 'kvs');
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
-        const items = await scan(dynamoTableName, region, filterCondition, nextPageKey);
-        return actionResult(items);
+        try {
+            const items = await scan(dynamoTableName, region, filterCondition, nextPageKey);
+            return actionResult(items);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                InternalServerError: () => actionResultError(KeyValueStoreScanErrorTypeEnum.ServiceUnavailable, 'KVS Service Unavailable'),
+                ResourceNotFoundException: () => actionResultError(KeyValueStoreScanErrorTypeEnum.ResourceNotFound, 'KVS Resource Not Found'),
+            });
+        }
     };
 };
 export const getKeyValueStoreScanActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/keyValueStore/getKeyValueStoreUpdateActionProcessor.js

@@ -1,6 +1,6 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
 import { qpqCoreUtils } from 'quidproquo-core';
-import { actionResult, KeyValueStoreActionType } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, KeyValueStoreActionType, KeyValueStoreUpdateErrorTypeEnum } from 'quidproquo-core';
 import { getKvsDynamoTableNameFromConfig } from '../../../awsNamingUtils';
 import { updateItem } from '../../../logic/dynamo';
 const getProcessKeyValueStoreUpdate = (qpqConfig) => {
@@ -8,8 +8,16 @@ const getProcessKeyValueStoreUpdate = (qpqConfig) => {
         const dynamoTableName = getKvsDynamoTableNameFromConfig(keyValueStoreName, qpqConfig, 'kvs');
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const storeConfig = qpqCoreUtils.getKeyValueStoreByName(qpqConfig, keyValueStoreName);
-        const item = await updateItem(dynamoTableName, region, updates, storeConfig.partitionKey.key, key, storeConfig.sortKeys[0]?.key, sortKey);
-        return actionResult(item);
+        try {
+            const item = await updateItem(dynamoTableName, region, updates, storeConfig.partitionKey.key, key, storeConfig.sortKeys[0]?.key, sortKey);
+            return actionResult(item);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                InternalServerError: () => actionResultError(KeyValueStoreUpdateErrorTypeEnum.ServiceUnavailable, 'KVS Service Unavailable'),
+                ResourceNotFoundException: () => actionResultError(KeyValueStoreUpdateErrorTypeEnum.ResourceNotFound, 'KVS Resource Not Found'),
+            });
+        }
     };
 };
 export const getKeyValueStoreUpdateActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/queue/getQueueSendMessageActionProcessor.js

@@ -1,23 +1,30 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, QueueActionType } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, QueueActionType, QueueSendMessagesErrorTypeEnum, toCrossServiceSession } from 'quidproquo-core';
 import { sendMessages } from '../../../logic/sqs/sendMessages';
 import { resolveResourceName } from '../../../runtimeConfig/qpqAwsLambdaRuntimeConfigUtils';
 const getProcessQueueSendMessage = (qpqConfig) => {
-    return async ({ queueName, queueMessages, context }, session) => {
+    return async ({ queueName, queueMessages }, session) => {
         // While we have some uuids
         const sqsQueueName = resolveResourceName(queueName, qpqConfig);
-        await sendMessages(sqsQueueName, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), queueMessages.map((message) => {
-            // Add the session info to the message
-            const queueMessageWithSession = {
-                ...message,
-                storySession: {
-                    ...session,
-                    context,
-                },
-            };
-            return JSON.stringify(queueMessageWithSession);
-        }));
-        return actionResult(void 0);
+        try {
+            await sendMessages(sqsQueueName, qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig), queueMessages.map((message) => {
+                // Add the session info to the message
+                const queueMessageWithSession = {
+                    ...message,
+                    storySession: toCrossServiceSession(session),
+                };
+                return JSON.stringify(queueMessageWithSession);
+            }));
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                AccessDenied: () => actionResultError(QueueSendMessagesErrorTypeEnum.AccessDenied, 'Access denied sending to queue'),
+                AccessDeniedException: () => actionResultError(QueueSendMessagesErrorTypeEnum.AccessDenied, 'Access denied sending to queue'),
+                QueueDoesNotExist: () => actionResultError(QueueSendMessagesErrorTypeEnum.QueueNotFound, `Queue not found: ${queueName}`),
+                RequestThrottled: () => actionResultError(QueueSendMessagesErrorTypeEnum.ServiceUnavailable, 'Queue throttled'),
+            });
+        }
     };
 };
 export const getQueueSendMessagesActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/system/getSystemExecuteStoryActionProcessor.js

@@ -11,6 +11,7 @@ const getProcessExecuteStory = (qpqConfig) => {
         const functionKey = getUniqueKeyFromQpqFunctionRuntime(payload.runtime);
         const resolveStory = createRuntime(qpqConfig, {
             context: payload.storySession?.context || session.context,
+            localContext: payload.storySession?.localContext || session.localContext,
             depth: (payload.storySession?.depth || session.depth || 0) + 1,
             decodedAccessToken: payload.storySession?.decodedAccessToken || session.decodedAccessToken,
             correlation: payload.storySession?.correlation || session.correlation,

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryAssociateSoftwareTokenActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getUserDirectoryAssociateSoftwareTokenActionProcessor: ActionProcessorListResolver;

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryAssociateSoftwareTokenActionProcessor.js

@@ -0,0 +1,13 @@
+import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
+import { actionResult, UserDirectoryActionType, } from 'quidproquo-core';
+import { associateSoftwareToken } from '../../../logic/cognito/associateSoftwareToken';
+const getProcessAssociateSoftwareToken = (qpqConfig) => {
+    return async ({ session }) => {
+        const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
+        const response = await associateSoftwareToken(region, session);
+        return actionResult(response);
+    };
+};
+export const getUserDirectoryAssociateSoftwareTokenActionProcessor = async (qpqConfig) => ({
+    [UserDirectoryActionType.AssociateSoftwareToken]: getProcessAssociateSoftwareToken(qpqConfig),
+});

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryChangePasswordActionProcessor.js

@@ -1,11 +1,20 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, UserDirectoryActionType, UserDirectoryChangePasswordErrorTypeEnum, } from 'quidproquo-core';
 import { changePassword } from '../../../logic/cognito/changePassword';
 const getProcessChangePassword = (qpqConfig) => {
     return async ({ oldPassword, newPassword, accessToken }) => {
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
-        await changePassword(accessToken, oldPassword, newPassword, region);
-        return actionResult(void 0);
+        try {
+            await changePassword(accessToken, oldPassword, newPassword, region);
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                NotAuthorizedException: () => actionResultError(UserDirectoryChangePasswordErrorTypeEnum.IncorrectPassword, 'Current password is incorrect'),
+                InvalidPasswordException: () => actionResultError(UserDirectoryChangePasswordErrorTypeEnum.InvalidNewPassword, 'New password does not meet the password policy'),
+                LimitExceededException: () => actionResultError(UserDirectoryChangePasswordErrorTypeEnum.LimitExceeded, 'Too many attempts, please try again later'),
+            });
+        }
     };
 };
 export const getUserDirectoryChangePasswordActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryConfirmEmailVerificationActionProcessor.js

@@ -1,11 +1,20 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, UserDirectoryActionType, UserDirectoryConfirmEmailVerificationErrorTypeEnum, } from 'quidproquo-core';
 import { verifyUserEmail } from '../../../logic/cognito/verifyUserEmail';
 const getProcessConfirmEmailVerification = (qpqConfig) => {
     return async ({ code, accessToken }) => {
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
-        await verifyUserEmail(region, accessToken, code);
-        return actionResult(void 0);
+        try {
+            await verifyUserEmail(region, accessToken, code);
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                CodeMismatchException: () => actionResultError(UserDirectoryConfirmEmailVerificationErrorTypeEnum.InvalidCode, 'Verification code is incorrect'),
+                ExpiredCodeException: () => actionResultError(UserDirectoryConfirmEmailVerificationErrorTypeEnum.ExpiredCode, 'Verification code has expired'),
+                LimitExceededException: () => actionResultError(UserDirectoryConfirmEmailVerificationErrorTypeEnum.LimitExceeded, 'Too many attempts, please try again later'),
+            });
+        }
     };
 };
 export const getUserDirectoryConfirmEmailVerificationActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryConfirmForgotPasswordActionProcessor.js

@@ -1,5 +1,5 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, UserDirectoryActionType, UserDirectoryConfirmForgotPasswordErrorTypeEnum, } from 'quidproquo-core';
 import { getCFExportNameUserPoolClientIdFromConfig, getCFExportNameUserPoolIdFromConfig } from '../../../awsNamingUtils';
 import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
 import { confirmForgotPassword } from '../../../logic/cognito/confirmForgotPassword';
@@ -10,8 +10,18 @@ const getProcessConfirmForgotPassword = (qpqConfig) => {
         const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
         const userPoolClientId = await getExportedValue(getCFExportNameUserPoolClientIdFromConfig(userDirectoryName, qpqConfig), region);
         const resolvedUsername = await resolveUsernameByPreferredUsername(userPoolId, region, username);
-        const authResponse = await confirmForgotPassword(userPoolId, userPoolClientId, region, code, resolvedUsername, password);
-        return actionResult(authResponse);
+        try {
+            const authResponse = await confirmForgotPassword(userPoolId, userPoolClientId, region, code, resolvedUsername, password);
+            return actionResult(authResponse);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                CodeMismatchException: () => actionResultError(UserDirectoryConfirmForgotPasswordErrorTypeEnum.InvalidCode, 'Confirmation code is incorrect'),
+                ExpiredCodeException: () => actionResultError(UserDirectoryConfirmForgotPasswordErrorTypeEnum.ExpiredCode, 'Confirmation code has expired'),
+                InvalidPasswordException: () => actionResultError(UserDirectoryConfirmForgotPasswordErrorTypeEnum.InvalidNewPassword, 'New password does not meet the password policy'),
+                LimitExceededException: () => actionResultError(UserDirectoryConfirmForgotPasswordErrorTypeEnum.LimitExceeded, 'Too many attempts, please try again later'),
+            });
+        }
     };
 };
 export const getUserDirectoryConfirmForgotPasswordActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryCreateUserActionProcessor.js

@@ -1,5 +1,5 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, actionResultError, ErrorTypeEnum, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, UserDirectoryActionType, UserDirectoryCreateUserErrorTypeEnum, } from 'quidproquo-core';
 import { getCFExportNameUserPoolClientIdFromConfig, getCFExportNameUserPoolIdFromConfig } from '../../../awsNamingUtils';
 import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
 import { createUser } from '../../../logic/cognito/createUser';
@@ -11,10 +11,19 @@ const getProcessCreateUser = (qpqConfig) => {
         const userPoolClientId = await getExportedValue(getCFExportNameUserPoolClientIdFromConfig(payload.userDirectoryName, qpqConfig), region);
         const resolvedUsername = await resolveUsernameByPreferredUsername(userPoolId, region, payload.createUserRequest.email);
         if (resolvedUsername !== payload.createUserRequest.email) {
-            return actionResultError(ErrorTypeEnum.Conflict, 'An account with this email already exists');
+            return actionResultError(UserDirectoryCreateUserErrorTypeEnum.Conflict, 'An account with this email already exists');
+        }
+        try {
+            const authResponse = await createUser(userPoolId, region, userPoolClientId, payload.createUserRequest);
+            return actionResult(authResponse);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                UsernameExistsException: () => actionResultError(UserDirectoryCreateUserErrorTypeEnum.Conflict, 'An account with this email already exists'),
+                InvalidPasswordException: () => actionResultError(UserDirectoryCreateUserErrorTypeEnum.InvalidPassword, 'Password does not meet the password policy'),
+                LimitExceededException: () => actionResultError(UserDirectoryCreateUserErrorTypeEnum.LimitExceeded, 'Too many attempts, please try again later'),
+            });
         }
-        const authResponse = await createUser(userPoolId, region, userPoolClientId, payload.createUserRequest);
-        return actionResult(authResponse);
     };
 };
 export const getUserDirectoryCreateUserActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryDecodeAccessTokenActionProcessor.js

@@ -1,5 +1,5 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, actionResultError, ErrorTypeEnum, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, UserDirectoryActionType, UserDirectoryDecodeAccessTokenErrorTypeEnum, } from 'quidproquo-core';
 import { getCFExportNameUserPoolIdFromConfig } from '../../../awsNamingUtils';
 import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
 import { decodeValidJwt } from '../../../logic/cognito/decodeValidJwt';
@@ -9,7 +9,7 @@ const getProcessDecodeAccessToken = (qpqConfig) => {
         const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
         const authInfo = await decodeValidJwt(userPoolId, region, ignoreExpiration, accessToken);
         if (!authInfo || !authInfo?.username) {
-            return actionResultError(ErrorTypeEnum.Unauthorized, 'Invalid access token');
+            return actionResultError(UserDirectoryDecodeAccessTokenErrorTypeEnum.Unauthorized, 'Invalid access token');
         }
         return actionResult({
             ...authInfo,

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryForgotPasswordActionProcessor.js

@@ -1,5 +1,5 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, UserDirectoryActionType, UserDirectoryForgotPasswordErrorTypeEnum, } from 'quidproquo-core';
 import { getCFExportNameUserPoolClientIdFromConfig, getCFExportNameUserPoolIdFromConfig } from '../../../awsNamingUtils';
 import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
 import { forgotPassword } from '../../../logic/cognito/forgotPassword';
@@ -10,8 +10,16 @@ const getProcessForgotPassword = (qpqConfig) => {
         const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
         const userPoolClientId = await getExportedValue(getCFExportNameUserPoolClientIdFromConfig(userDirectoryName, qpqConfig), region);
         const resolvedUsername = await resolveUsernameByPreferredUsername(userPoolId, region, username);
-        const authResponse = await forgotPassword(userPoolId, userPoolClientId, region, resolvedUsername);
-        return actionResult(authResponse);
+        try {
+            const authResponse = await forgotPassword(userPoolId, userPoolClientId, region, resolvedUsername);
+            return actionResult(authResponse);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                UserNotFoundException: () => actionResultError(UserDirectoryForgotPasswordErrorTypeEnum.UserNotFound, 'No account found for this user'),
+                LimitExceededException: () => actionResultError(UserDirectoryForgotPasswordErrorTypeEnum.LimitExceeded, 'Too many attempts, please try again later'),
+            });
+        }
     };
 };
 export const getUserDirectoryForgotPasswordActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryGetUserAttributesByUserIdActionProcessor.js

@@ -1,5 +1,5 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, UserDirectoryActionType, UserDirectoryGetUserAttributesByUserIdErrorTypeEnum, } from 'quidproquo-core';
 import { getCFExportNameUserPoolIdFromConfig } from '../../../awsNamingUtils';
 import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
 import { getUserAttributesBySub } from '../../../logic/cognito/getUserAttributesBySub';
@@ -7,8 +7,15 @@ const getProcessGetUserAttributesByUserId = (qpqConfig) => {
     return async ({ userDirectoryName, userId }, session) => {
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
-        const userAttributes = await getUserAttributesBySub(userPoolId, region, userId);
-        return actionResult(userAttributes);
+        try {
+            const userAttributes = await getUserAttributesBySub(userPoolId, region, userId);
+            return actionResult(userAttributes);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                USER_NOT_FOUND: () => actionResultError(UserDirectoryGetUserAttributesByUserIdErrorTypeEnum.UserNotFound, 'No user found for this userId'),
+            });
+        }
     };
 };
 export const getUserDirectoryGetUserAttributesByUserIdActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryGetUsersActionProcessor.js

@@ -1,5 +1,5 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, UserDirectoryActionType, UserDirectoryGetUsersErrorTypeEnum, } from 'quidproquo-core';
 import { getCFExportNameUserPoolIdFromConfig } from '../../../awsNamingUtils';
 import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
 import { listPagedUsers } from '../../../logic/cognito/listPagedUsers';
@@ -7,8 +7,16 @@ const getProcessGetUsers = (qpqConfig) => {
     return async ({ userDirectoryName, nextPageKey }, session) => {
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
-        const userAttributes = await listPagedUsers(userPoolId, region, nextPageKey);
-        return actionResult(userAttributes);
+        try {
+            const userAttributes = await listPagedUsers(userPoolId, region, nextPageKey);
+            return actionResult(userAttributes);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                InvalidParameterException: () => actionResultError(UserDirectoryGetUsersErrorTypeEnum.InvalidPageKey, 'The supplied page key is invalid'),
+                TooManyRequestsException: () => actionResultError(UserDirectoryGetUsersErrorTypeEnum.LimitExceeded, 'Too many requests, please try again later'),
+            });
+        }
     };
 };
 export const getUserDirectoryGetUsersActionProcessor = async (qpqConfig) => ({

package/lib/esm/getActionProcessor/core/userDirectory/getUserDirectoryGetUsersByAttributeActionProcessor.js

@@ -1,5 +1,5 @@
 import { qpqConfigAwsUtils } from 'quidproquo-config-aws';
-import { actionResult, UserDirectoryActionType, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, UserDirectoryActionType, UserDirectoryGetUsersByAttributeErrorTypeEnum, } from 'quidproquo-core';
 import { getCFExportNameUserPoolIdFromConfig } from '../../../awsNamingUtils';
 import { getExportedValue } from '../../../logic/cloudformation/getExportedValue';
 import { listPagedUsersByAttribute } from '../../../logic/cognito/listPagedUsersByAttribute';
@@ -7,8 +7,16 @@ const getProcessGetUsersByAttribute = (qpqConfig) => {
     return async ({ userDirectoryName, attribueName, attribueValue, limit, nextPageKey }, _session) => {
         const region = qpqConfigAwsUtils.getApplicationModuleDeployRegion(qpqConfig);
         const userPoolId = await getExportedValue(getCFExportNameUserPoolIdFromConfig(userDirectoryName, qpqConfig), region);
-        const userAttributes = await listPagedUsersByAttribute(userPoolId, region, attribueName, attribueValue, limit, nextPageKey);
-        return actionResult(userAttributes);
+        try {
+            const userAttributes = await listPagedUsersByAttribute(userPoolId, region, attribueName, attribueValue, limit, nextPageKey);
+            return actionResult(userAttributes);
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                InvalidParameterException: () => actionResultError(UserDirectoryGetUsersByAttributeErrorTypeEnum.InvalidSearchParameters, 'The search attribute, value, limit, or page key is invalid'),
+                TooManyRequestsException: () => actionResultError(UserDirectoryGetUsersByAttributeErrorTypeEnum.LimitExceeded, 'Too many requests, please try again later'),
+            });
+        }
     };
 };
 export const getUserDirectoryGetUsersByAttributeActionProcessor = async (qpqConfig) => ({