npm - piper-utils - Versions diffs - 1.0.0 - Mend

piper-utils 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (38) hide show

package/.babelrc +12 -0
package/README.md +119 -0
package/bin/main.js +1003 -0
package/bin/main.js.LICENSE.txt +151 -0
package/bin/main.js.map +1 -0
package/bitbucket-pipelines.yml +14 -0
package/jasmine.json +7 -0
package/package.json +62 -0
package/src/database/dbSetUp/migrations.js +45 -0
package/src/database/dbUtils/queryStringUtils/accessRightsUtils.js +149 -0
package/src/database/dbUtils/queryStringUtils/accessRightsUtils.test.js +177 -0
package/src/database/dbUtils/queryStringUtils/createFilters.js +92 -0
package/src/database/dbUtils/queryStringUtils/createFilters.test.js +37 -0
package/src/database/dbUtils/queryStringUtils/createIncludes.js +45 -0
package/src/database/dbUtils/queryStringUtils/createIncludes.test.js +20 -0
package/src/database/dbUtils/queryStringUtils/createSort.js +36 -0
package/src/database/dbUtils/queryStringUtils/createSort.test.js +60 -0
package/src/database/dbUtils/queryStringUtils/defaultFilters.js +108 -0
package/src/database/dbUtils/queryStringUtils/defaultFilters.test.js +50 -0
package/src/database/dbUtils/queryStringUtils/findAll.js +42 -0
package/src/database/dbUtils/queryStringUtils/findAll.test.js +79 -0
package/src/database/dbUtils/queryStringUtils/mocks/mocks.js +127 -0
package/src/dynamo/dynamoUtils.js +16 -0
package/src/eventManager/handleEvents.js +32 -0
package/src/eventManager/handleEvents.test.js +92 -0
package/src/eventManager/handleFile.js +76 -0
package/src/eventManager/handleFile.test.js +352 -0
package/src/eventManager/publishEvents.js +99 -0
package/src/eventManager/publishEvents.test.js +161 -0
package/src/eventManager/watchBucket.js +41 -0
package/src/eventManager/watchBucket.test.js +137 -0
package/src/index.js +40 -0
package/src/requestResonse/errorCodes.js +132 -0
package/src/requestResonse/requestResponse.js +198 -0
package/src/requestResonse/requestResponse.test.js +241 -0
package/src/s3/S3Utils.js/S3Utils.js +20 -0
package/src/sns/SNSUtils.js +18 -0
package/webpack.config.js +50 -0

package/src/requestResonse/requestResponse.test.js ADDED Viewed

