Upload 36 files

.dockerignore

@@ -0,0 +1,8 @@
+Dockerfile
+docker-compose.yml
+node_modules
+logos.png
+LICENSE
+README.md
+npm-debug.log
+

.editorconfig

@@ -0,0 +1,16 @@
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.js]
+indent_style = space
+indent_size = 2

.eslintrc.json

@@ -0,0 +1,16 @@
+{
+  "extends": "eslint:recommended",
+  "env": {
+    "es6": true,
+    "node": true,
+    "browser": false,
+    "jest": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2020
+  },
+  "rules": {
+    "no-unused-vars": "warn",
+    "no-console": "off"
+  }
+}

.gitignore

@@ -0,0 +1,13 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Dependency directories
+node_modules
+
+# Optional npm cache directory
+.npm
+
+# Auto-Generated Jest MongoDB config
+globalConfig.json

.nvmrc

@@ -0,0 +1 @@
+16.13.1

.prettierrc

@@ -0,0 +1,3 @@
+{
+  "trailingComma": "es5"
+}

Dockerfile

@@ -0,0 +1,16 @@
+FROM node:16
+LABEL MAINTAINER Michael Hueter <mthueter@gmail.com>
+
+RUN npm install pm2@latest --global --quiet
+
+WORKDIR /usr/src/app
+COPY package*.json ./
+
+# Bundle app source
+COPY . .
+
+RUN npm ci --only=production
+
+EXPOSE 8080
+
+CMD ["pm2-runtime", "./config/pm2.json"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Michael Hueter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,61 @@
----
-title: Node Docker Boilerplate
-emoji: 📈
-colorFrom: red
-colorTo: pink
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# RESTful API Server Boilerplate
+
+## Featuring Docker, Node, Express, MongoDB, Mongoose, & NGINX
+
+![Tech Logos](./logos.png)
+
+## License & Purpose
+
+MIT License. This is something I've used in production before with success that I found useful for quickly bootstrapping RESTful APIs. You can fork and clone and take this apart without giving me any credit for anything. If you like it, you can star the repo ⭐️ or follow me on GitHub.
+
+Feel free to make an issue or PR if you want to suggest ideas / fixes.
+
+## About
+
+This configuration is a backend [RESTful API](https://en.wikipedia.org/wiki/Representational_state_transfer) boilerplate with the following pieces:
+
+- [Docker](https://www.docker.com/) as the container service to isolate the environment.
+- [Node.js](https://nodejs.org/en/) (Long-Term-Support Version) as the run-time environment to run JavaScript.
+- [Express.js](https://expressjs.com/) as the server framework / controller layer
+- [MongoDB](https://www.mongodb.com/) as the database layer
+- [Mongoose](https://mongoosejs.com/) as the "ODM" / model layer
+- [NGINX](https://docs.nginx.com/nginx/admin-guide/content-cache/content-caching/) as a proxy / content-caching layer
+
+## How to Install & Run
+
+You will need to first download and install [Docker Desktop](https://www.docker.com/products/docker-desktop) or [Linux equivalent](https://docs.docker.com/install/linux/docker-ce/ubuntu/).
+
+0.  Fork/Clone the repo
+1.  Run `docker-compose up` to start three containers:
+    - the MongoDB database container
+    - the Node.js app container
+    - the NGINX proxy container
+1.  Server is accessible at `http://localhost:8080` if you have Docker for Windows or Mac. Use `http://localhost` without specifying the port to hit the NGINX proxy. On Linux, you may need to hit the IP Address of the docker-machine rather than `localhost` (port rules are the same.)
+
+## How to Run Tests
+
+Currently, tests are run outside of the Docker container (unfortunately for now). The tests use an in-memory version of MongoDB. You should be able to run `npm install` followed by `npm test` to run everything (assuming you have the LTS version of Node installed on your machine).
+
+## App Structure
+
+- the boilerplate entity is called "Thing" and all the routes are based on the thing resource. When you want to start building a real API, you can probably just do a global find and replace for thing, but mind the case-sensitivity.
+- most folders have an `index.js` which simply exports the contents of all the files in those folders. This is to make importing things around the app slightly easier, since you can just `require` the folder name and destructure the functions you are looking for. Check out [this part of the Node.js docs](https://nodejs.org/api/modules.html#modules_folders_as_modules) for more info.
+
+**\_\_tests\_\_**
+
+- this folder contains unit and integration tests both run using `npm test` which in turn uses [Jest](https://jestjs.io/)
+
+**./app**
+
+- `handlers` are Express.js route handlers that have `request`, `response`, and `next` parameters.
+- `helpers` are raw JS "classes" and utility functions for use across the app
+- `models` are [Mongoose schema](https://mongoosejs.com/docs/guide.html) definitions and associated models
+- `routers` are RESTful route declarations using [express.Router module](https://expressjs.com/en/guide/routing.html) that utilize the functions in `handlers`
+- `schemas` are [JSONSchema](https://json-schema.org/understanding-json-schema/index.html) validation schemas for creating or updating a Thing. Pro-tip: use [JSONSchema.net](https://jsonschema.net/) to generate schemas based on examples for you.
+- `app.js` is what builds and configures the express app
+- `config.js` is the app-specific config that you will want to customize for your app
+- `index.js` is the entrypoint that actually starts the Express server
+
+**./config**
+
+- config contains NGINX proxy configuration, the production pm2 configuration (the process-runner of choice), and the Jest configuration to run MongoDB in memory

__tests__/integration.js

@@ -0,0 +1,72 @@
+/**
+ * These tests currently only work if you have a local MongoDB database
+ */
+const request = require("supertest");
+const mongoose = require("mongoose");
+const app = require("../app/app");
+const { Thing } = require("../app/models");
+
+const exampleThing = {
+  name: "Example",
+  number: 5,
+  stuff: ["cats", "dogs"],
+  url: "https://google.com",
+};
+
+beforeEach(async () => {
+  const testThing = new Thing(exampleThing);
+  await testThing.save();
+});
+
+afterEach(async () => {
+  await mongoose.connection.dropCollection("things");
+});
+
+afterAll(async () => {
+  await mongoose.disconnect();
+});
+
+describe("GET /things", () => {
+  test("Get a list of things", async () => {
+    let response = await request(app).get("/things");
+    expect(response.body).toEqual([exampleThing]);
+  });
+});
+
+describe("POST /things", () => {
+  test("Create a mini new Thing", async () => {
+    let response = await request(app).post("/things").send({ name: "A Thing" });
+    expect(response.body).toEqual({ name: "A Thing", stuff: [] });
+  });
+  test("Create a full new Thing", async () => {
+    const fullThing = {
+      name: "Other Thing",
+      stuff: ["cats", "dogs"],
+      number: 5,
+      url: "http://google.com",
+    };
+    let response = await request(app).post("/things").send(fullThing);
+    expect(response.body).toEqual(fullThing);
+
+    let duplicateResponse = await request(app)
+      .post("/things")
+      .send({ name: "Other Thing" });
+    expect(duplicateResponse.status).toEqual(409);
+  });
+});
+
+describe("PATCH /things/:name", () => {
+  test("Update a thing's name", async () => {
+    let response = await request(app)
+      .patch("/things/Example")
+      .send({ name: "New Name" });
+    expect(response.body).toEqual({ ...exampleThing, name: "New Name" });
+  });
+});
+
+describe("DELETE /things/:name", () => {
+  test("Delete a thing name", async () => {
+    let response = await request(app).delete("/things/Example");
+    expect(response.body).toEqual(exampleThing);
+  });
+});

__tests__/unit.js

@@ -0,0 +1,42 @@
+const { APIError, parseSkipLimit } = require("../app/helpers");
+
+describe("Helper Functions", () => {
+  describe("parseSkipLimit()", () => {
+    it("should return a number if a valid limit is passed", () => {
+      const limit = "6";
+      const validatedLimit = parseSkipLimit(limit);
+      expect(validatedLimit).toBe(6);
+    });
+    it("should return an API Error if a non-numeric limit is passed", () => {
+      const limit = "foo";
+      const validatedLimit = parseSkipLimit(limit);
+      expect(validatedLimit).toBeInstanceOf(APIError);
+    });
+    it('should return an API Error if zero is passed when type is "limit"', () => {
+      const limit = "0";
+      const validatedLimit = parseSkipLimit(limit);
+      expect(validatedLimit).toBeInstanceOf(APIError);
+    });
+    it('should return zero if zero is passed when the type is "skip"', () => {
+      const skip = "0";
+      const validatedLimit = parseSkipLimit(skip, 1000, "skip");
+      expect(validatedLimit).toBe(0);
+    });
+    it("should return an API Error if a negative limit is passed", () => {
+      const limit = "-1";
+      const validatedLimit = parseSkipLimit(limit);
+      expect(validatedLimit).toBeInstanceOf(APIError);
+    });
+    it("should return an API Error if a limit > max is passed", () => {
+      const maximum = 100;
+      const limit = "101";
+      const validatedLimit = parseSkipLimit(limit, maximum);
+      expect(validatedLimit).toBeInstanceOf(APIError);
+    });
+    it("should return a number if a valid numeric limit is passed", () => {
+      const limit = "5";
+      const validatedLimit = parseSkipLimit(limit);
+      expect(validatedLimit).toBe(5);
+    });
+  });
+});

app/app.js

@@ -0,0 +1,44 @@
+// npm packages
+const dotenv = require("dotenv");
+const express = require("express");
+
+// app imports
+const { connectToDatabase, globalResponseHeaders } = require("./config");
+const { errorHandler } = require("./handlers");
+const { thingsRouter } = require("./routers");
+
+// global constants
+dotenv.config();
+const app = express();
+const {
+  bodyParserHandler,
+  globalErrorHandler,
+  fourOhFourHandler,
+  fourOhFiveHandler,
+} = errorHandler;
+
+// database
+connectToDatabase();
+
+// body parser setup
+app.use(express.urlencoded({ extended: true }));
+app.use(express.json({ type: "*/*" }));
+app.use(bodyParserHandler); // error handling specific to body parser only
+
+// response headers setup; CORS
+app.use(globalResponseHeaders);
+
+app.use("/things", thingsRouter);
+
+// catch-all for 404 "Not Found" errors
+app.get("*", fourOhFourHandler);
+// catch-all for 405 "Method Not Allowed" errors
+app.all("*", fourOhFiveHandler);
+
+app.use(globalErrorHandler);
+
+/**
+ * This file does NOT run the app. It merely builds and configures it then exports it.config
+ *  This is for integration tests with supertest (see __tests__).
+ */
+module.exports = app;

app/config.js

@@ -0,0 +1,56 @@
+const mongoose = require("mongoose");
+
+const APP_NAME = "Boilerplate API";
+const ENV = process.env.NODE_ENV;
+const PORT = process.env.PORT || 8080;
+
+/**
+ * Connect to mongoose asynchronously or bail out if it fails
+ */
+async function connectToDatabase() {
+  const MONGODB_URI =
+    process.env.MONGODB_URI || "mongodb://mongodb/boilerplate";
+
+  mongoose.Promise = Promise;
+  if (ENV === "development" || ENV === "test") {
+    mongoose.set("debug", true);
+  }
+
+  try {
+    await mongoose.connect(MONGODB_URI, {
+      autoIndex: false,
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    console.log(`${APP_NAME} successfully connected to database.`);
+  } catch (error) {
+    console.log(error);
+    process.exit(1);
+  }
+}
+
+/**
+ * Configuration middleware to enable cors and set some other allowed headers.
+ *  You can also just use the 'cors' package.
+ */
+function globalResponseHeaders(request, response, next) {
+  response.header("Access-Control-Allow-Origin", "*");
+  response.header(
+    "Access-Control-Allow-Headers",
+    "Origin, Accept, X-Requested-With, Content-Type, Access-Control-Request-Method, Access-Control-Request-Headers, Authorization"
+  );
+  response.header(
+    "Access-Control-Allow-Methods",
+    "POST,GET,PATCH,DELETE,OPTIONS"
+  );
+  response.header("Content-Type", "application/json");
+  return next();
+}
+
+module.exports = {
+  APP_NAME,
+  ENV,
+  PORT,
+  connectToDatabase,
+  globalResponseHeaders,
+};

app/handlers/error.js

@@ -0,0 +1,45 @@
+const { APP_NAME } = require("../config");
+const { APIError } = require("../helpers");
+
+function bodyParserHandler(error, request, response, next) {
+  if (error instanceof SyntaxError || error instanceof TypeError) {
+    // console.error(error);
+    return next(new APIError(400, "Bad Request", "Malformed JSON."));
+  }
+}
+
+function fourOhFourHandler(request, response, next) {
+  return next(
+    new APIError(
+      404,
+      "Resource Not Found",
+      `${request.path} is not valid path to a ${APP_NAME} resource.`
+    )
+  );
+}
+
+function fourOhFiveHandler(request, response, next) {
+  return next(
+    new APIError(
+      405,
+      "Method Not Allowed",
+      `${request.method} method is not supported at ${request.path}.`
+    )
+  );
+}
+
+function globalErrorHandler(error, request, response, next) {
+  let err = error;
+  if (!(error instanceof APIError)) {
+    err = new APIError(500, error.type, error.message);
+  }
+
+  return response.status(err.status).json(err);
+}
+
+module.exports = {
+  bodyParserHandler,
+  fourOhFourHandler,
+  fourOhFiveHandler,
+  globalErrorHandler
+};

app/handlers/index.js

@@ -0,0 +1,3 @@
+exports.errorHandler = require("./error");
+exports.thingHandler = require("./thing");
+exports.thingsHandler = require("./things");

app/handlers/thing.js

@@ -0,0 +1,91 @@
+// npm packages
+const { validate } = require("jsonschema");
+
+// app imports
+const { Thing } = require("../models");
+const { APIError } = require("../helpers");
+const { thingNewSchema, thingUpdateSchema } = require("../schemas");
+
+/**
+ * Validate the POST request body and create a new Thing
+ */
+async function createThing(request, response, next) {
+  const validation = validate(request.body, thingNewSchema);
+  if (!validation.valid) {
+    return next(
+      new APIError(
+        400,
+        "Bad Request",
+        validation.errors.map(e => e.stack).join(". ")
+      )
+    );
+  }
+
+  try {
+    const newThing = await Thing.createThing(new Thing(request.body));
+    return response.status(201).json(newThing);
+  } catch (err) {
+    return next(err);
+  }
+}
+
+/**
+ * Get a single thing
+ * @param {String} name - the name of the Thing to retrieve
+ */
+async function readThing(request, response, next) {
+  const { name } = request.params;
+  try {
+    const thing = await Thing.readThing(name);
+    return response.json(thing);
+  } catch (err) {
+    return next(err);
+  }
+}
+
+/**
+ * Update a single thing
+ * @param {String} name - the name of the Thing to update
+ */
+async function updateThing(request, response, next) {
+  const { name } = request.params;
+
+  const validation = validate(request.body, thingUpdateSchema);
+  if (!validation.valid) {
+    return next(
+      new APIError(
+        400,
+        "Bad Request",
+        validation.errors.map(e => e.stack).join(". ")
+      )
+    );
+  }
+
+  try {
+    const thing = await Thing.updateThing(name, request.body);
+    return response.json(thing);
+  } catch (err) {
+    return next(err);
+  }
+}
+
+/**
+ * Remove a single thing
+ * @param {String} name - the name of the Thing to remove
+ */
+async function deleteThing(request, response, next) {
+  const { name } = request.params;
+  try {
+    const deleteMsg = await Thing.deleteThing(name);
+    return response.json(deleteMsg);
+  } catch (err) {
+    return next(err);
+  }
+}
+
+module.exports = {
+  createThing,
+  readThing,
+  updateThing,
+  deleteThing
+};

app/handlers/things.js

@@ -0,0 +1,28 @@
+// app imports
+const { Thing } = require("../models");
+const { APIError, parseSkipLimit } = require("../helpers");
+
+/**
+ * List all the things. Query params ?skip=0&limit=1000 by default
+ */
+async function readThings(request, response, next) {
+  /* pagination validation */
+  let skip = parseSkipLimit(request.query.skip) || 0;
+  let limit = parseSkipLimit(request.query.limit, 1000) || 1000;
+  if (skip instanceof APIError) {
+    return next(skip);
+  } else if (limit instanceof APIError) {
+    return next(limit);
+  }
+
+  try {
+    const things = await Thing.readThings({}, {}, skip, limit);
+    return response.json(things);
+  } catch (err) {
+    return next(err);
+  }
+}
+
+module.exports = {
+  readThings
+};

app/helpers/APIError.js

@@ -0,0 +1,31 @@
+/** Class representing an API Error Response with a related HTTP Status Code **/
+class APIError extends Error {
+  /**
+   * Create an Error Object
+   * @param {Number} status - The HTTP Status Code (e.g. 404)
+   * @param {String} title - The title corresponding to the Status Code (e.g. Bad Request)
+   * @param {String} message - Specific information about what caused the error
+   */
+  constructor(
+    status = 500,
+    title = "Internal Server Error",
+    message = "An unknown server error occurred."
+  ) {
+    super(message);
+    this.status = status;
+    this.title = title;
+    this.message = message;
+  }
+  toJSON() {
+    const { status, title, message } = this;
+    return {
+      error: {
+        status,
+        title,
+        message
+      }
+    };
+  }
+}
+
+module.exports = APIError;

app/helpers/index.js

@@ -0,0 +1,2 @@
+exports.APIError = require("./APIError");
+exports.parseSkipLimit = require("./parseSkipLimit");

app/helpers/parseSkipLimit.js

@@ -0,0 +1,33 @@
+const APIError = require("./APIError");
+/**
+ * Validate the 'limit' and `skip` query params
+ * @param {String} val - limit or skip param
+ * @param {Number} max - the max value (default 1000)
+ * @param {String} type - what we're validating (skip or limit, default limit)
+ * @return {Number} numerical form of the val
+ */
+function parseSkipLimit(val, max = 1000, type = "limit") {
+  if (!val) {
+    return null;
+  }
+  const min = type === "skip" ? 0 : 1;
+  const num = +val;
+
+  if (!Number.isInteger(num)) {
+    return new APIError(
+      400,
+      "Bad Request",
+      `Invalid ${type}: '${val}', ${type} needs to be an integer.`
+    );
+  } else if (num < min || (max && num > max)) {
+    return new APIError(
+      400,
+      "Bad Request",
+      `${num} is out of range for ${type} -- it should be between ${min} and ${max}.`
+    );
+  }
+
+  return num;
+}
+
+module.exports = parseSkipLimit;

app/models/Thing.js

@@ -0,0 +1,108 @@
+// npm packages
+const mongoose = require("mongoose");
+
+// app imports
+const { APIError } = require("../helpers");
+
+// globals
+const Schema = mongoose.Schema;
+
+const thingSchema = new Schema({
+  name: String,
+  number: Number,
+  stuff: [String],
+  url: String
+});
+
+thingSchema.statics = {
+  /**
+   * Create a Single New Thing
+   * @param {object} newThing - an instance of Thing
+   * @returns {Promise<Thing, APIError>}
+   */
+  async createThing(newThing) {
+    const duplicate = await this.findOne({ name: newThing.name });
+    if (duplicate) {
+      throw new APIError(
+        409,
+        "Thing Already Exists",
+        `There is already a thing with name '${newThing.name}'.`
+      );
+    }
+    const thing = await newThing.save();
+    return thing.toObject();
+  },
+  /**
+   * Delete a single Thing
+   * @param {String} name - the Thing's name
+   * @returns {Promise<Thing, APIError>}
+   */
+  async deleteThing(name) {
+    const deleted = await this.findOneAndRemove({ name });
+    if (!deleted) {
+      throw new APIError(404, "Thing Not Found", `No thing '${name}' found.`);
+    }
+    return deleted.toObject();
+  },
+  /**
+   * Get a single Thing by name
+   * @param {String} name - the Thing's name
+   * @returns {Promise<Thing, APIError>}
+   */
+  async readThing(name) {
+    const thing = await this.findOne({ name });
+
+    if (!thing) {
+      throw new APIError(404, "Thing Not Found", `No thing '${name}' found.`);
+    }
+    return thing.toObject();
+  },
+  /**
+   * Get a list of Things
+   * @param {Object} query - pre-formatted query to retrieve things.
+   * @param {Object} fields - a list of fields to select or not in object form
+   * @param {String} skip - number of docs to skip (for pagination)
+   * @param {String} limit - number of docs to limit by (for pagination)
+   * @returns {Promise<Things, APIError>}
+   */
+  async readThings(query, fields, skip, limit) {
+    const things = await this.find(query, fields)
+      .skip(skip)
+      .limit(limit)
+      .sort({ name: 1 })
+      .exec();
+    if (!things.length) {
+      return [];
+    }
+    return things.map(thing => thing.toObject());
+  },
+  /**
+   * Patch/Update a single Thing
+   * @param {String} name - the Thing's name
+   * @param {Object} thingUpdate - the json containing the Thing attributes
+   * @returns {Promise<Thing, APIError>}
+   */
+  async updateThing(name, thingUpdate) {
+    const thing = await this.findOneAndUpdate({ name }, thingUpdate, {
+      new: true
+    });
+    if (!thing) {
+      throw new APIError(404, "Thing Not Found", `No thing '${name}' found.`);
+    }
+    return thing.toObject();
+  }
+};
+
+/* Transform with .toObject to remove __v and _id from response */
+if (!thingSchema.options.toObject) thingSchema.options.toObject = {};
+thingSchema.options.toObject.transform = (doc, ret) => {
+  const transformed = ret;
+  delete transformed._id;
+  delete transformed.__v;
+  return transformed;
+};
+
+/** Ensure MongoDB Indices **/
+thingSchema.index({ name: 1, number: 1 }, { unique: true }); // example compound idx
+
+module.exports = mongoose.model("Thing", thingSchema);

app/models/index.js

@@ -0,0 +1 @@
+exports.Thing = require("./Thing");

app/routers/index.js

@@ -0,0 +1 @@
+exports.thingsRouter = require("./things");

app/routers/things.js

@@ -0,0 +1,25 @@
+// npm packages
+const express = require("express");
+
+// app imports
+const { thingHandler, thingsHandler } = require("../handlers");
+
+// globals
+const router = new express.Router();
+const { readThings } = thingsHandler;
+const { createThing, readThing, updateThing, deleteThing } = thingHandler;
+
+/* All the Things Route */
+router
+  .route("")
+  .get(readThings)
+  .post(createThing);
+
+/* Single Thing by Name Route */
+router
+  .route("/:name")
+  .get(readThing)
+  .patch(updateThing)
+  .delete(deleteThing);
+
+module.exports = router;

app/schemas/index.js

@@ -0,0 +1,2 @@
+exports.thingNewSchema = require('./thingNew');
+exports.thingUpdateSchema = require('./thingUpdate');

app/schemas/thingNew.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "number": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "stuff": {
+      "type": "array",
+      "uniqueItems": true,
+      "minItems": 1,
+      "items": {
+        "type": "string"
+      }
+    },
+    "url": {
+      "type": "string",
+      "format": "uri"
+    }
+  },
+  "required": ["name"]
+}

app/schemas/thingUpdate.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "number": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "stuff": {
+      "type": "array",
+      "uniqueItems": true,
+      "minItems": 1,
+      "items": {
+        "type": "string"
+      }
+    },
+    "url": {
+      "type": "string",
+      "format": "uri"
+    }
+  },
+  "required": ["name"]
+}

app/server.js

@@ -0,0 +1,6 @@
+const { APP_NAME, PORT } = require("./config");
+const app = require("./app");
+
+app.listen(PORT, () => {
+  console.log(`${APP_NAME} is listening on port ${PORT}...`);
+});

config/jest/globalSetup.js

@@ -0,0 +1,6 @@
+const { MongoMemoryServer } = require("mongodb-memory-server");
+
+module.exports = async function () {
+  global.__MONGO_MEMORY_SERVER_INSTANCE__ = await MongoMemoryServer.create();
+  process.env.MONGODB_URI = `mongodb://localhost:27017/boilerplate-test`;
+};

config/jest/globalTeardown.js

@@ -0,0 +1,3 @@
+module.exports = async function () {
+  await global.__MONGO_MEMORY_SERVER_INSTANCE__.stop();
+};

config/nginx/nginx.conf

@@ -0,0 +1,76 @@
+worker_processes auto;
+worker_rlimit_nofile 100000;
+worker_cpu_affinity auto;
+events {
+    worker_connections 1024;
+    use epoll;
+    multi_accept on;
+}
+
+http {
+    proxy_cache_path /etc/nginx/cache levels=1:2 keys_zone=cache:8m max_size=1000m inactive=600m;
+    proxy_temp_path /etc/nginx/cache/tmp;
+
+    server {
+        listen 80;
+        server_name boilerplate-api;
+
+        access_log /dev/stdout;
+        error_log /dev/stdout error;
+
+        # gzip Compression
+        gzip on;
+        gzip_proxied any;
+        gzip_min_length 1000;
+        gzip_types application/json;
+        gzip_vary on;
+
+        # Keepalive and Timeouts
+        client_body_timeout 30;
+        client_header_timeout 30;
+        keepalive_timeout 30;
+        keepalive_requests 100000;
+        reset_timedout_connection on;
+        send_timeout 30;
+
+        # Proxy Settings
+        # Left as defaults
+
+        # File Descriptor cache
+        open_file_cache max=200000 inactive=20s;
+        open_file_cache_valid 30s;
+        open_file_cache_min_uses 2;
+        open_file_cache_errors on;
+
+        # Other Settings
+        client_max_body_size 0;
+        underscores_in_headers on;
+        tcp_nopush on;
+        tcp_nodelay on;
+        sendfile on;
+
+        location /nginx_status {
+            stub_status on;
+            access_log off;
+        }
+
+        location / {
+            proxy_ignore_headers "Set-Cookie";
+            proxy_hide_header "Set-Cookie";
+
+            proxy_cache cache;
+            proxy_cache_key $scheme$proxy_host$uri$is_args$args;
+            proxy_cache_valid 200 10m;
+            proxy_cache_bypass $arg_nocache;
+
+            add_header X-Cache-Status $upstream_cache_status;
+
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Host $server_name;
+            proxy_pass http://app:8080;
+        }
+
+    }
+}

config/pm2.json

@@ -0,0 +1,10 @@
+{
+  "apps": [
+    {
+      "name": "Boilerplate-API",
+      "script": "./app/server.js",
+      "instances": "max",
+      "exec_mode": "cluster"
+    }
+  ]
+}

docker-compose.yml

@@ -0,0 +1,29 @@
+version: "3"
+services:
+  app:
+    build: .
+    command: pm2-dev ./app/server.js
+    environment:
+      NODE_ENV: development
+    depends_on:
+      - mongodb
+    ports:
+      - "8080:8080"
+    volumes:
+      - .:/usr/src/app
+      - ./node_modules:/home/nodejs/node_modules
+
+  nginx:
+    image: nginx:latest
+    links:
+      - app
+    ports:
+      - "80:80"
+    volumes:
+      - ./config/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+
+  mongodb:
+    image: mongo:4
+    command: mongod
+    ports:
+      - "27017:27017"

package.json

@@ -0,0 +1,34 @@
+{
+  "author": "Michael Hueter <mthueter@gmail.com>",
+  "version": "2.0.0",
+  "name": "docker-node-express-boilerplate",
+  "description": "Boilerplate Dockerized Express code to launch new RESTful APIs.",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:mhueter/docker-node-express-boilerplate.git"
+  },
+  "main": "app/app.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "dotenv": "10.0.0",
+    "express": "4.17.2",
+    "jsonschema": "1.4.0",
+    "mongoose": "6.1.4"
+  },
+  "devDependencies": {
+    "babel-eslint": "^10.1.0",
+    "babel-preset-es2017": "^6.24.1",
+    "eslint": "^8.5.0",
+    "jest": "^27.4.5",
+    "jest-environment-node": "^27.4.4",
+    "mongodb-memory-server": "^8.1.0",
+    "supertest": "^6.1.6"
+  },
+  "jest": {
+    "globalSetup": "./config/jest/globalSetup.js",
+    "globalTeardown": "./config/jest/globalTeardown.js"
+  }
+}