@stanlemon/server 0.1.0

package/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "@stanlemon"
+  ]
+}

package/README.md

@@ -0,0 +1,49 @@
+# Express App Server
+
+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.
+
+When `NODE_ENV=development` the server will also proxy requests to webpack.
+
+This library goes well with [@stanlemon/webdev](../webdev/README.md).
+
+```javascript
+import {
+  createAppServer,
+  asyncJsonHandler as handler,
+  NotFoundException,
+} from "@stanlemon/server";
+
+const app = createAppServer({ port: 3003 });
+
+// curl http://localhost:3003/hello?name=Stanley
+app.get(
+  "/hello",
+  handler(({ name }) => ({ hello: name || "Stan" }))
+);
+
+// curl http://localhost:3003/hello/Stan
+app.get(
+  "/hello/Stan",
+  // Promises are handled correctly
+  handler(() => {
+    // This is the same as just hitting /hello, so we'll demonstrate the exception handling
+    throw new NotFoundException();
+  })
+);
+
+// curl http://localhost:3003/hello/Stanley
+app.get(
+  "/hello/:name",
+  // Promises are handled correctly
+  handler(({ name }) => Promise.resolve({ hello: name || "Stan" }))
+);
+
+// curl -X POST http://localhost:3003/hello -H 'Content-Type: application/json' -d '{"name": "Stanley"}'
+app.post(
+  "/hello",
+  // You can also use async/await
+  handler(async ({ name }) => await Promise.resolve({ hello: name || "Stan" }))
+);
+```

package/app.js

@@ -0,0 +1,37 @@
+import {
+  createAppServer,
+  asyncJsonHandler as handler,
+  NotFoundException,
+} from "./src/index.js";
+
+const app = createAppServer({ port: 3003 });
+
+// curl http://localhost:3003/hello?name=Stanley
+app.get(
+  "/hello",
+  handler(({ name }) => ({ hello: name || "Stan" }))
+);
+
+// curl http://localhost:3003/hello/Stan
+app.get(
+  "/hello/Stan",
+  // Promises are handled correctly
+  handler(() => {
+    // This is the same as just hitting /hello, so we'll demonstrate the exception handling
+    throw new NotFoundException();
+  })
+);
+
+// curl http://localhost:3003/hello/Stanley
+app.get(
+  "/hello/:name",
+  // Promises are handled correctly
+  handler(({ name }) => Promise.resolve({ hello: name || "Stan" }))
+);
+
+// curl -X POST http://localhost:3003/hello -H 'Content-Type: application/json' -d '{"name": "Stanley"}'
+app.post(
+  "/hello",
+  // You can also use async/await
+  handler(async ({ name }) => await Promise.resolve({ hello: name || "Stan" }))
+);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@stanlemon/server",
+  "version": "0.1.0",
+  "description": "A basic express web server setup.",
+  "author": "Stan Lemon <stanlemon@users.noreply.github.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=17.0"
+  },
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": "./src/index.js",
+  "scripts": {
+    "start": "NODE_ENV=development nodemon ./app.js",
+    "lint": "eslint --ext js,jsx,ts,tsx ./",
+    "lint:format": "eslint --fix --ext js,jsx,ts,tsx ./"
+  },
+  "dependencies": {
+    "compression": "^1.7.4",
+    "dotenv": "11.0.0",
+    "express": "^4.17.1",
+    "express-rate-limit": "^5.5.1",
+    "helmet": "^4.6.0",
+    "http-proxy-middleware": "^2.0.1",
+    "lodash-es": "^4.17.21",
+    "morgan": "^1.10.0"
+  },
+  "devDependencies": {
+    "@stanlemon/eslint-config": "*",
+    "nodemon": "^2.0.15"
+  }
+}

package/src/asyncJsonHandler.js

