piper-utils 1.0.0

package/src/eventManager/watchBucket.test.js

@@ -0,0 +1,137 @@
+import * as watchBucket from './watchBucket.js';
+import * as handleEvents from './handleEvents.js';
+import * as publishEventsFunc from './publishEvents.js';
+import _ from 'lodash';
+
+describe('watchBucket.js', () => {
+    describe('watchBucket', () => {
+        it('should fail missing event', function () {
+            const params = {
+                dynamoConfigTable: 'dynamoConfigTable',
+                dynamoConfigKey: 'dynamoConfigKey',
+                s3Bucket: 's3Bucket',
+                snsTopic: 'snsTopic',
+                createFunc: _.noop
+            };
+
+            expect(() => {
+                watchBucket.watchBucket(params);
+            }).toThrow();
+        });
+
+        it('should fail missing dynamoConfigTable', function () {
+            const event = {};
+            const params = {
+                event,
+                dynamoConfigKey: 'dynamoConfigKey',
+                s3Bucket: 's3Bucket',
+                snsTopic: 'snsTopic',
+                createFunc: _.noop
+            };
+
+            expect(() => {
+                watchBucket.watchBucket(params);
+            }).toThrow();
+        });
+
+        it('should fail missing dynamoConfigKey', function () {
+            const event = {};
+            const params = {
+                event,
+                dynamoConfigTable: 'dynamoConfigTable',
+                s3Bucket: 's3Bucket',
+                snsTopic: 'snsTopic',
+                createFunc: _.noop
+            };
+
+            expect(() => {
+                watchBucket.watchBucket(params);
+            }).toThrow();
+        });
+
+        it('should fail missing s3Bucket', function () {
+            const event = {};
+            const params = {
+                event,
+                dynamoConfigTable: 'dynamoConfigTable',
+                dynamoConfigKey: 'dynamoConfigKey',
+                snsTopic: 'snsTopic',
+                createFunc: _.noop
+            };
+
+            expect(() => {
+                watchBucket.watchBucket(params);
+            }).toThrow();
+        });
+
+        it('should fail missing snsTopic', function () {
+            const event = {};
+            const params = {
+                event,
+                dynamoConfigTable: 'dynamoConfigTable',
+                dynamoConfigKey: 'dynamoConfigKey',
+                s3Bucket: 's3Bucket',
+                createFunc: _.noop
+            };
+
+            expect(() => {
+                watchBucket.watchBucket(params);
+            }).toThrow();
+        });
+
+        it('should fail missing transformer', function () {
+            const event = {};
+            const params = {
+                event,
+                dynamoConfigTable: 'dynamoConfigTable',
+                dynamoConfigKey: 'dynamoConfigKey',
+                s3Bucket: 's3Bucket',
+                snsTopic: 'snsTopic'
+            };
+
+            expect(() => {
+                watchBucket.watchBucket(params);
+            }).toThrow();
+        });
+
+        it('should call publish events if not sns', function () {
+            const event = {};
+            const params = {
+                event,
+                dynamoConfigTable: 'dynamoConfigTable',
+                dynamoConfigKey: 'dynamoConfigKey',
+                s3Bucket: 's3Bucket',
+                snsTopic: 'snsTopic',
+                transformer: _.noop
+            };
+
+            const fromSnsSpy = spyOn(handleEvents, 'handleEvents').and.returnValue(Promise.resolve());
+            const publishEventsSpy = spyOn(publishEventsFunc, 'publishEvents').and.returnValue(Promise.resolve());
+
+            return watchBucket.watchBucket(params).then(() => {
+                expect(fromSnsSpy).not.toHaveBeenCalled();
+                expect(publishEventsSpy).toHaveBeenCalled();
+            });
+        });
+
+        it('should call handleEvents if sns', function () {
+            const event = { Records: [{ EventSource: 'aws:sns' }] };
+            const params = {
+                event,
+                dynamoConfigTable: 'dynamoConfigTable',
+                dynamoConfigKey: 'dynamoConfigKey',
+                s3Bucket: 's3Bucket',
+                snsTopic: 'snsTopic',
+                transformer: _.noop
+            };
+
+            const fromSnsSpy = spyOn(handleEvents, 'handleEvents').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();
+            });
+        });
+    });
+});

