@stanlemon/server 0.2.0 → 0.2.3

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@stanlemon/server",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "A basic express web server setup.",
   "author": "Stan Lemon <stanlemon@users.noreply.github.com>",
   "license": "MIT",
   "engines": {
-    "node": ">=17.0"
+    "node": ">=16.13.0"
   },
   "type": "module",
   "main": "./src/index.js",
@@ -13,21 +13,23 @@
   "scripts": {
     "start": "NODE_ENV=development nodemon ./app.js",
     "lint": "eslint --ext js,jsx,ts,tsx ./",
-    "lint:format": "eslint --fix --ext js,jsx,ts,tsx ./"
+    "lint:format": "eslint --fix --ext js,jsx,ts,tsx ./",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --watch"
   },
   "dependencies": {
     "compression": "^1.7.4",
     "dotenv": "16.0.0",
-    "express": "^4.17.2",
-    "express-rate-limit": "^6.2.1",
+    "express": "^4.18.1",
+    "express-rate-limit": "^6.4.0",
     "helmet": "^5.0.2",
-    "http-proxy-middleware": "^2.0.3",
+    "http-proxy-middleware": "^2.0.6",
     "joi": "^17.6.0",
     "lodash-es": "^4.17.21",
     "morgan": "^1.10.0"
   },
   "devDependencies": {
-    "@stanlemon/eslint-config": "0.1.4",
-    "nodemon": "^2.0.15"
+    "@stanlemon/eslint-config": "*",
+    "nodemon": "^2.0.16"
   }
-}
+}

package/src/asyncJsonHandler.js

@@ -1,3 +1,4 @@
+import { isPlainObject } from "lodash-es";
 import { formatInput } from "./index.js";
 import { formatOutput } from "./index.js";
 
@@ -5,16 +6,7 @@ export default asyncJsonHandler;
 
 export function asyncJsonHandler(fn) {
   return async (req, res /*, next */) => {
-    const input = {
-      // For POST & PUT requests we'll use the body
-      // For everything else, it's query string parameters
-      ...(req.method === "POST" || req.method === "PUT"
-        ? formatInput(req.body)
-        : req.query || {}),
-      // Always make sure the request parameters override everything else
-      // eg. a param for 'id' is not overridden by a query string 'id' or 'req.body.id'
-      ...req.params,
-    };
+    const input = buildInput(req);
 
     try {
       const output = await fn(input);
@@ -60,6 +52,26 @@ export function asyncJsonHandler(fn) {
   };
 }
 
+function buildInput(req) {
+  const query = isPlainObject(req.query) ? req.query : {};
+  const params = isPlainObject(req.params) ? req.params : {};
+
+  if (req.method === "POST" || req.method === "PUT") {
+    const body = formatInput(req.body);
+
+    // This is a weird payload, don't try any of our append magic
+    if (!isPlainObject(body)) {
+      return body;
+    }
+
+    // Always make sure the request parameters override everything else
+    // eg. a param for 'id' is not overridden by a query string 'id' or 'req.body.id'
+    return { ...body, ...query, ...params };
+  }
+
+  return params;
+}
+
 function formatError(ex) {
   return ex.message + (ex.details ? ": " + ex.details : "");
 }

package/src/convertCase.test.js

@@ -0,0 +1,30 @@
+import convertCase from "./convertCase";
+import { snakeCase } from "lodash-es";
+
+describe("convertCase()", () => {
+  const convert = (obj) => convertCase(obj, convert, snakeCase);
+
+  it("converts object keys", async () => {
+    expect(convert({ fooBar: true }, convertCase, snakeCase)).toEqual({
+      foo_bar: true,
+    });
+  });
+
+  it("converts an array of object keys", async () => {
+    expect(convert([{ fooBar: true }], convertCase, snakeCase)).toEqual([
+      {
+        foo_bar: true,
+      },
+    ]);
+  });
+
+  it("does not convert strings", async () => {
+    expect(convert("hereIsAString", convertCase, snakeCase)).toEqual(
+      "hereIsAString"
+    );
+  });
+
+  it("does not convert anything else", async () => {
+    expect(convert(true, convertCase, snakeCase)).toEqual(true);
+  });
+});

package/src/createAppServer.js

@@ -14,7 +14,7 @@ export default function createAppServer(options) {
   const { port, webpack, start } = { ...DEFAULTS, ...options };
 
   const app = express();
-  app.use(express.json());
+  app.use(express.json({ strict: false }));
 
   if (process.env.NODE_ENV !== "test") {
     app.use(morgan("combined"));

package/src/formatInput.js

@@ -1,6 +1,9 @@
-import { snakeCase } from "lodash-es";
+import { isArray, snakeCase } from "lodash-es";
 import convertCase from "./convertCase.js";
 
 export default function formatInput(obj) {
+  if (isArray(obj)) {
+    return obj.map((v) => formatInput(v));
+  }
   return convertCase(obj, formatInput, snakeCase);
 }

package/src/formatInput.test.js

@@ -0,0 +1,31 @@
+import formatInput from "./formatInput";
+
+describe("formatInput()", () => {
+  it("formats object keys", async () => {
+    expect(formatInput({ fooBar: true })).toEqual({
+      foo_bar: true,
+    });
+  });
+
+  it("formats an array of object keys", async () => {
+    expect(formatInput([{ fooBar: true }])).toEqual([
+      {
+        foo_bar: true,
+      },
+    ]);
+  });
+
+  it("does not formats strings", async () => {
+    expect(formatInput("hereIsAString")).toEqual("hereIsAString");
+  });
+
+  it("does not formats anything else", async () => {
+    expect(formatInput(true)).toEqual(true);
+  });
+
+  it("does not change already formatted object keys", async () => {
+    expect(formatInput({ foo_bar: true })).toEqual({
+      foo_bar: true,
+    });
+  });
+});

package/src/formatOutput.js

@@ -1,9 +1,16 @@
-import { camelCase, isObject, isArray, isDate, isEmpty, omit } from "lodash-es";
+import {
+  camelCase,
+  isPlainObject,
+  isArray,
+  isDate,
+  isEmpty,
+  omit,
+} from "lodash-es";
 import convertCase from "./convertCase.js";
 
 export default function formatOutput(o, omittedFields = []) {
   const obj =
-    isObject(o) && !isEmpty(omittedFields) ? omit(o, omittedFields) : o;
+    isPlainObject(o) && !isEmpty(omittedFields) ? omit(o, omittedFields) : o;
   if (isDate(obj)) {
     return obj.toISOString();
   }

package/src/formatOutput.test.js

@@ -0,0 +1,31 @@
+import formatOutput from "./formatOutput";
+
+describe("formatOutput()", () => {
+  it("formats object keys", async () => {
+    expect(formatOutput({ foo_bar: true })).toEqual({
+      fooBar: true,
+    });
+  });
+
+  it("formats an array of object keys", async () => {
+    expect(formatOutput([{ foo_bar: true }])).toEqual([
+      {
+        fooBar: true,
+      },
+    ]);
+  });
+
+  it("does not formats strings", async () => {
+    expect(formatOutput("hereIsAString")).toEqual("hereIsAString");
+  });
+
+  it("does not formats anything else", async () => {
+    expect(formatOutput(true)).toEqual(true);
+  });
+
+  it("does not change already formatted object keys", async () => {
+    expect(formatOutput({ fooBar: true })).toEqual({
+      fooBar: true,
+    });
+  });
+});