piper-utils 1.0.4 → 1.0.5-7.1

package/src/database/dbUtils/queryStringUtils/createFilters.test.js

@@ -1,9 +1,9 @@
 import { createFilters } from './createFilters.js';
-import { defaultFiltersWithSubSchema, event, eventWithSingleElementAsArray, eventWithSingleElementInArray } from './mocks/mocks.js';
-import DB from 'sequelize';
+import { defaultFiltersWithSubSchema, event, eventWithSearchString, eventWithSearchStringNumber, eventWithSingleElementAsArray, eventWithSingleElementInArray, manyStringFields } from './mocks/mocks.js';
+import DB, { or } from 'sequelize';
 
 describe('createFilters', function () {
-    it('should handle case insensitive searches', function (){
+    it('should handle case insensitive searches', function () {
         const where = createFilters(event, defaultFiltersWithSubSchema);
         expect(where.char).toEqual({ [DB.Op.iLike]: '%StringToSearch%' });
     });
@@ -34,4 +34,22 @@ describe('createFilters', function () {
         expect(where.notOnObject).not.toBeDefined();
         expect(where.date).not.toBeDefined();
     });
+
+    it('should handle searchString', function () {
+        const where = createFilters(eventWithSearchString, manyStringFields);
+        const orSymbols = Object.getOwnPropertySymbols(where);
+        expect(orSymbols.length).toBeGreaterThan(0);
+    });
+
+    it('should handle searchString if value is a number', function () {
+        const where = createFilters(eventWithSearchStringNumber, manyStringFields);
+        const orSymbols = Object.getOwnPropertySymbols(where);
+        expect(orSymbols.length).toBeGreaterThan(0);
+    });
+
+    it('should handle searchString sub fields', function () {
+        const where = createFilters(eventWithSearchStringNumber, defaultFiltersWithSubSchema);
+        const orSymbols = Object.getOwnPropertySymbols(where);
+        expect(orSymbols.length).toBeGreaterThan(0);
+    });
 });

package/src/database/dbUtils/queryStringUtils/findAll.js

@@ -31,7 +31,8 @@ export function getPaginationFromFindAll(result, limit, offset) {
 export async function findAll(model, options) {
 
     const limit = options.limit || 0;
-    const findArgs = Object.assign({include: { all: true, nested: true }}, options, { limit: limit + 1 });
+    const includes = options.includes || { all: true, nested: true };
+    const findArgs = Object.assign({include: includes}, options, { limit: limit + 1 });
     const results = await model.findAll(findArgs);
     return getPaginationFromFindAll(results, limit, options.offset);
 }

package/src/database/dbUtils/queryStringUtils/mocks/mocks.js

@@ -30,6 +30,16 @@ export const defaultFiltersWithSubSchema = {
     array: { filterType: DB.Op.in }
 };
 
+export const manyStringFields = {
+    id: { filterType: DB.Op.eq },
+    name: { filterType: DB.Op.iLike },
+    title: { filterType: DB.Op.iLike },
+    size: { filterType: DB.Op.iLike },
+    decimal: { filterType: DB.Op.or },
+    boolean: { type: DB.BOOLEAN, filterType: DB.Op.eq },
+    array: { filterType: DB.Op.in }
+};
+
 export const event = {
     'pathParameters': {
         'id': '1'
@@ -61,6 +71,39 @@ export const event = {
         'sort': 'decimal,-id,boolean,notOnObject,-date,FLURB.id'
     }
 };
+export const eventWithSearchString = {
+    'pathParameters': {
+        'id': '1'
+    },
+    'body': '{}',
+    'requestContext': {
+        'authorizer': {
+            'claims': {
+                'custom:businessIds': '[\'1\',\'2\',\'3\',\'4\']'
+            }
+        }
+    },
+    'queryStringParameters': {
+        'searchString': 'alpha-search'
+    }
+};
+
+export const eventWithSearchStringNumber = {
+    'pathParameters': {
+        'id': '1'
+    },
+    'body': '{}',
+    'requestContext': {
+        'authorizer': {
+            'claims': {
+                'custom:businessIds': '[\'1\',\'2\',\'3\',\'4\']'
+            }
+        }
+    },
+    'queryStringParameters': {
+        'searchString': '900'
+    }
+};
 
 export const eventWithSingleElementInArray = {
     'pathParameters': {

package/src/eventManager/handleEvents.js

@@ -18,7 +18,9 @@ export function handleEvents(event, transformer, errorHandlerPerFile, shouldSkip
             let path = decodeURIComponent(file);
             if (path) {
                 return handleFile(path, s3Bucket, transformer, { shouldSkipFailedFolders, userImportTypes }).catch((err) => {
+                    console.error('###############--@--->',err)
                     if (errorHandlerPerFile && !errorHandlerPerFile(err, path)) {
+                        console.error('HANDLE-FILE-CATCH: ', err);
                         hasErrors = true;
                     }
                 });
@@ -26,7 +28,35 @@ export function handleEvents(event, transformer, errorHandlerPerFile, shouldSkip
         });
     }).then(() => {
         if (hasErrors) {
-            throw 'Errors processing one or more files. See error logs for detail on each error.';
+            throw 'ERROR: HANDLE-FILE';
+        }
+    });
+}
+
+export function handleDirectS3WriteEvent(event, transformer, errorHandlerPerFile, shouldSkipFailedFolders = false, userImportTypes) {
+    if (!event || !event.Records) {
+        return Promise.resolve();
+    }
+
+    let hasErrors = false;
+
+    return Promise.map(event.Records, (record) => {
+        const s3Bucket = record.s3.bucket.name;
+        const file = record.s3.object.key || [];
+
+        let path = decodeURIComponent(file);
+        if (path) {
+            return handleFile(path, s3Bucket, transformer, { shouldSkipFailedFolders, userImportTypes }).catch((err) => {
+                if (errorHandlerPerFile && !errorHandlerPerFile(err, path)) {
+                    console.error('HANDLE-FILE-CATCH:', err);
+                    hasErrors = true;
+                }
+            });
+        }
+
+    }).then(() => {
+        if (hasErrors) {
+            throw 'ERROR: HANDLE-FILE (DIRECT S3 EVENT)';
         }
     });
 }

package/src/eventManager/handleFile.js

@@ -8,16 +8,19 @@ export async function handleFile(path, s3Bucket, transformer, options) {
         Bucket: s3Bucket,
         Key: path
     };
-    let body = '{}'
+    let body = '{}';
     try {
-        body = await S3Util.getObject(params);
+        const s3r = await S3Util.getObject(params);
+        console.log('------->s3r', s3r);
+        body = s3r
         const parsedBody = JSON.parse(body);
+        console.log('------->parsedBody-if this is empty body we need to skip transform?', parsedBody);
         const returnedValue = await transformer(parsedBody);
         await S3Util.deleteObject(params);
 
         return returnedValue;
     } catch (error) {
-        console.error('handle-file-error', error);
+        console.error('HANDLE-FILE-ERROR', error);
 
         if (error.code === 'NoSuchKey' || !body) {
             return;
@@ -26,6 +29,7 @@ export async function handleFile(path, s3Bucket, transformer, options) {
         let newPath = '';
 
         if (userImportTypes) {
+            console.log('USER IMPORT')
             // look for items in the userImportTypes
             const usersImports = Object.values(userImportTypes);
             const items = path.split('/');
@@ -68,9 +72,22 @@ export async function handleFile(path, s3Bucket, transformer, options) {
             Body: body
         };
 
+        if (containsErrorTwice(newPath, 'failed-once')
+            || containsErrorTwice(newPath, 'failed-twice')
+            || containsErrorTwice(newPath, 'error')) {
+            throw 'NESTING ERROR';
+        }
+
         await S3Util.putObject(newParams);
         await S3Util.deleteObject(params);
 
         throw error;
     }
 }
+
+export function containsErrorTwice(str, val) {
+    const firstIndex = str.toLowerCase().indexOf(val);
+    if (firstIndex === -1) return false;
+    const secondIndex = str.toLowerCase().indexOf(val, firstIndex + 1);
+    return secondIndex !== -1;
+}

package/src/eventManager/handleFile.test.js

@@ -1,5 +1,5 @@
 import Promise from 'bluebird';
-import { handleFile } from './handleFile.js';
+import { containsErrorTwice, handleFile } from './handleFile.js';
 import S3Util from '../s3/S3Utils.js/S3Utils.js';
 
 describe('handleFile', () => {
@@ -330,9 +330,9 @@ describe('handleFile', () => {
             }
         };
 
-        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }' ));
+        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
         spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
-        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'))
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
 
         spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
         const userImportTypes = {
@@ -349,4 +349,33 @@ describe('handleFile', () => {
             });
         });
     });
+    it('should throw if nesting error folders', async () => {
+        const creator = {
+            createFunc: () => {
+                return Promise.resolve();
+            }
+        };
+
+        spyOn(S3Util, 'getObject').and.returnValue(Promise.resolve('{ "test": "val" }'));
+        spyOn(S3Util, 'deleteObject').and.returnValue(Promise.resolve('{}'));
+        const putObjectSpy = spyOn(S3Util, 'putObject').and.returnValue(Promise.resolve('{}'));
+        spyOn(creator, 'createFunc').and.rejectWith({ message: 'THIS FUNCTION FAILED' });
+
+        try {
+            await handleFile('error/error/file.json', 'someBucket', creator.createFunc);
+        } catch (e) {
+            expect(e).toBe('NESTING ERROR');
+            expect(putObjectSpy).not.toHaveBeenCalled();
+        }
+
+    });
+    it('containsErrorTwice: should throw if nesting error folders', async () => {
+        const r = containsErrorTwice('error/error', 'error');
+        expect(r).toBe(true);
+
+    });
+    it('containsErrorTwice: should throw if nesting error folders', async () => {
+        const r = containsErrorTwice('error/false', 'error');
+        expect(r).toBe(false);
+    });
 });

package/src/eventManager/watchBucket.js

@@ -1,9 +1,10 @@
 import { publishEvents } from './publishEvents.js';
-import { handleEvents } from './handleEvents.js';
+import { handleEvents, handleDirectS3WriteEvent } from './handleEvents.js';
 import _ from 'lodash';
 
 /**
  * bucket watcher watches a s3 bucket and publishes events to a sns topic, this allows you to process files in s3 with a some transformer function
+ * prefix objects with DIRECT to listen to direct s3 events
  *
  * @param {object} params - The parameters for watchBucket, see below
  * @param {object} params.event - The event of the lambda
@@ -14,7 +15,7 @@ import _ from 'lodash';
  * @param {function} params.transformer - the function to run on each file
  * @param {function} [params.errorHandlerPerFile] - the function to run on as a catch on each file
  * @param {boolean} [params.shouldSkipFailedFolders] - whether to use the failed-once, failed-twice, error or just error folders
- * @param {object} [params.userImportTypes] - user import sub directories object map
+ * @param {object} [params.userImportTypes] - user import subdirectories object map
  */
 export function watchBucket({
                                 event,
@@ -31,9 +32,27 @@ export function watchBucket({
         throw new Error('Missing required parameters. Need event, dynamoConfigTable, dynamoConfigKey, s3Bucket, snsTopic, transformer');
     }
 
-    const EventSource = _.get(event, 'Records[0].EventSource');
+    const EventSource = _.get(event, 'Records[0].eventSource') || _.get(event, 'Records[0].EventSource');
+
     if (_.isEqual(EventSource, 'aws:sns')) {
         return handleEvents(event, transformer, errorHandlerPerFile, shouldSkipFailedFolders, userImportTypes);
+    } else if (_.isEqual(EventSource, 'aws:s3')) {
+        const failedOnce = 'failed-once';
+        const failedTwice = 'failed-twice';
+        const error = 'error';
+        const direct = 'DIRECT';
+        const key = _.get(event, 'Records[0].s3.object.key') || '';
+        const startsWithDirect = _.startsWith(key, direct);
+        if (key.includes(failedOnce) || key.includes(failedTwice) || key.includes(error)) {
+            // this used to throw, but the throw raised useless alarms, I believed turing throw in to a return was ok
+            return;
+        }
+
+        if (startsWithDirect) {
+            console.log('------->DIRECT WRITE FIRE');
+            return handleDirectS3WriteEvent(event, transformer, errorHandlerPerFile, shouldSkipFailedFolders, userImportTypes);
+        }
+
     } else {
         // the function is being run from the cron job so publish SNS events
         return publishEvents(dynamoConfigTable, dynamoConfigKey, s3Bucket, snsTopic, userImportTypes);

package/src/eventManager/watchBucket.test.js

@@ -3,6 +3,84 @@ import * as handleEvents from './handleEvents.js';
 import * as publishEventsFunc from './publishEvents.js';
 import _ from 'lodash';
 
+const directEventMock = {
+    'Records': [
+        {
+            'eventVersion': '2.1',
+            'eventSource': 'aws:s3',
+            'awsRegion': 'us-east-1',
+            'eventTime': '2024-06-30T02:14:21.023Z',
+            'eventName': 'ObjectCreated:Put',
+            'userIdentity': {
+                'principalId': 'AWS:AROA5F2DYBZDQJZJL6QJ3:piper-development-updateOrder'
+            },
+            'requestParameters': {
+                'sourceIPAddress': '3.89.10.118'
+            },
+            'responseElements': {
+                'x-amz-request-id': 'TXTBHCFPQCG7G9XZ',
+                'x-amz-id-2': 'w/j8mQQpM6QcH0GOW2SQGh2yrj38NEeiOucQxnYODv77FuNYegVHwAm24B+EqcjuvhmRo1Kve28m8PzDHSENzokrGZC0r/xq'
+            },
+            's3': {
+                's3SchemaVersion': '1.0',
+                'configurationId': 'piper-hooks-development-handleWebhook-e8435433a831248ee12806555a8d414d',
+                'bucket': {
+                    'name': 'notify-webhook-dev',
+                    'ownerIdentity': {
+                        'principalId': 'A27KTZMXKEPEYT'
+                    },
+                    'arn': 'arn:aws:s3:::notify-webhook-dev'
+                },
+                'object': {
+                    'key': 'DIRECT-1z2HUO9nT2-106-orderUpdated-2024-06-30.json',
+                    'size': 186,
+                    'eTag': 'dca24fb9226703fcb0d64bd3e0833f16',
+                    'sequencer': '006680BF7CF4E2AA36'
+                }
+            }
+        }
+    ]
+};
+
+const errorBucketMock = {
+    'Records': [
+        {
+            'eventVersion': '2.1',
+            'eventSource': 'aws:s3',
+            'awsRegion': 'us-east-1',
+            'eventTime': '2024-06-30T03:33:47.071Z',
+            'eventName': 'ObjectCreated:Put',
+            'userIdentity': {
+                'principalId': 'AWS:AROA5F2DYBZD5OBZV274Z:piper-hooks-development-handleWebhook'
+            },
+            'requestParameters': {
+                'sourceIPAddress': '44.222.115.132'
+            },
+            'responseElements': {
+                'x-amz-request-id': 'P82WFW970DEXHPER',
+                'x-amz-id-2': 'ZfM/HalpIrLKJf+hx+q1ldaKoPH1IxUZtyXe1B80dx04lbiJk+9uge7pnEFRsBchGLdNEdeFwAO1+xUfOP9oCz19rZeHHSZU'
+            },
+            's3': {
+                's3SchemaVersion': '1.0',
+                'configurationId': 'piper-hooks-development-handleWebhook-e8435433a831248ee12806555a8d414d',
+                'bucket': {
+                    'name': 'notify-webhook-dev',
+                    'ownerIdentity': {
+                        'principalId': 'A27KTZMXKEPEYT'
+                    },
+                    'arn': 'arn:aws:s3:::notify-webhook-dev'
+                },
+                'object': {
+                    'key': 'error/1z2HUO9nT2-106-orderUpdated-2024-06-30.json',
+                    'size': 2,
+                    'eTag': '99914b932bd37a50b983c5e7c90ae93b',
+                    'sequencer': '006680D21B0BAEE0A8'
+                }
+            }
+        }
+    ]
+};
+
 describe('watchBucket.js', () => {
     describe('watchBucket', () => {
         it('should fail missing event', function () {
@@ -133,5 +211,46 @@ describe('watchBucket.js', () => {
                 expect(publishEventsSpy).not.toHaveBeenCalled();
             });
         });
+
+        it('NOT run direct s3 calls if key does not start with DIRECT to prevent infinite loops', function () {
+            const params = {
+                event: directEventMock,
+                dynamoConfigTable: 'dynamoConfigTable',
+                dynamoConfigKey: 'dynamoConfigKey',
+                s3Bucket: 's3Bucket',
+                snsTopic: 'snsTopic',
+                transformer: _.noop
+            };
+
+            const fromSnsSpy = spyOn(handleEvents, 'handleDirectS3WriteEvent').and.returnValue(Promise.resolve());
+            const publishEventsSpy = spyOn(publishEventsFunc, 'publishEvents').and.returnValue(Promise.resolve());
+
+            return watchBucket.watchBucket(params).then(() => {
+                expect(fromSnsSpy).toHaveBeenCalled();
+                expect(publishEventsSpy).not.toHaveBeenCalled();
+            });
+        });
+
+        it('throw if a watch for s3 is fired when a file is rewritten to error folder', function () {
+            const params = {
+                event: errorBucketMock,
+                dynamoConfigTable: 'dynamoConfigTable',
+                dynamoConfigKey: 'dynamoConfigKey',
+                s3Bucket: 's3Bucket',
+                snsTopic: 'snsTopic',
+                transformer: _.noop
+            };
+
+            const fromSnsSpy = spyOn(handleEvents, 'handleDirectS3WriteEvent').and.returnValue(Promise.resolve());
+            const publishEventsSpy = spyOn(publishEventsFunc, 'publishEvents').and.returnValue(Promise.resolve());
+
+            try {
+                watchBucket.watchBucket(params);
+                expect(fromSnsSpy).not.toHaveBeenCalled();
+                expect(publishEventsSpy).not.toHaveBeenCalled();
+            } catch (e) {
+                expect(e).toBe('INVALID WATCH')
+            }
+        });
     });
 });

package/src/index.js

@@ -1,10 +1,14 @@
 import { handleFile as handleFileImport } from './eventManager/handleFile.js';
 import { watchBucket as watchBucketImport } from './eventManager/watchBucket.js';
 import { publishEvents as publishEventsImport } from './eventManager/publishEvents.js';
+import { createIncludes as createIncludesImport } from './database/dbUtils/queryStringUtils/createIncludes.js';
 import { createFilters as createFiltersImport } from './database/dbUtils/queryStringUtils/createFilters.js';
 import { createSort as createSortImport } from './database/dbUtils/queryStringUtils/createSort.js';
 import { findAll as findAllImport } from './database/dbUtils/queryStringUtils/findAll.js';
 import { checkModule as checkModuleImport } from './database/dbUtils/queryStringUtils/accessRightsUtils.js';
+import { getModuleInfo as getModuleInfoImport } from './database/dbUtils/queryStringUtils/accessRightsUtils.js';
+import { getAccessRightsInfo as getAccessRightsInfoImport } from './database/dbUtils/queryStringUtils/accessRightsUtils.js';
+import { getDefaultBusinessIDInfo as getDefaultBusinessIDInfoImport } from './database/dbUtils/queryStringUtils/accessRightsUtils.js';
 import { failure as failureImport, success as successImport } from './requestResonse/requestResponse.js';
 import { runMigrations as runMigrationsImport } from './database/dbSetup/migrations.js';
 import { getCurrentUser as getCurrentUserImport } from './requestResonse/requestResponse.js';
@@ -17,14 +21,19 @@ import { parseEvent as parseEventImport } from './requestResonse/requestResponse
 import { getBusinessesInfo as getBusinessesInfoImport } from './database/dbUtils/queryStringUtils/accessRightsUtils.js';
 import { userDefaultBid as userDefaultBidImport } from './database/dbUtils/queryStringUtils/accessRightsUtils.js';
 import { checkWriteAccess as checkWriteAccessImport } from './database/dbUtils/queryStringUtils/accessRightsUtils.js';
+import { isSystemUser as isSystemUserImport } from './database/dbUtils/queryStringUtils/accessRightsUtils.js';
 
 export const handleFile = handleFileImport;
 export const watchBucket = watchBucketImport;
 export const publishEvents = publishEventsImport;
 export const createFilters = createFiltersImport;
+export const createIncludes = createIncludesImport;
 export const createSort = createSortImport;
 export const findAll = findAllImport;
 export const checkModule = checkModuleImport;
+export const getAccessRightsInfo = getAccessRightsInfoImport;
+export const getDefaultBusinessIDInfo = getDefaultBusinessIDInfoImport;
+export const getModuleInfo = getModuleInfoImport;
 export const failure = failureImport;
 export const success = successImport;
 export const runMigrations = runMigrationsImport;
@@ -38,3 +47,4 @@ export const parseEvent = parseEventImport;
 export const getBusinessesInfo = getBusinessesInfoImport;
 export const userDefaultBid = userDefaultBidImport;
 export const checkWriteAccess = checkWriteAccessImport;
+export const isSystemUser = isSystemUserImport;

package/src/requestResonse/requestResponse.js

@@ -3,7 +3,7 @@ import { errorList } from './errorCodes.js';
 
 /**
  * @param {Object} body
- * @param {{}} options
+ * @param {{dbClose?:function}} [options]
  */
 export function success(body, options) {
     const dbClose = _.get(options, 'dbClose', _.noop);
@@ -38,7 +38,7 @@ export function successHtml(html, options) {
 export function getCurrentUserNameFromCognitoEvent(event) {
     const attributes = _.get(event, 'request.userAttributes');
 
-    return attributes['cognito:email_alias'] || 'UNKNOWN USER';
+    return attributes['cognito:email_alias'] || attributes['email'] || 'UNKNOWN USER';
 }
 
 /**
@@ -54,7 +54,7 @@ export function getCurrentUser(event) {
 
     const id = JSON.parse(jsonToParse);
 
-    const username = _.get(event, 'requestContext.authorizer.claims.email') || _.get(event, 'requestContext.authorizer.email') || 'LOCAL TEST USER';
+    const username = _.get(event, 'requestContext.authorizer.claims.email') || _.get(event, 'requestContext.authorizer.email') || 'localtestuser@gexample.com';
 
     return {
         username,
@@ -74,7 +74,7 @@ export function failure(body = {}, options) {
     dbClose();
     let cleanedErrorBody;
 
-    if (process.env.UTIL_LOG === 'LOG_ALL') {
+    if (process.env.UTIL_LOG === 'LOG_ALL' || process.env.BUILD_ENV === 'test') {
         console.error('------->UTIL ERROR:', body);
     }
 
@@ -85,8 +85,8 @@ export function failure(body = {}, options) {
     } else if (_.isUndefined(body.errorCode) || _.isUndefined(body.statusCode)) {
         cleanedErrorBody = detectSequelizeError(body);
     }
-    if(_.get(body, 'response.data.message')) {
-        console.error('------->UTIL ERROR: '+_.get(body, 'response.data.message'))
+    if (_.get(body, 'response.data.message')) {
+        console.error('------->UTIL ERROR: ' + _.get(body, 'response.data.message'));
     }
 
     const newBody = _.merge(NORMAL_ERROR, cleanedErrorBody);
@@ -194,5 +194,42 @@ export function detectJoyError(body) {
     errorBody.message = joyError.message;
     errorBody.statusCode = 400;
     errorBody.errorCode = '4000';
+    return errorBody;
+}
+
+/**
+ * Parse the body of a Dynamoose error response.
+ * Attempts to extract a human-readable error message from Dynamoose errors.
+ * This is a fallback for unknown database errors.
+ *
+ * @param {object} body - Part of a body response containing error details.
+ * @returns {object} - Error message object { message: string }
+ */
+export function detectDynamooseError(body) {
+    const errorBody = {};
+
+    // Start with an empty message string.
+    let dynamooseError = '';
+
+    // If the error body contains an array of errors, concatenate their messages.
+    if (Array.isArray(body.errors)) {
+        dynamooseError += body.errors.reduce((acc, err) => {
+            return acc + ' ' + (err.message || '');
+        }, '');
+    }
+
+    // If there's a top-level message, add it.
+    if (body.message) {
+        dynamooseError += ' ' + body.message;
+    }
+
+    // If there is any additional detail provided, append it.
+    if (body.detail) {
+        dynamooseError += ' ' + body.detail;
+    }
+
+    // Trim the message to remove extra spaces.
+    errorBody.message = dynamooseError.trim();
+
     return errorBody;
 }

package/src/requestResonse/requestResponse.test.js

@@ -95,7 +95,7 @@ describe('requestResponse', () => {
             };
             const res = getCurrentUser(event);
             expect(res).toEqual({
-                username: 'LOCAL TEST USER',
+                username: 'localtestuser@gexample.com',
                 id: 0
             });
         });
@@ -139,6 +139,15 @@ describe('requestResponse', () => {
         });
     });
     describe('parseBody', () => {
+        // fit('parse form data', () => {
+        // parse body does not parse form data
+        //     const event = {
+        //         body: 'threeDSMethodData=eyJ0aHJlZURTTWV0aG9kTm90aWZpY2F0aW9uVVJMIjoiaHR0cHM6Ly93ZWJob29rLnNpdGUvNGYyNjEyZGMtOTA0Ny00NDRmLWIwOTUtYzcwYjg0NDliYjZlIiwidGhyZWVEU1NlcnZlclRyYW5zSUQiOiIxOTI2NThkMS1jNjA0LTQwYjQtOWFiMC0zMzJiNjcyMWI0ZmMifQ%3D%3D'
+        //     };
+        //
+        //     const res = parseBody(event);
+        //     expect(res).toEqual({ foo: 'bar' });
+        // });
         it('parse a json string', () => {
             const event = {
                 body: '{"foo":"bar"}'

package/webpack.config.js

@@ -46,5 +46,5 @@ module.exports = {
         path: path.join(__dirname, './bin'),
         filename: '[name].js'
     },
-    devtool: isProd ? 'nosources-source-map' : 'inline-source-map'
+    devtool: isProd ? 'source-map' : 'source-map'
 };