@apolitical/server 2.5.0-rc.1 → 2.5.1

package/CHANGELOG.md

@@ -5,9 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.5.1] - 2022-06-01
+### Added
+- Cache to `readinessCheck` and `livenessCheck` checks to avoid overload
+
 ## [2.5.0] - 2022-05-06
 ### Added
-- Custom `livenessCheck` to define liveness externally
+- Custom `readinessCheck` and `livenessCheck` to define probes externally
+- New probe `/health` endpoint to combine readiness and liveness
 
 ## [2.4.2] - 2022-03-03
 ### Bumped

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apolitical/server",
-  "version": "2.5.0-rc.1",
+  "version": "2.5.1",
   "description": "Node.js module to encapsulate Apolitical's express server setup",
   "author": "Apolitical Group Limited <engineering@apolitical.co>",
   "license": "MIT",
@@ -31,28 +31,29 @@
     "compression": "1.7.4",
     "cookie-parser": "1.4.6",
     "cors": "2.8.5",
-    "dotenv": "16.0.0",
+    "dotenv": "16.0.1",
     "express": "4.18.1",
-    "express-jwt": "7.6.2",
+    "express-jwt": "7.7.5",
     "http-status-codes": "2.2.0",
     "http-terminator": "3.2.0",
-    "jsrsasign": "10.5.20",
-    "jwks-rsa": "2.1.1",
+    "jsrsasign": "10.5.23",
+    "jwks-rsa": "2.1.3",
     "jwt-decode": "3.1.2",
+    "lru-cache": "7.10.1",
     "morgan": "1.10.0",
-    "passport": "0.5.2",
+    "passport": "0.6.0",
     "passport-jwt": "4.0.0",
     "prerender-node": "3.5.0",
-    "swagger-ui-express": "4.3.0"
+    "swagger-ui-express": "4.4.0"
   },
   "devDependencies": {
-    "@apolitical/eslint-config": "2.0.0",
+    "@apolitical/eslint-config": "2.0.1",
     "@apolitical/testing": "1.0.2",
-    "audit-ci": "6.2.0",
-    "husky": "7.0.4",
+    "audit-ci": "6.3.0",
+    "husky": "8.0.1",
     "jest": "28.1.0",
     "jest-junit": "13.2.0",
-    "lint-staged": "12.4.1",
+    "lint-staged": "13.0.0",
     "mock-jwks": "1.0.3",
     "nock": "13.2.4"
   },

package/src/config.js

@@ -18,6 +18,7 @@ module.exports = {
   },
   ENDPOINTS: {
     PROBES: {
+      HEALTH: '/health',
       LIVENESS: '/liveness',
       READINESS: '/readiness',
     },
@@ -48,6 +49,10 @@ module.exports = {
         USER_SLUG: 'user-slug',
       },
     },
