@stanlemon/server 0.2.61 → 0.3.1

package/README.md

@@ -1,5 +1,7 @@
 # Express App Server
 
+[![npm version](https://badge.fury.io/js/%40stanlemon%2Fserver.svg)](https://badge.fury.io/js/%40stanlemon%2Fserver)
+
 This is a base express app server that is wired up with sensible defaults, like compression, json support and serving the `dist` folder statically.
 
 It also include a function called `asyncJsonHandler` which is a wrapper for most express requests. It standardizes input/output as JSON, accepting camel case properties and snake casing them for output. It also covers a bunch of standard error behaviors.

package/app.js

@@ -35,3 +35,5 @@ app.post(
   // You can also use async/await
   handler(async ({ name }) => await Promise.resolve({ hello: name || "Stan" }))
 );
+
+app.catch404s();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stanlemon/server",
-  "version": "0.2.61",
+  "version": "0.3.1",
   "description": "A basic express web server setup.",
   "author": "Stan Lemon <stanlemon@users.noreply.github.com>",
   "license": "MIT",
@@ -13,20 +13,22 @@
   "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:fix": "eslint --fix --ext js,jsx,ts,tsx ./",
     "test": "jest --detectOpenHandles",
     "test:coverage": "jest --detectOpenHandles --coverage",
     "test:watch": "jest --detectOpenHandles --watch"
   },
   "dependencies": {
     "@stanlemon/webdev": "*",
+    "body-parser": "^1.20.2",
     "compression": "^1.7.4",
+    "cookie-parser": "^1.4.6",
     "dotenv": "16.3.1",
     "express": "^4.18.2",
     "express-rate-limit": "^7.1.5",
     "helmet": "^7.1.0",
     "http-proxy-middleware": "^2.0.6",
-    "joi": "^17.11.0",
+    "joi": "^17.12.0",
     "lodash": "^4.17.21",
     "lodash-es": "^4.17.21",
     "morgan": "^1.10.0"
@@ -34,6 +36,6 @@
   "devDependencies": {
     "@stanlemon/eslint-config": "*",
     "@types/lodash": "^4.14.202",
-    "nodemon": "^3.0.2"
+    "nodemon": "^3.0.3"
   }
 }

package/src/asyncJsonHandler.js

@@ -4,12 +4,20 @@ import { formatOutput } from "./index.js";
 
 export default asyncJsonHandler;
 
+/**
+ * Handler for JSON responses.
+ * This method ensures data formatting using {formatInput} and {formatOutput}.
+ * Callbacks that are wrapped by this handler receive an additional argument {input} which contains the formatted input data.
+ * If the request is a GET, the {input} is the request.params object.
+ * If the request is a POST or PUT, the {input} is the request.body object.
+ * @param {function} Express route handler function
+ */
 export function asyncJsonHandler(fn) {
-  return async (req, res /*, next */) => {
-    const input = buildInput(req);
-
+  return async (req, res, next) => {
     try {
-      const output = await fn(input);
+      const input = buildInput(req);
+
+      const output = await fn(input, req, res, next);
 
       // If a value is returned we'll assume that we need to render it as JSON
       if (output !== undefined) {
@@ -50,23 +58,12 @@ 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 formatInput(req.body);
+  } else if (req.method === "GET" || req.method === "DELETE") {
+    const params = isPlainObject(req.params) ? req.params : {};
+    return formatInput(params);
   }
-
-  return params;
 }
 
 function formatError(ex) {

package/src/createAppServer.js

@@ -1,26 +1,52 @@
 import dotenv from "dotenv";
-import express from "express";
+import express, { Router } from "express";
+import cookieParser from "cookie-parser";
 import compression from "compression";
 import helmet from "helmet";
 import morgan from "morgan";
 import rateLimit from "express-rate-limit";
 import { createProxyMiddleware } from "http-proxy-middleware";
+import path from "path";
 
 dotenv.config();
 
+const NODE_ENV = process.env.NODE_ENV ?? "development";
+
 export const DEFAULTS = { port: 3000, webpack: false, start: true };
 
+/**
+ * @typedef {object} AppAddons
+ * @property {function} start Start the server
+ * @property {function} catch404s Enable the 404 handler, only call this after you have added all of your routers.
+ *
+ * @typedef {import("express").Express & AppAddons} AppServer
+ */
+
+/**
+ * Create an express application server.
+ * @param {object} options
+ * @param {number} options.port Port to listen on
+ * @param {boolean} options.webpack Whether or not to create a proxy for webpack
+ * @param {boolean} options.start Whether or not to start the server
+ * @returns {AppServer} Pre-configured express app server with extra helper methods
+ */
+// eslint-disable-next-line max-lines-per-function
 export default function createAppServer(options) {
   const { port, webpack, start } = { ...DEFAULTS, ...options };
 
+  const useWebpack =
+    webpack !== false && NODE_ENV !== "production" && NODE_ENV !== "test";
+
   const app = express();
-  app.use(express.json({ strict: false }));
+  app.use(express.urlencoded({ extended: true }));
+  app.use(express.json());
+  app.use(cookieParser());
 
-  if (process.env.NODE_ENV !== "test") {
+  if (NODE_ENV !== "test") {
     app.use(morgan("combined"));
   }
 
-  if (process.env.NODE_ENV === "production") {
+  if (NODE_ENV === "production") {
     const limiter = rateLimit({
       windowMs: 5 * 60 * 1000, // 5 minutes
       max: 100, // Limit each IP to 100 requests per `window` (here, per 15 minutes)
@@ -33,13 +59,18 @@ export default function createAppServer(options) {
     app.use(helmet());
   }
 
-  if (
-    webpack !== false &&
-    process.env.NODE_ENV !== "production" &&
-    process.env.NODE_ENV !== "test"
-  ) {
+  app.get("/ping", (req, res) => {
+    res.json({
+      success: true,
+    });
+  });
+
+  if (useWebpack) {
+    // eslint-disable-next-line no-console
+    console.info("Proxying webpack dev server");
+
     app.get(
-      "/*.js",
+      "/static/*",
       createProxyMiddleware({
         target: webpack,
         changeOrigin: true,
@@ -66,25 +97,48 @@ export default function createAppServer(options) {
     app.use(express.static("./dist"));
   }
 
-  app.get("/health", (req, res) => {
-    res.json({
-      success: true,
-    });
-  });
-
-  // If we're set to start. Btw we never start in test.
-  if (start && process.env.NODE_ENV !== "test") {
+  app.start = () => {
     const server = app.listen(port);
 
-    /* eslint-disable no-console */
-    console.log("Starting in %s mode", process.env.NODE_ENV);
-    console.log(
+    // eslint-disable-next-line no-console
+    console.info("Starting in %s mode on port %s", NODE_ENV, port);
+    // eslint-disable-next-line no-console
+    console.info(
       "Listening at http://%s:%s",
       server.address().address === "::"
         ? "localhost"
         : server.address().address,
       server.address().port
     );
+  };
+
+  app.spa = () => {
+    if (useWebpack) {
+      app.get(
+        "*",
+        createProxyMiddleware({
+          target: webpack,
+          changeOrigin: true,
+        })
+      );
+    } else {
+      app.get(`*`, function (req, res, next) {
+        res.sendFile(path.resolve("./", "dist", "index.html"));
+      });
+    }
+  };
+
+  app.catch404s = (path = "/*") => {
+    const router = Router();
+    router.use((req, res, next) => {
+      res.status(404).json({ error: "Not Found" });
+    });
+    app.use(path, router);
+  };
+
+  // If we're set to start. Btw we never start in test.
+  if (start && NODE_ENV !== "test") {
+    app.start();
   }
 
   return app;

package/src/schemaHandler.js

@@ -1,5 +1,12 @@
+import Joi from "joi";
 import asyncJsonHandler from "./asyncJsonHandler.js";
 
+/**
+ *
+ * @param {Joi.Schema} schema
+ * @param {*} fn
+ * @returns
+ */
 export default function schemaHandler(schema, fn) {
   return async (req, res, next) => {
     // Validate the input schema
@@ -27,18 +34,19 @@ export default function schemaHandler(schema, fn) {
         },
       });
 
-      // eslint-disable-next-line require-atomic-updates
       req.body = value;
 
       // Wrap all of these in our async handler
       await asyncJsonHandler(fn)(req, res, next);
     } catch (error) {
-      res.status(400).json({
-        errors: Object.assign.apply(
-          null,
-          error.details.map((d) => ({ [d.path]: d.message }))
-        ),
-      });
+      if (error instanceof Joi.ValidationError) {
+        res.status(400).json({
+          errors: Object.assign.apply(
+            null,
+            error.details.map((d) => ({ [d.path]: d.message }))
+          ),
+        });
+      }
     }
   };
 }

package/test.http

@@ -0,0 +1,22 @@
+GET http://localhost:3003/hello
+
+###
+
+GET http://localhost:3003/hello/Stan
+
+###
+
+GET http://localhost:3003/hello/Sara
+
+###
+
+POST http://localhost:3003/hello HTTP/1.1
+Content-Type: application/json
+
+{
+  "name": "Lucy"
+}
+
+###
+
+GET http://localhost:3003/doesNotExist