@@ -0,0 +1,241 @@
+import {
+    failure, success, successHtml,
+    getCurrentUser, getCurrentUserNameFromCognitoEvent, parseBody, parseEvent, detectSequelizeError
+} from './requestResponse.js';
+describe('requestResponse', () => {
+    describe('success', () => {
+        it('should return 200', () => {
+            const res = success({ foo: 'bar' }, {});
+            expect(res).toEqual({
+                statusCode: 200, headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Credentials': true
+                }, body: '{"foo":"bar"}'
+            });
+        });
+    });
+    describe('success', () => {
+        it('should call dbclose', () => {
+            const options = {
+                dbClose: () => {
+                }
+            };
+            const closeSpy = spyOn(options, 'dbClose');
+            const res = success({ foo: 'bar' }, options);
+            expect(closeSpy).toHaveBeenCalled();
+        });
+    });
+    describe('successHtml', () => {
+        it('should return 200', () => {
+            const res = successHtml('<html>test</html>', {});
+            expect(res).toEqual({
+                statusCode: 200, headers: {
+                    'Content-Type': 'text/html',
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Credentials': true
+                }, body: '<html>test</html>'
+            });
+        });
+        it('should call dbclose', () => {
+            const options = {
+                dbClose: () => {
+                }
+            };
+            const closeSpy = spyOn(options, 'dbClose');
+            const res = successHtml('<html>test</html>', options);
+            expect(closeSpy).toHaveBeenCalled();
+        });
+    });
+    describe('getCurrentUserNameFromCognitoEvent', () => {
+        it('should return username', () => {
+            const event = {
+                request: {
+                    userAttributes: {
+                        'cognito:email_alias': 'kevin@test.com'
+                    }
+                }
+            };
+            const res = getCurrentUserNameFromCognitoEvent(event);
+            expect(res).toEqual('kevin@test.com');
+        });
+        it('should return username', () => {
+            const event = {
+                request: {
+                    userAttributes: {}
+                }
+            };
+            const res = getCurrentUserNameFromCognitoEvent(event);
+            expect(res).toEqual('UNKNOWN USER');
+        });
+    });
+    describe('getCurrentUser', () => {
+        it('should return username', () => {
+            const event = {
+                requestContext: {
+                    authorizer: {
+                        'custom:UID': '1',
+                        'email': 'kevin@test.com'
+                    }
+                }
+            };
+            const res = getCurrentUser(event);
+            expect(res).toEqual({
+                username: 'kevin@test.com',
+                id: 1
+            });
+        });
+        it('should return username', () => {
+            const event = {
+                requestContext: {
+                    authorizer: {}
+                }
+            };
+            const res = getCurrentUser(event);
+            expect(res).toEqual({
+                username: 'LOCAL TEST USER',
+                id: 0
+            });
+        });
+    });
+    describe('failure', () => {
+        it('should return an error', () => {
+            const res = failure({ foo: 'bar' }, {});
+            expect(res).toEqual({
+                statusCode: 500, headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Credentials': true
+                }, body: '{"statusCode":500,"errorCode":"5XX","message":""}'
+            });
+        });
+        it('should look for errors in details return an error', () => {
+            const res = failure({ details: 'bar' }, {});
+            expect(res).toEqual({
+                statusCode: 400, headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Credentials': true
+                }, body: '{"statusCode":400,"errorCode":"4000","message":"INTERNAL UTIL ERROR"}'
+            });
+        });
+        it('should deal with error code on body, but no details', () => {
+            const res = failure({ errorCode: 333 }, {});
+            expect(res).toEqual({
+                statusCode: 500, headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Credentials': true
+                }, body: '{"statusCode":500,"errorCode":"5XX","message":""}'
+            });
+        });
+        it('should no details and no codes', () => {
+            const res = failure({ errorCode: 333, statusCode: 222 }, {});
+            expect(res).toEqual({
+                statusCode: 222, headers: {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Credentials': true
+                }, body: '{"statusCode":222,"errorCode":333,"message":"INTERNAL UTIL ERROR"}'
+            });
+        });
+    });
+    describe('parseBody', () => {
+        it('parse a json string', () => {
+            const event = {
+                body: '{"foo":"bar"}'
+            };
+            const res = parseBody(event);
+            expect(res).toEqual({ foo: 'bar' });
+        });
+        it('should handle no parseable things', () => {
+            const event = {
+                body: 'DRY DUCK'
+            };
+            try {
+                parseBody(event);
+            } catch (e) {
+                expect(e.message).toEqual('INVALID JSON');
+            }
+        });
+    });
+    describe('parseEvent', () => {
+        it('parse a json string', () => {
+            const event = '{"foo":"bar"}';
+            const res = parseEvent(event, () => {
+            });
+            expect(res).toEqual({ foo: 'bar' });
+        });
+        it('should handle non parsable things', () => {
+            const event = {
+                body: 'DRY DUCK'
+            };
+            try {
+                parseEvent(event, () => {
+                });
+            } catch (e) {
+                expect(e.message).toEqual('INVALID JSON');
+            }
+        });
+        it('should handle no parsable things', () => {
+            const event = 'DRY DUCK';
+            try {
+                parseEvent(event, () => {
+                });
+            } catch (e) {
+                expect(e.message).toEqual('INVALID JSON');
+            }
+        });
+        it('should handle no call back', () => {
+            const event = 'DRY DUCK';
+            try {
+                parseEvent(event);
+            } catch (e) {
+                expect(e.message).toEqual('INVALID JSON');
+            }
+        });
+        it('should handle event already an object', () => {
+            const event = { good: 'boy' };
+            const res = parseEvent(event);
+            expect(res).toEqual({ good: 'boy' });
+        });
+        it('should handle parsable stuff', () => {
+            const event = '{"good":"boy"}';
+            const res = parseEvent(event);
+            expect(res).toEqual({ good: 'boy' });
+        });
+        it('should handle undefined', () => {
+            const event = undefined;
+            const res = parseEvent(event);
+            expect(res).toEqual({});
+        });
+    });
+    describe('detectSequelizeError', () => {
+        it('should find sequelize errors', () => {
+            const body = {
+                errors: [
+                    {
+                        message: 'I'
+                    }
+                ],
+                parent: 'eggs',
+                original: {
+                    detail: 'like'
+                },
+                TypeError: 'green'
+            };
+            const res = detectSequelizeError(body);
+            expect(res).toEqual({ message: 'Ilikegreeneggs' });
+        });
+    });
+});