package/src/index.js

@@ -0,0 +1,40 @@
+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 { 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 { 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';
+import { successHtml as successHtmlImport } from './requestResonse/requestResponse.js';
+import { getCurrentUserNameFromCognitoEvent as getCurrentUserNameFromCognitoEventImport } from './requestResonse/requestResponse.js';
+import { defaultFilters as defaultFiltersImport } from './database/dbUtils/queryStringUtils/defaultFilters.js';
+import { accessRightsUtils as accessRightsUtilsImport } from './database/dbUtils/queryStringUtils/accessRightsUtils.js';
+import { parseBody as parseBodyImport } from './requestResonse/requestResponse.js';
+import { parseEvent as parseEventImport } from './requestResonse/requestResponse.js';
+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';
+
+export const handleFile = handleFileImport;
+export const watchBucket = watchBucketImport;
+export const publishEvents = publishEventsImport;
+export const createFilters = createFiltersImport;
+export const createSort = createSortImport;
+export const findAll = findAllImport;
+export const checkModule = checkModuleImport;
+export const failure = failureImport;
+export const success = successImport;
+export const runMigrations = runMigrationsImport;
+export const getCurrentUser = getCurrentUserImport;
+export const successHtml = successHtmlImport;
+export const getCurrentUserNameFromCognitoEvent = getCurrentUserNameFromCognitoEventImport;
+export const defaultFilters = defaultFiltersImport;
+export const accessRightsUtils = accessRightsUtilsImport;
+export const parseBody = parseBodyImport;
+export const parseEvent = parseEventImport;
+export const getBusinessesInfo = getBusinessesInfoImport;
+export const userDefaultBid = userDefaultBidImport;
+export const checkWriteAccess = checkWriteAccessImport;

package/src/requestResonse/errorCodes.js

@@ -0,0 +1,132 @@
+export const errorList = {
+    invalidInventoryReleaseRequest: {
+        message: 'NOT ENOUGH INVENTORY TO FULFILL RELEASE',
+        errorCode: '4010',
+        statusCode: 400
+    },
+    alreadyReleased: {
+        message: 'ALREADY RELEASED',
+        errorCode: '4011',
+        statusCode: 400
+    },
+    alreadyReceived: {
+        message: 'RECEIVABLE ALREADY RECEIVED',
+        errorCode: '4012',
+        statusCode: 400
+    },
+    invalidItemsRequest: {
+        message: 'VALID ITEMS MUST BE INCLUDED',
+        errorCode: '4013',
+        statusCode: 400
+    },
+    invalidID: {
+        message: 'ID is invalid',
+        errorCode: '4014',
+        statusCode: 400
+    },
+    invalidReceivable: {
+        message: 'MUST CONTAIN AT LEAST ONE RECEIVABLE',
+        errorCode: '4015',
+        statusCode: 400
+    },
+    invalidRequest: {
+        message: 'INVALID REQUEST DATA',
+        errorCode: '4016',
+        statusCode: 400
+    },
+    invalidAPIKey: {
+        message: 'INVALID REQUEST - API MAY KEY INVALID',
+        errorCode: '4017',
+        statusCode: 400
+    },
+    qbCreationError: {
+        message: 'QUICKBOOKS ERROR - ERROR CREATING OBJECT IN QUICKBOOKS',
+        errorCode: '4018',
+        statusCode: 400
+    },
+    cannotReopen: {
+        message: 'CANNOT REOPEN - THE ORDER HAS ALREADY BEEN OPENED',
+        errorCode: '4018',
+        statusCode: 400
+    },
+    invalidDateFormat: {
+        message: 'INVALID DATE FORMAT',
+        errorCode: '4019',
+        statusCode: 400
+    },
+    invalidStartDate: {
+        message: 'INVALID START DATE',
+        errorCode: '4020',
+        statusCode: 400
+    },
+    invalidEndDate: {
+        message: 'INVALID END DATE',
+        errorCode: '4021',
+        statusCode: 400
+    },
+    invalidOrderStatus: {
+        message: 'UNABLE TO EDIT ORDER ITEMS UNLESS THE ORDER IS IN ESTIMATE STATUS',
+        errorCode: '4022',
+        statusCode: 400
+    },
+    invalidPaymentStatus: {
+        message: 'UNABLE TO UPDATE PAYMENT STATUS PAYMENT MUST BE OPEN',
+        errorCode: '4023',
+        statusCode: 400
+    },
+    invalidReleaseStatus: {
+        message: 'UNABLE TO UPDATE RELEASE, STATUS RELEASE MUST BE OPEN',
+        errorCode: '4024',
+        statusCode: 400
+    },
+    invalidReceivableStatus: {
+        message: 'UNABLE TO UPDATE RECEIVABLE, STATUS RECEIVABLE MUST BE OPEN',
+        errorCode: '40025',
+        statusCode: 400
+    },
+    invalidJson:{
+        message: 'INVALID JSON',
+        errorCode: '4005',
+        statusCode: 400
+    },
+    invalidFilter:{
+        message: 'INVALID FILTER',
+        errorCode: '4026',
+        statusCode: 400
+    },
+    invalidUserNameUpdate:{
+        message: 'UNABLE TO UPDATE USERNAME',
+        errorCode: '4027',
+        statusCode: 400
+    },
+    imageSizeLimit:{
+        message: 'IMAGE SIZE LIMIT 100KB EXCEEDED',
+        errorCode: '4028',
+        statusCode: 400
+    },
+    unauthorized:{
+        message: 'UNAUTHORIZED',
+        errorCode: '4111',
+        statusCode: 401
+    },
+    notFound:{
+        message: 'ITEM NOT FOUND',
+        errorCode: '4004',
+        statusCode: 404
+    },
+    emailRequired:{
+        message: 'NO EMAIL PROVIDED, CHECK CUSTOMER EMAIL',
+        errorCode: '4004',
+        statusCode: 404
+    },
+    mobilePhoneRequired:{
+        message: 'NO MOBILE PHONE PROVIDED, CHECK CUSTOMER CONTACTS',
+        errorCode: '4004',
+        statusCode: 404
+    },
+    invalidCadenceType: {
+        message: 'INVALID CADENCE TYPE',
+        errorCode: '5001',
+        statusCode: 500
+    },
+};

package/src/requestResonse/requestResponse.js

@@ -0,0 +1,198 @@
+import _ from 'lodash';
+import { errorList } from './errorCodes.js';
+
+/**
+ * @param {Object} body
+ * @param {{}} options
+ */
+export function success(body, options) {
+    const dbClose = _.get(options, 'dbClose', _.noop);
+    dbClose();
+
+    return buildResponse(200, body);
+}
+
+/**
+ * @param {string} html
+ * @param {{dbClose:function|undefined}} options
+ */
+export function successHtml(html, options) {
+    const dbClose = _.get(options, 'dbClose', _.noop);
+
+    dbClose();
+    return {
+        statusCode: 200,
+        headers: {
+            'Content-Type': 'text/html',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Credentials': true
+        },
+        body: html
+    };
+}
+
+/**
+ * @param {string} event
+ * @returns string
+ */
+export function getCurrentUserNameFromCognitoEvent(event) {
+    const attributes = _.get(event, 'request.userAttributes');
+
+    return attributes['cognito:email_alias'] || 'UNKNOWN USER';
+}
+
+/**
+ * Get the user information from the event object
+ *
+ * @param event {Object} an event object
+ * @returns {{username: string, id: number}}
+ */
+export function getCurrentUser(event) {
+    let jsonToParse = _.get(event, 'requestContext.authorizer.claims.custom:UID') ||
+        _.get(event, 'requestContext.authorizer.custom:UID') ||
+        '0';
+
+    const id = JSON.parse(jsonToParse);
+
+    const username = _.get(event, 'requestContext.authorizer.claims.email') || _.get(event, 'requestContext.authorizer.email') || 'LOCAL TEST USER';
+
+    return {
+        username,
+        id
+    };
+}
+
+/**
+ * Create a failure response
+ *
+ * @param body {Object} an event object
+ * @param options {Object} an options object
+ * @returns {{statusCode:number, headers:object, body:string}} a response object
+ */
+export function failure(body = {}, options) {
+    const dbClose = _.get(options, 'dbClose', _.noop);
+    dbClose();
+    let cleanedErrorBody;
+
+    if (process.env.UTIL_LOG === 'LOG_ALL') {
+        console.error('------->UTIL ERROR:', body);
+    }
+
+    const NORMAL_ERROR = { statusCode: 500, errorCode: '5XX', message: 'INTERNAL UTIL ERROR' };
+    cleanedErrorBody = body;
+    if (!_.isUndefined(body.details)) {
+        cleanedErrorBody = detectJoyError(body);
+    } 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'))
+    }
+
+    const newBody = _.merge(NORMAL_ERROR, cleanedErrorBody);
+
+    return buildResponse(newBody.statusCode, newBody);
+}
+
+/**
+ * Create a failure response object
+ *
+ * @param statusCode {Number} a status code
+ * @param body {Object} an event object
+ * @returns {{statusCode:number, headers:object, body:string}} a response object
+ */
+function buildResponse(statusCode, body) {
+    return {
+        statusCode: statusCode,
+        headers: {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Credentials': true
+        },
+        body: JSON.stringify(body)
+    };
+}
+
+/**
+ * parse the body of the event object
+ *
+ * @param requestEvent {{body:string}} an event object
+ * @returns event {*} the json object of the body
+ */
+export function parseBody(requestEvent) {
+
+    let eventBody = {};
+    if (_.isString(requestEvent.body)) {
+        try {
+            eventBody = JSON.parse(requestEvent.body);
+        } catch (e) {
+            // Invalid JSON
+            eventBody = null;
+
+            throw errorList.invalidJson;
+        }
+    } else if (_.isObject(requestEvent.body)) {
+        eventBody = requestEvent.body;
+    }
+
+    return eventBody;
+}
+
+/**
+ * parse the body of the event object
+ *
+ * @param requestEvent {string|object} an event object
+ * @param [callback] {function} undefined a call back function
+ * @returns event {*} the json object of the body
+ */
+export function parseEvent(requestEvent, callback) {
+    let event = {};
+    if (_.isString(requestEvent)) {
+        try {
+            event = JSON.parse(requestEvent);
+        } catch (e) {
+            // Invalid JSON
+            event = null;
+
+            if (callback) {
+                callback(Error(e));
+            }
+        }
+    } else if (_.isObject(requestEvent)) {
+        event = requestEvent;
+    }
+
+    return event;
+}
+
+/**
+ * parse the body of the event object
+ * look for sequelize errors and return a message
+ * ERRORS should not be caught here this is a fallback for unknown database errors
+ *
+ * @param body {object} part of a body response
+ * @returns error message object {message:string}
+ */
+export function detectSequelizeError(body) {
+    const errorBody = {};
+
+    let sequelizeError = _.get(body, 'errors', []).reduce((acc, err) => {
+        acc = acc + ' ' + _.get(err, 'message');
+        return acc;
+    }, '');
+    const parentError = _.get(body, 'parent', '');
+
+    sequelizeError = sequelizeError + _.get(body, 'original.detail', '') + _.get(body, 'TypeError', '') + parentError;
+    errorBody.message = sequelizeError.trim();
+    return errorBody;
+}
+
+export function detectJoyError(body) {
+    const errorBody = {};
+    const joyError = _.get(body, 'details[0]', {});
+    console.error('USER VALIDATION ERROR:', body);
+
+    errorBody.message = joyError.message;
+    errorBody.statusCode = 400;
+    errorBody.errorCode = '4000';
+    return errorBody;
+}