+    CACHE_OPTIONS: {
+      max: 2, // Only liveness and readiness
+      ttl: 60 * 1000, // One minute
+    },
   },
   JWT: {
     APOLITICAL: {

package/src/container.js

@@ -14,6 +14,7 @@ const httpTerminator = require('http-terminator');
 const jwksRsa = require('jwks-rsa');
 const jsrsasign = require('jsrsasign');
 const jwtDecode = require('jwt-decode');
+const lru = require('lru-cache');
 const morgan = require('morgan');
 const passport = require('passport');
 const passportJwt = require('passport-jwt');
@@ -34,6 +35,7 @@ const jwtPassportHelper = require('./helpers/jwt/passport.helper');
 const loggerHelper = require('./helpers/logger.helper');
 // Loaders
 const documentationLoader = require('./loaders/documentation.loader');
+const expressLoader = require('./loaders/express.loader');
 const loggerLoader = require('./loaders/logger.loader');
 const middlewaresLoader = require('./loaders/middlewares.loader');
 const probesLoader = require('./loaders/probes.loader');
@@ -45,6 +47,8 @@ const jwtApoliticalMiddleware = require('./middlewares/jwt/apolitical.middleware
 const jwtAuth0Middleware = require('./middlewares/jwt/auth0.middleware');
 const errorMiddleware = require('./middlewares/error.middleware');
 // Services
+const expressService = require('./services/express.service');
+const healthService = require('./services/health.service');
 const jwtService = require('./services/jwt.service');
 const serverService = require('./services/server.service');
 
@@ -64,6 +68,7 @@ container.register({
   jwksRsa: asValue(jwksRsa),
   jsrsasign: asValue(jsrsasign),
   jwtDecode: asValue(jwtDecode),
+  lru: asValue(lru),
   morgan: asValue(morgan),
   passport: asValue(passport),
   passportJwt: asValue(passportJwt),
@@ -84,6 +89,7 @@ container.register({
   loggerHelper: asFunction(loggerHelper).singleton(),
   // Loaders
   documentationLoader: asFunction(documentationLoader).singleton(),
+  expressLoader: asFunction(expressLoader).singleton(),
   loggerLoader: asFunction(loggerLoader).singleton(),
   middlewaresLoader: asFunction(middlewaresLoader).singleton(),
   probesLoader: asFunction(probesLoader).singleton(),
@@ -95,6 +101,8 @@ container.register({
   jwtAuth0Middleware: asFunction(jwtAuth0Middleware).singleton(),
   errorMiddleware: asFunction(errorMiddleware).singleton(),
   // Services
+  expressService: asFunction(expressService).singleton(),
+  healthService: asFunction(healthService).singleton(),
   jwtService: asFunction(jwtService).singleton(),
   serverService: asFunction(serverService).singleton(),
 });

package/src/loaders/express.loader.js

@@ -0,0 +1,36 @@
+'use strict';
+
+module.exports = ({
+  logger,
+  documentationLoader,
+  loggerLoader,
+  errorMiddleware,
+  middlewaresLoader,
+  probesLoader,
+  fallbackLoader,
+}) => {
+  // Main (express) loader
+  return async function load(app, opts) {
+    const childLogger = logger.where(__filename, 'load');
+    childLogger.debug('Started');
+    // Load probes
+    probesLoader(app, opts);
+    // Load useful middlewares
+    middlewaresLoader(app, opts);
+    // Load logger
+    await loggerLoader(app, opts);
+    // Load custom resources
+    if (opts.appLoader) {
+      await opts.appLoader(app);
+    }
+    // Load documentation
+    documentationLoader(app, opts);
+    // Load fallback routing
+    fallbackLoader(app, opts);
+    // Use error handler
+    if (opts.handleErrors) {
+      app.use(errorMiddleware(opts));
+    }
+    childLogger.debug('Finished');
+  };
+};

package/src/loaders/probes.loader.js

@@ -1,20 +1,22 @@
 'use strict';
 
-module.exports = ({ health, config, logger }) => {
-  const { LIVENESS, READINESS } = config.ENDPOINTS.PROBES;
+module.exports = ({ config, logger, healthService }) => {
+  const { HEALTH, LIVENESS, READINESS } = config.ENDPOINTS.PROBES;
 
-  return function load(app, { livenessCheck }) {
+  return function load(app, { readinessCheck, livenessCheck }) {
     const childLogger = logger.where(__filename, 'load');
     childLogger.debug('Started');
-    // Setup health checker
-    const healthCheck = new health.HealthChecker();
-    // Overwrite live check when it is defined
+    // Overwrite checks when defined
+    if (readinessCheck) {
+      healthService.registerReadiness(readinessCheck);
+    }
     if (livenessCheck) {
-      healthCheck.registerLivenessCheck(new health.LivenessCheck('livenessCheck', livenessCheck));
+      healthService.registerLiveness(livenessCheck);
     }
     // Load probes endpoints
-    app.get(LIVENESS, health.LivenessEndpoint(healthCheck));
-    app.get(READINESS, health.ReadinessEndpoint(healthCheck));
+    app.get(HEALTH, healthService.healthEndpoint());
+    app.get(READINESS, healthService.readinessEndpoint());
+    app.get(LIVENESS, healthService.livenessEndpoint());
     childLogger.debug('Finished');
   };
 };

package/src/middlewares/jwt/auth0.middleware.js

@@ -2,7 +2,7 @@
 
 module.exports = ({ expressJwt: { expressjwt: jwt }, jwksRsa, config }) => {
   const { CACHE, RATE_LIMIT, RPM, URI, ALGORITHMS } = config.JWT.AUTH0;
-  // Express JWT authentication (Auth0)
+  // Define express JWT authentication (Auth0)
   return function handler({ domain, audience, issuer }) {
     return jwt({
       secret: jwksRsa.expressJwtSecret({

package/src/services/express.service.js

@@ -0,0 +1,48 @@
+'use strict';
+
+module.exports = ({ express, httpTerminator, logger, expressLoader }) => {
+  let app = null;
+  let terminator = null; // I need your clothes, your boots and your motorcycle
+
+  function expressRunner(app, port) {
+    const childLogger = logger.where(__filename, 'expressRunner');
+    childLogger.debug('Started');
+    return new Promise((resolve, reject) => {
+      if (!port) {
+        childLogger.warn('Missing port option');
+        return reject(new Error('Cannot start server without port option'));
+      }
+      const server = app.listen(port, () => {
+        childLogger.info(`Server listening on ${port}`);
+        return resolve();
+      });
+      terminator = httpTerminator.createHttpTerminator({ server });
+      childLogger.debug('Finished');
+    });
+  }
+
+  async function startup(opts) {
+    const childLogger = logger.where(__filename, 'startup');
+    childLogger.debug('Started');
+    // Create, load and run the express app
+    if (!app) {
+      app = express();
+      await expressLoader(app, opts);
+      await expressRunner(app, opts.port);
+    }
+    childLogger.debug('Finished');
+    return app;
+  }
+
+  async function shutdown() {
+    const childLogger = logger.where(__filename, 'shutdown');
+    childLogger.debug('Started');
+    // Terminate process and clean-up variables
+    await terminator.terminate();
+    app = null;
+    terminator = null;
+    childLogger.debug('Finished');
+  }
+
+  return { startup, shutdown };
+};

package/src/services/health.service.js

@@ -0,0 +1,52 @@
+'use strict';
+
+module.exports = ({ health, lru, config }) => {
+  const { CACHE_OPTIONS } = config.SERVER;
+  // Setup health checker
+  const healthCheck = new health.HealthChecker();
+  // Setup cache
+  const cache = new lru(CACHE_OPTIONS);
+
+  function buildCheckWithCache(key, check) {
+    cache.clear();
+    return async function () {
+      const checked = cache.get(key);
+      if (!checked) {
+        await check();
+        cache.set(key, true);
+      }
+    };
+  }
+
+  // function registerStartup(startup) {
+  //   healthCheck.registerStartupCheck(new health.StartupCheck("Startup Check", startup));
+  // }
+
+  function healthEndpoint() {
+    return health.HealthEndpoint(healthCheck);
+  }
+
+  function registerReadiness(readiness) {
+    const readinessWithCache = buildCheckWithCache('readiness', readiness);
+    healthCheck.registerReadinessCheck(new health.ReadinessCheck('Readiness Check', readinessWithCache));
+  }
+
+  function readinessEndpoint() {
+    return health.ReadinessEndpoint(healthCheck);
+  }
+
+  function registerLiveness(liveness) {
+    const livenessWithCache = buildCheckWithCache('liveness', liveness);
+    healthCheck.registerLivenessCheck(new health.LivenessCheck('Liveness Check', livenessWithCache));
+  }
+
+  function livenessEndpoint() {
+    return health.LivenessEndpoint(healthCheck);
+  }
+
+  function registerShutdown(shutdown) {
+    healthCheck.registerShutdownCheck(new health.ShutdownCheck('Shutdown Check', shutdown));
+  }
+
+  return { healthEndpoint, readinessEndpoint, registerReadiness, registerLiveness, livenessEndpoint, registerShutdown };
+};

package/src/services/server.service.js

@@ -1,75 +1,19 @@
 'use strict';
 
 module.exports = ({
-  express,
-  httpTerminator,
-  logger,
-  documentationLoader,
-  loggerLoader,
   authenticationMiddleware,
   authorisationMiddleware,
-  errorMiddleware,
-  middlewaresLoader,
-  probesLoader,
-  fallbackLoader,
+  expressService: { startup, shutdown },
+  healthService: { registerShutdown },
   jwtService,
   serverError,
 }) => {
-  let terminator = null; // I need your clothes, your boots and your motorcycle.
-
-  function run(app, port) {
-    const childLogger = logger.where(__filename, 'run');
-    childLogger.debug('Started');
-    return new Promise((resolve, reject) => {
-      if (!port) {
-        childLogger.warn('Missing port option');
-        return reject(new Error('Cannot start server without port option'));
-      }
-      const server = app.listen(port, () => {
-        childLogger.info(`Server listening on ${port}`);
-        return resolve();
-      });
-      terminator = httpTerminator.createHttpTerminator({ server });
-      childLogger.debug('Finished');
-    });
-  }
+  // Register shutdown to clean up any resources used by the express app
+  registerShutdown(shutdown);
 
   return {
-    async start(opts) {
-      const childLogger = logger.where(__filename, 'start');
-      childLogger.debug('Started');
-      // Create Express server
-      const app = express();
-      // Load probes
-      probesLoader(app, opts);
-      // Load useful middlewares
-      middlewaresLoader(app, opts);
-      // Load logger
-      await loggerLoader(app, opts);
-      // Load custom resources
-      if (opts.appLoader) {
-        await opts.appLoader(app);
-      }
-      // Load documentation
-      documentationLoader(app, opts);
-      // Load fallback routing
-      fallbackLoader(app, opts);
-      // Use error handler
-      if (opts.handleErrors) {
-        app.use(errorMiddleware(opts));
-      }
-      // Run the server
-      await run(app, opts.port);
-      childLogger.debug('Finished');
-      return app;
-    },
-    async stop() {
-      const childLogger = logger.where(__filename, 'stop');
-      childLogger.debug('Started');
-      // Terminate server process
-      await terminator.terminate();
-      childLogger.debug('Finished');
-    },
+    start: startup,
+    stop: shutdown,
     jwt: jwtService,
     errors: serverError,
     middlewares: {