package/src/s3/S3Utils.js/S3Utils.js ADDED Viewed

@@ -0,0 +1,20 @@
+import { S3 } from '@aws-sdk/client-s3';
+export function s3Utils(action, params) {
+    const s3 = new S3();
+    return s3[action](params);
+}
+const S3Util = {
+    getObject: (params) => getS3(params),
+    deleteObject: (params) => s3Utils('deleteObject', params),
+    putObject: (params) => s3Utils('putObject', params),
+    listObjectsV2: (params) => s3Utils('listObjectsV2', params)
+};
+export default S3Util;
+async function getS3(params) {
+    const s3 = new S3();
+    const response = await s3.getObject(params);
+    return response.Body.transformToString('utf-8');
+}

package/src/sns/SNSUtils.js ADDED Viewed

@@ -0,0 +1,18 @@
+import { SNS } from '@aws-sdk/client-sns';
+const SNSUtil = {
+    publish: (params) => publish(params),
+    createTopic: (params) => createTopic(params)
+};
+async function publish(params) {
+    const sns = new SNS();
+    return await sns.publish(params);
+}
+async function createTopic(params) {
+    const sns = new SNS();
+    return await sns.createTopic(params);
+}
+export default SNSUtil;

package/webpack.config.js ADDED Viewed

@@ -0,0 +1,50 @@
+const path = require('path');
+const nodeExternals = require('webpack-node-externals');
+const TerserPlugin = require("terser-webpack-plugin");
+const isProd = process.env.BUILD_ENV === 'production';
+console.log('----------->BUILD TYPE:', isProd);
+module.exports = {
+    entry: './src/index.js',
+    target: 'node',
+    mode: isProd ? 'production' : 'development',
+    externals: [nodeExternals()],
+    optimization: {
+        minimize: isProd,
+        minimizer: [
+            new TerserPlugin({
+                extractComments: false,
+                terserOptions: {
+                    keep_fnames: true,
+                    mangle:false,
+                    format: {
+                        comments: true,
+                    },
+                }
+            })
+        ]
+    },
+    module: {
+        rules: [
+            {
+                test: /\.js$/,
+                use: [
+                    {
+                        loader: 'babel-loader',
+                        options: {
+                            retainLines: true
+                        }
+                    }
+                ],
+                include: __dirname,
+                exclude: /node_modules/
+            }
+        ]
+    },
+    output: {
+        libraryTarget: 'commonjs',
+        path: path.join(__dirname, './bin'),
+        filename: '[name].js'
+    },
+    devtool: isProd ? 'nosources-source-map' : 'inline-source-map'
+};