@@ -0,0 +1,105 @@
+import { formatInput } from "./index.js";
+import { formatOutput } from "./index.js";
+
+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,
+    };
+
+    try {
+      const output = await fn(input);
+
+      // If a value is returned we'll assume that we need to render it as JSON
+      if (output !== undefined) {
+        res.status(200).json(formatOutput(output));
+      }
+    } catch (ex) {
+      // TODO: Add better support for validation errors
+      if (ex.message === "Bad Request") {
+        res.status(400).json({ error: ex.message });
+        return;
+      }
+
+      if (ex.message === "Not Authorized") {
+        res.status(403).json({ error: ex.message });
+        return;
+      }
+
+      if (ex.message === "Not Found") {
+        res.status(404).json({ error: ex.message });
+        return;
+      }
+
+      if (ex.message === "Already Exists") {
+        res.status(409).json({ error: ex.message });
+        return;
+      }
+
+      if (
+        process.env.NODE_ENV === "development" ||
+        process.env.NODE_ENV === "test"
+      ) {
+        // eslint-disable-next-line no-console
+        console.error(ex);
+
+        res.status(500).json({ error: ex.message });
+      } else {
+        res.status(500).json({ error: "Something went wrong" });
+      }
+    }
+  };
+}
+
+export class BadRequestException extends Error {
+  static MESSAGE = "Bad Request";
+  static CODE = 400;
+
+  constructor() {
+    super(BadRequestException.MESSAGE);
+    this.name = "BadRequestException";
+    this.code = BadRequestException.CODE;
+  }
+}
+
+export class NotAuthorizedException extends Error {
+  static MESSAGE = "Not Authorized";
+  static CODE = 403;
+
+  constructor() {
+    super(NotAuthorizedException.MESSAGE);
+    this.name = "NotAuthorizedException";
+    this.code = NotAuthorizedException.CODE;
+  }
+}
+
+export class NotFoundException extends Error {
+  static MESSAGE = "Not Found";
+  static CODE = 404;
+
+  constructor() {
+    super(NotFoundException.MESSAGE);
+    this.name = "NotFoundException";
+    this.code = NotFoundException.CODE;
+  }
+}
+
+export class AlreadyExistsException extends Error {
+  static MESSAGE = "Already Exists";
+  static CODE = 409;
+
+  constructor() {
+    super(AlreadyExistsException.MESSAGE);
+    this.name = "AlreadyExistsException";
+    this.code = AlreadyExistsException.CODE;
+  }
+}

package/src/convertCase.js

@@ -0,0 +1,20 @@
+import { isObject, isArray, isString } from "lodash-es";
+
+export default function convertCase(obj, me, convert) {
+  if (
+    isString(obj) &&
+    /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/.test(
+      obj
+    )
+  ) {
+    return new Date(obj);
+  } else if (isArray(obj)) {
+    return obj.map((i) => me(i));
+  } else if (isObject(obj) && !isArray(obj)) {
+    const n = {};
+    Object.keys(obj).forEach((k) => (n[convert(k)] = me(obj[k])));
+    return n;
+  } else {
+    return obj;
+  }
+}

package/src/createAppServer.js

@@ -0,0 +1,74 @@
+import dotenv from "dotenv";
+import express from "express";
+import compression from "compression";
+import helmet from "helmet";
+import morgan from "morgan";
+import rateLimit from "express-rate-limit";
+import { createProxyMiddleware } from "http-proxy-middleware";
+
+dotenv.config();
+
+const DEVELOPMENT = "development";
+const { NODE_ENV = DEVELOPMENT, WEBPACK_URL = "http://localhost:8080" } =
+  process.env;
+
+export default function createAppServer(opts = { port: 3000 }) {
+  const app = express();
+  app.use(express.json());
+
+  const limiter = rateLimit({
+    windowMs: 15 * 60 * 1000, // X minutes
+    max: 100, // limit each IP to Y requests per windowMs
+  });
+
+  app.use(limiter);
+
+  if (process.env.NODE_ENV !== "test") {
+    app.use(morgan("combined"));
+  }
+
+  if (process.env.NODE_ENV === "production") {
+    app.use(compression());
+    app.use(helmet());
+  }
+
+  if (NODE_ENV !== DEVELOPMENT) {
+    app.use(express.static("./dist"));
+  }
+
+  if (NODE_ENV === DEVELOPMENT && WEBPACK_URL) {
+    app.get(
+      "/*.js",
+      createProxyMiddleware({
+        target: WEBPACK_URL,
+        changeOrigin: true,
+      })
+    );
+
+    app.get(
+      "/",
+      createProxyMiddleware({
+        target: WEBPACK_URL,
+        changeOrigin: true,
+      })
+    );
+  }
+
+  app.get("/health", (req, res) => {
+    res.json({
+      success: true,
+    });
+  });
+
+  const server = app.listen(opts.port);
+
+  /* eslint-disable no-console */
+  console.log("Starting in %s mode", NODE_ENV);
+  console.log(
+    "Listening at http://%s:%s",
+    server.address().address === "::" ? "localhost" : server.address().address,
+    server.address().port
+  );
+
+  return app;
+}

package/src/formatInput.js

@@ -0,0 +1,6 @@
+import { snakeCase } from "lodash-es";
+import convertCase from "./convertCase.js";
+
+export default function formatInput(obj) {
+  return convertCase(obj, formatInput, snakeCase);
+}

package/src/formatOutput.js

@@ -0,0 +1,12 @@
+import { camelCase, isArray, isDate } from "lodash-es";
+import convertCase from "./convertCase.js";
+
+export default function formatOutput(obj) {
+  if (isDate(obj)) {
+    return obj.toISOString();
+  }
+  if (isArray(obj)) {
+    return obj.map((v) => formatOutput(v));
+  }
+  return convertCase(obj, formatOutput, camelCase);
+}

package/src/index.js

@@ -0,0 +1,5 @@
+export { default as createAppServer } from "./createAppServer.js";
+export { default as convertCase } from "./convertCase.js";
+export { default as formatInput } from "./formatInput.js";
+export { default as formatOutput } from "./formatOutput.js";
+export * from "./asyncJsonHandler.js";