Health check endpoint (#19)

Author: hanchiang

README.md

@@ -154,6 +154,7 @@ Each key contains 6 characters.
 * Check URL: Check where a shortened URL redirects to
 
 # TODO
+* XSS sanitisation
 * URL shortening: Check if URL is stored in the database. If it is, return the short url
 * Key generation: do not check against the database for existing short urls because there can still be a conflict due to concurrency. Let the database handle the conflict
 * Handle expired keys

src/controllers/index.ts

@@ -4,9 +4,41 @@ import {
   // Extend from this to define a valid schema type/interface
 } from 'express-joi-validation';
 import { ShortenUrlRequest } from './types';
-import { ShortenUrlSchema } from '../controllers/validators';
+import { ShortenUrlSchema, HealthCheckSchema } from '../controllers/validators';
 import { UrlShortenerServiceImpl } from '../services/impl/urlShortener';
 
+import { UrlDaoImpl } from '../db/postgres/dao/urlDao';
+import { Redis } from '../db/redis';
+import logger from '../utils/logger';
+
+export const healthCheck = async (
+  req: ValidatedRequest<HealthCheckSchema>,
+  res: Response
+) => {
+  const response: any = {
+    message: 'Service is up and running!',
+  };
+
+  if (req.query.postgres !== undefined) {
+    try {
+      await new UrlDaoImpl().healthCheck();
+      response.postgres = 'Postgres is up and running!';
+    } catch (e) {
+      logger.error(`postgres health check failed: ${e}`);
+    }
+  }
+  if (req.query.redis !== undefined) {
+    try {
+      await Redis.getInstance().ping();
+      response.redis = 'Redis is up and running!';
+    } catch (e) {
+      logger.error(`redis health check failed: ${e}`);
+    }
+  }
+
+  res.json(response);
+};
+
 export const shortenUrl = async (
   req: ValidatedRequest<ShortenUrlSchema>,
   res: Response

src/controllers/validators.ts

@@ -23,3 +23,15 @@ export interface ShortenUrlSchema extends ValidatedRequestSchema {
     alias?: string;
   };
 }
+
+export const healthCheckValidator = Joi.object({
+  postgres: Joi.string().min(0),
+  redis: Joi.string().min(0),
+});
+
+export interface HealthCheckSchema extends ValidatedRequestSchema {
+  [ContainerTypes.Query]: {
+    postgres?: string;
+    redis?: string;
+  };
+}

src/db/index.ts

@@ -16,12 +16,12 @@ export const initDb = () => {
 };
 
 export const closeDb = async () => {
-  await flushDb();
+  await clearDb();
   await knex.destroy();
   await Redis.close();
 };
 
-export const flushDb = async () => {
+export const clearDb = async () => {
   await knex('url').del();
   await Redis.flush();
 };

src/db/postgres/dao/urlDao.ts

@@ -1,12 +1,17 @@
+import { raw } from 'objection';
 import { Url } from '../models/url';
 
 export interface UrlDao {
+  healthCheck(): Promise<any>;
   insert(id: string, originalUrl: string): Promise<void>;
   findById(id: string): Promise<Url>;
   findByIds(ids: string[]): Promise<Url[]>;
 }
 
 export class UrlDaoImpl implements UrlDao {
+  public async healthCheck(): Promise<any> {
+    return Url.query().select(raw('1'));
+  }
   public async insert(id: string, originalUrl): Promise<void> {
     await Url.query().insert({
       id,

src/db/redis/index.ts

@@ -6,6 +6,7 @@ import config from '../../config';
 BluebirdPromise.promisifyAll(redis);
 
 export interface MemoryStore {
+  ping(): Promise<any>;
   setString(key: string, value: string, ttl?: number): Promise<void>;
   getString(key: string): Promise<string | null>;
 }
@@ -30,6 +31,10 @@ export class Redis implements MemoryStore {
     return redis.createClient(options);
   }
 
+  public async ping(): Promise<any> {
+    return this.conn.ping();
+  }
+
   public async setString(
     key: string,
     value: string,

src/routes/index.ts

@@ -2,7 +2,11 @@ import express, { Request, Response } from 'express';
 import cors from 'cors';
 import * as middlewares from '../middlewares';
 import * as controllers from '../controllers';
-import { shortenUrlValidator, validator } from '../controllers/validators';
+import {
+  validator,
+  shortenUrlValidator,
+  healthCheckValidator,
+} from '../controllers/validators';
 import { corsCheck } from '../utils/cors';
 
 const router = express.Router();
@@ -11,10 +15,19 @@ router.get(
   '/',
   cors(),
   middlewares.catchErrors(async (req: Request, res: Response) => {
-    res.json('Service is up and running!');
+    res.json({
+      message: 'Service is up and running!',
+    });
   })
 );
 
+router.get(
+  '/healthz',
+  cors(),
+  validator.query(healthCheckValidator),
+  middlewares.catchErrors(controllers.healthCheck)
+);
+
 router.options('/urls', corsCheck());
 router.post(
   '/urls',

src/utils/error.ts

@@ -1,6 +1,7 @@
 import { ThrowError, CustomError } from '../types/error';
 
 export enum ErrorCode {
+  OK = 200,
   BAD_REQUEST = 400,
   UNAUTHORIZED = 401,
   FORBIDDEN = 403,

test/dbhelper.ts

@@ -2,14 +2,14 @@ import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 chai.use(chaiAsPromised);
 
-import { initDb, closeDb, flushDb } from '../src/db';
+import { initDb, closeDb, clearDb } from '../src/db';
 
 before(async () => {
   await initDb();
 });
 
 afterEach(async () => {
-  await flushDb();
+  await clearDb();
 });
 
 after(async () => {

test/integration/healthCheck.ts

@@ -0,0 +1,38 @@
+import { expect } from 'chai';
+import { Server } from 'http';
+
+import app from '../../src/app';
+import config from '../config';
+import { ErrorCode } from '../../src/utils/error';
+import { sendRequest } from './utils/sendRequest';
+
+let server: Server;
+
+describe('Health check', () => {
+  beforeEach(async () => {
+    return new Promise((resolve) => {
+      server = app.listen(config.port, resolve);
+    });
+  });
+
+  afterEach(async () => {
+    return new Promise((resolve, reject) => {
+      server.close((err) => {
+        if (err) {
+          reject(err);
+        }
+        resolve();
+      });
+    });
+  });
+
+  it('Health check should succeed for postgres and redis', async () => {
+    const res = await sendRequest(server, 'get', `/healthz?postgres&redis`);
+    expect(res.status).to.equal(ErrorCode.OK);
+    expect(res.body.payload).to.eql({
+      message: 'Service is up and running!',
+      postgres: 'Postgres is up and running!',
+      redis: 'Redis is up and running!',
+    });
+  });
+});