feat: Adds error catcher and makes filter and sort optional.

Author: ryasmi

readme.md

@@ -5,7 +5,6 @@
 1. Install it with `npm i @js-entity-repos/express`.
 1. For each entity you will need to do the following.
     1. [Create an Entity interface](#entity-interface).
-    1. [Create a factory config](#factory-config).
     1. [Construct the facade](#construct-the-facade).
     1. [Use the facade](https://github.com/js-entity-repos/core/blob/master/docs/facade.md).
 
@@ -22,18 +21,18 @@ export interface TodoEntity extends Entity {
 }
 ```
 
-### Factory Config
-
-```ts
-import FactoryConfig from '@js-entity-repos/express/dist/FactoryConfig';
-
-const todoFactoryConfig: FactoryConfig<TodoEntity> = { service };
-```
-
 ### Construct the Facade
 
 ```ts
 import factory from '@js-entity-repos/express/dist/factory';
 
-const todosFacade = factory(todoFactoryConfig);
+const todosFacade = factory<TodoEntity>({
+  // Optional property that catches errors from handlers.
+  errorCatcher: (handler) => (req, res) => {
+    handler(req, res).catch((err) => {
+      res.status(500).send();
+    });
+  },
+  service,
+});
 ```

src/FacadeConfig.ts

@@ -1,6 +1,8 @@
 import Facade from '@js-entity-repos/core/dist/Facade';
 import Entity from '@js-entity-repos/core/dist/types/Entity';
+import ErrorCatcher from './utils/ErrorCatcher';
 
 export default interface FacadeConfig<E extends Entity> {
   readonly service: Facade<E>;
+  readonly errorCatcher: ErrorCatcher;
 }

src/FactoryConfig.ts

@@ -1,6 +1,8 @@
 import Facade from '@js-entity-repos/core/dist/Facade';
 import Entity from '@js-entity-repos/core/dist/types/Entity';
+import ErrorCatcher from './utils/ErrorCatcher';
 
 export default interface FactoryConfig<E extends Entity> {
   readonly service: Facade<E>;
+  readonly errorCatcher?: ErrorCatcher;
 }

src/factory.test.ts

@@ -4,8 +4,10 @@ sourceMapSupport.install();
 import axiosFactory from '@js-entity-repos/axios/dist/factory';
 import facadeTest from '@js-entity-repos/core/dist/tests';
 import { TestEntity } from '@js-entity-repos/core/dist/tests/utils/testEntity';
+import * as assert from 'assert';
 import axios from 'axios';
 import { config } from 'dotenv';
+import { BAD_REQUEST, OK } from 'http-status-codes';
 import 'mocha'; // tslint:disable-line:no-import-side-effect
 import createTestServer from './utils/createTestServer';
 config();
@@ -31,9 +33,25 @@ after(async () => {
   server.close();
 });
 
+const axiosClient = axios.create({
+  baseURL: `http://localhost:${testServerPort}${testServerRoute}`,
+});
+
 facadeTest(axiosFactory<TestEntity>({
-  axios: axios.create({
-    baseURL: `http://localhost:${testServerPort}${testServerRoute}`,
-  }),
+  axios: axiosClient,
   entityName: 'Test Entity',
 }));
+
+describe('facade', () => {
+  it('should not throw JSON error', async () => {
+    const response = await axiosClient.get('/');
+    assert.equal(response.status, OK);
+  });
+  it('should throw JSON error when using invalid filter', async () => {
+    await axiosClient.get('/?filter=invalid_json').then((response) => {
+      return { response };
+    }).catch((err) => {
+      assert.equal(err.response.status, BAD_REQUEST);
+    });
+  });
+});

src/factory.ts

@@ -11,9 +11,11 @@ import patchEntities from './functions/patchEntities';
 import removeEntities from './functions/removeEntities';
 import removeEntity from './functions/removeEntity';
 import replaceEntity from './functions/replaceEntity';
+import catchErrors from './utils/catchErrors';
 
 export default <E extends Entity>(factoryConfig: FactoryConfig<E>): Router => {
   const facadeConfig: FacadeConfig<E> = {
+    errorCatcher: catchErrors,
     ...factoryConfig,
   };
   const router = Router();

src/functions/countEntities.ts

@@ -3,11 +3,12 @@ import { Request, Response } from 'express';
 import { OK } from 'http-status-codes';
 import FacadeConfig from '../FacadeConfig';
 import catchErrors from '../utils/catchErrors';
+import getJsonQueryParam from '../utils/getJsonQueryParam';
 
 export default <E extends Entity>(config: FacadeConfig<E>) => {
   return catchErrors(async (req: Request, res: Response) => {
     const { count } = await config.service.countEntities({
-      filter: JSON.parse(req.query.filter),
+      filter: getJsonQueryParam(req.query, 'filter'),
     });
     res.status(OK).json(count);
   });

src/functions/getEntities.ts

@@ -3,17 +3,18 @@ import { Request, Response } from 'express';
 import { OK } from 'http-status-codes';
 import FacadeConfig from '../FacadeConfig';
 import catchErrors from '../utils/catchErrors';
+import getJsonQueryParam from '../utils/getJsonQueryParam';
 
 export default <E extends Entity>(config: FacadeConfig<E>) => {
   return catchErrors(async (req: Request, res: Response) => {
     const result = await config.service.getEntities({
-      filter: JSON.parse(req.query.filter),
+      filter: getJsonQueryParam(req.query, 'filter'),
       pagination: {
         cursor: req.query.cursor,
         forward: req.query.forward === 'true',
         limit: Number(req.query.limit),
       },
-      sort: JSON.parse(req.query.sort),
+      sort: getJsonQueryParam(req.query, 'sort'),
     });
     res.status(OK).json(result);
   });

src/functions/getEntity.ts

@@ -3,11 +3,12 @@ import { Request, Response } from 'express';
 import { OK } from 'http-status-codes';
 import FacadeConfig from '../FacadeConfig';
 import catchErrors from '../utils/catchErrors';
+import getJsonQueryParam from '../utils/getJsonQueryParam';
 
 export default <E extends Entity>(config: FacadeConfig<E>) => {
   return catchErrors(async (req: Request, res: Response) => {
     const { entity } = await config.service.getEntity({
-      filter: JSON.parse(req.query.filter),
+      filter: getJsonQueryParam(req.query, 'filter'),
       id: req.params.id,
     });
     res.status(OK).json(entity);

src/functions/patchEntities.ts

@@ -3,11 +3,12 @@ import { Request, Response } from 'express';
 import { OK } from 'http-status-codes';
 import FacadeConfig from '../FacadeConfig';
 import catchErrors from '../utils/catchErrors';
+import getJsonQueryParam from '../utils/getJsonQueryParam';
 
 export default <E extends Entity>(config: FacadeConfig<E>) => {
   return catchErrors(async (req: Request, res: Response) => {
     const { entity } = await config.service.patchEntity({
-      filter: JSON.parse(req.query.filter),
+      filter: getJsonQueryParam(req.query, 'filter'),
       id: req.params.id,
       patch: req.body,
     });

src/functions/removeEntities.ts

@@ -3,11 +3,12 @@ import { Request, Response } from 'express';
 import { NO_CONTENT } from 'http-status-codes';
 import FacadeConfig from '../FacadeConfig';
 import catchErrors from '../utils/catchErrors';
+import getJsonQueryParam from '../utils/getJsonQueryParam';
 
 export default <E extends Entity>(config: FacadeConfig<E>) => {
   return catchErrors(async (req: Request, res: Response) => {
     await config.service.removeEntities({
-      filter: JSON.parse(req.query.filter),
+      filter: getJsonQueryParam(req.query, 'filter'),
     });
     res.status(NO_CONTENT).send();
   });

src/functions/removeEntity.ts

@@ -3,11 +3,12 @@ import { Request, Response } from 'express';
 import { NO_CONTENT } from 'http-status-codes';
 import FacadeConfig from '../FacadeConfig';
 import catchErrors from '../utils/catchErrors';
+import getJsonQueryParam from '../utils/getJsonQueryParam';
 
 export default <E extends Entity>(config: FacadeConfig<E>) => {
   return catchErrors(async (req: Request, res: Response) => {
     await config.service.removeEntity({
-      filter: JSON.parse(req.query.filter),
+      filter: getJsonQueryParam(req.query, 'filter'),
       id: req.params.id,
     });
     res.status(NO_CONTENT).send();

src/functions/replaceEntity.ts

@@ -3,12 +3,13 @@ import { Request, Response } from 'express';
 import { OK } from 'http-status-codes';
 import FacadeConfig from '../FacadeConfig';
 import catchErrors from '../utils/catchErrors';
+import getJsonQueryParam from '../utils/getJsonQueryParam';
 
 export default <E extends Entity>(config: FacadeConfig<E>) => {
   return catchErrors(async (req: Request, res: Response) => {
     const { entity } = await config.service.replaceEntity({
       entity: req.body,
-      filter: JSON.parse(req.query.filter),
+      filter: getJsonQueryParam(req.query, 'filter'),
       id: req.params.id,
     });
     res.status(OK).json(entity);

src/utils/ErrorCatcher.ts

@@ -0,0 +1,7 @@
+import { Request, Response } from 'express';
+
+export type Handler = (req: Request, res: Response) => Promise<void>;
+
+type ErrorCatcher = (handler: Handler) => (req: Request, res: Response) => void;
+
+export default ErrorCatcher;

src/utils/JsonSyntaxError.ts

@@ -0,0 +1,8 @@
+// tslint:disable:no-class
+import { BaseError } from 'make-error';
+
+export default class JsonSyntaxError extends BaseError {
+  constructor(public path: string[]) {
+    super();
+  }
+}

src/utils/catchErrors.ts

@@ -1,21 +1,25 @@
 import ConflictingEntityError from '@js-entity-repos/core/dist/errors/ConflictingEntityError';
 import MissingEntityError from '@js-entity-repos/core/dist/errors/MissingEntityError';
-import { Request, Response } from 'express';
-import { CONFLICT, INTERNAL_SERVER_ERROR, NOT_FOUND } from 'http-status-codes';
+import { BAD_REQUEST, CONFLICT, INTERNAL_SERVER_ERROR, NOT_FOUND } from 'http-status-codes';
+import ErrorCatcher from './ErrorCatcher';
+import JsonSyntaxError from './JsonSyntaxError';
 
-export type Handler = (req: Request, res: Response) => Promise<void>;
-
-export default (handler: Handler) => {
-  return (req: Request, res: Response) => {
+const errorCatcher: ErrorCatcher = (handler) => {
+  return (req, res) => {
     handler(req, res).catch((err) => {
       if (err instanceof ConflictingEntityError) {
         return res.status(CONFLICT).send();
       }
       if (err instanceof MissingEntityError) {
         return res.status(NOT_FOUND).send();
       }
+      if (err instanceof JsonSyntaxError) {
+        return res.status(BAD_REQUEST).send();
+      }
       /* istanbul ignore next */
       return res.status(INTERNAL_SERVER_ERROR).send();
     });
   };
 };
+
+export default errorCatcher;

src/utils/getJsonQueryParam.ts

@@ -0,0 +1,6 @@
+import parseJson from './parseJson';
+
+export default (data: { readonly [k: string]: string | undefined }, paramName: string) => {
+  const paramValue = data[paramName];
+  return paramValue === undefined ? undefined : parseJson(paramValue, [paramName]);
+};

src/utils/parseJson.ts

@@ -0,0 +1,13 @@
+import JsonSyntaxError from './JsonSyntaxError';
+
+export default (data: string, path: string[]) => {
+  try {
+    return JSON.parse(data);
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new JsonSyntaxError(path);
+    }
+    /* istanbul ignore next */
+    throw err;
+  }
+};