Linting

.gitignore

@@ -59,3 +59,9 @@ typings/
 
 # next.js build output
 .next
+
+# vscode folders
+.vscode/
+
+# dstore
+.DS_Store

package.json

@@ -2,7 +2,7 @@
   "private": true,
   "scripts": {
     "install": "lerna bootstrap",
-    "test:lint": "eslint .",        
+    "test:lint": "eslint .",
     "test": "lerna run --concurrency 2 test -- -- --config=../../jest.config.js",
     "diff": "lerna diff",
     "new-version": "lerna version --conventional-commits --yes"

packages/lambda-powertools-middleware-obfuscater/__tests__/obfuscate.js

@@ -1,52 +1,52 @@
 const obfuscater = require('../obfuscate')
 
 const invokeObfuscater = (event, obfuscationFilters = []) => {
-  return obfuscater(event, obfuscationFilters);
+  return obfuscater(event, obfuscationFilters)
 }
 
-test ('should obfuscate events using the filter', () => { 
+test('should obfuscate events using the filter', () => {
   const event = invokeObfuscater({ test: 'wat' }, ['test'])
-  expect(event.test).toEqual('******');
+  expect(event.test).toEqual('******')
 })
 
-test ('should obfuscate events with arrays using the filter', () => { 
-  const event = invokeObfuscater({ test: [ { foo: 'wat' }, {foo: 'bar'} ] }, ['test.*.foo'])
-  expect(event.test[0].foo).toEqual('******');
-  expect(event.test[1].foo).toEqual('******');
+test('should obfuscate events with arrays using the filter', () => {
+  const event = invokeObfuscater({ test: [ { foo: 'wat' }, { foo: 'bar' } ] }, ['test.*.foo'])
+  expect(event.test[0].foo).toEqual('******')
+  expect(event.test[1].foo).toEqual('******')
 })
 
-test ('should obfuscate events with multipleArrays arrays using the filter', () => { 
-  const event = invokeObfuscater({ test: [ { foo: { bar: [ {baz: 'heyo' } ] } }, { foo: { bar: [ {baz: 'hey' } ] } } ] }, ["test.*.foo.bar.*.baz"]);
-  expect(event.test[0].foo.bar[0].baz).toEqual('******');
+test('should obfuscate events with multipleArrays arrays using the filter', () => {
+  const event = invokeObfuscater({ test: [ { foo: { bar: [ { baz: 'heyo' } ] } }, { foo: { bar: [ { baz: 'hey' } ] } } ] }, ['test.*.foo.bar.*.baz'])
+  expect(event.test[0].foo.bar[0].baz).toEqual('******')
 })
 
-test ('should obfuscate every field on an object using the filter', () => {
-  const event = invokeObfuscater({ test: [ { foo: { bar: [ {baz: { bloop: { blah: "Please Obfuscate Me"} } } ] } }, { foo: { bar: [ {baz: 'hey' } ] } } ] }, ["test.*.foo"]);
-  expect(event.test[0].foo.bar[0].baz.bloop.blah).toEqual('******');
+test('should obfuscate every field on an object using the filter', () => {
+  const event = invokeObfuscater({ test: [ { foo: { bar: [ { baz: { bloop: { blah: 'Please Obfuscate Me' } } } ] } }, { foo: { bar: [ { baz: 'hey' } ] } } ] }, ['test.*.foo'])
+  expect(event.test[0].foo.bar[0].baz.bloop.blah).toEqual('******')
 })
 
-test ('should not filter fields that dont exist', () => {
-  const rawEvent = { test: { foo: { bar: { buzz: "Nope" }}}};
-  const event = invokeObfuscater({ test: { foo: { bar: { buzz: "Nope" }}}}, ["test.foo.bar.boop"])
-  expect(event).toEqual(rawEvent);
+test('should not filter fields that dont exist', () => {
+  const rawEvent = { test: { foo: { bar: { buzz: 'Nope' } } } }
+  const event = invokeObfuscater({ test: { foo: { bar: { buzz: 'Nope' } } } }, ['test.foo.bar.boop'])
+  expect(event).toEqual(rawEvent)
 })
 
-test ('should not filter fields that dont exist with arrays', () => {
-  const event = { test: { foo: { bar: [{ buzz: "Nope" }]}}};
-  const obfuscatedEvent = invokeObfuscater({ test: { foo: { bar: [{ buzz: "Nope" }]}}}, ["test.foo.bar.*.blap"]);
+test('should not filter fields that dont exist with arrays', () => {
+  const event = { test: { foo: { bar: [{ buzz: 'Nope' }] } } }
+  const obfuscatedEvent = invokeObfuscater({ test: { foo: { bar: [{ buzz: 'Nope' }] } } }, ['test.foo.bar.*.blap'])
 
-  expect(event).toEqual(obfuscatedEvent);
+  expect(event).toEqual(obfuscatedEvent)
 })
 
-test ('should not filter when nothing passed', () => {
-  const event = { test: { foo: { bar: [{ buzz: "Nope" }]}}};
-  const obfuscatedEvent = invokeObfuscater({ test: { foo: { bar: [{ buzz: "Nope" }]}}}, []);
+test('should not filter when nothing passed', () => {
+  const event = { test: { foo: { bar: [{ buzz: 'Nope' }] } } }
+  const obfuscatedEvent = invokeObfuscater({ test: { foo: { bar: [{ buzz: 'Nope' }] } } }, [])
 
-  expect(event).toEqual(obfuscatedEvent);
+  expect(event).toEqual(obfuscatedEvent)
 })
 
-test ('should not filter when object doesnt exist', () => {
-  const event = { test: { foo: { bar: [{ buzz: "Nope" }]}}};
-  const obfuscatedEvent = invokeObfuscater(event, ["empty"])
-  expect(event).toEqual(obfuscatedEvent);
-})
+test('should not filter when object doesnt exist', () => {
+  const event = { test: { foo: { bar: [{ buzz: 'Nope' }] } } }
+  const obfuscatedEvent = invokeObfuscater(event, ['empty'])
+  expect(event).toEqual(obfuscatedEvent)
+})

packages/lambda-powertools-middleware-obfuscater/index.js

@@ -1,17 +1,17 @@
-const obfuscateFields = require("./obfuscate");
+const obfuscateFields = require('./obfuscate')
 
 // config should be { obfuscationfilters } where obfuscation filters is an array of references
 // To the object to filter.
 module.exports = ({ obfuscationFilters, filterOnAfter = false }) => ({
   after: (handler, next) => {
     if (filterOnAfter) {
-      handler.event = obfuscateFields(handler.event);
+      handler.event = obfuscateFields(handler.event)
     }
 
-    next();
+    next()
   },
   onError: (handler, next) => {
-    handler.event = obfuscateFields(handler.event, obfuscationFilters);
-    next(handler.error);
+    handler.event = obfuscateFields(handler.event, obfuscationFilters)
+    next(handler.error)
   }
 })