@storyous/errors 1.0.0

package/README.md

@@ -0,0 +1,17 @@
+# `errors`
+
+## Usage
+
+``` typescript
+import { AppError } from '@storyous/errors';
+
+throw AppError.internal('Something went wrong.');
+
+...
+
+import { initErrHandler } from '@storyous/errors';
+
+const app = new Koa();
+app.use(initErrHandler(logger));
+
+```

package/__tests__/appError.test.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const mocha_1 = require("mocha");
+const lib_1 = require("../lib");
+(0, mocha_1.describe)('packages/errors/AppError', () => {
+    (0, mocha_1.it)('should receive Error with additional Meta', () => {
+        const err = new lib_1.AppError('');
+        err.setMeta({ foo: 'bar' });
+        assert_1.default.deepStrictEqual(err.meta, { foo: 'bar' });
+    });
+    (0, mocha_1.it)('should receive NotFound Error', () => {
+        const err = lib_1.AppError.notFound('Ups ...', { foo: 'bar' });
+        assert_1.default.deepStrictEqual(err.message, 'Not found: Ups ...');
+        assert_1.default.deepStrictEqual(err.meta, { foo: 'bar', code: 404, httpStatus: 404 });
+    });
+    (0, mocha_1.it)('should receive NotFound Error without custom message', () => {
+        const err = lib_1.AppError.notFound();
+        assert_1.default.deepStrictEqual(err.message, 'Not found');
+        assert_1.default.deepStrictEqual(err.meta, { code: 404, httpStatus: 404 });
+    });
+    (0, mocha_1.it)('should receive BadRequest Error', () => {
+        const err = lib_1.AppError.badRequest('Ups ...', { foo: 'bar' });
+        assert_1.default.deepStrictEqual(err.message, 'Bad request: Ups ...');
+        assert_1.default.deepStrictEqual(err.meta, { foo: 'bar', code: 400, httpStatus: 400 });
+    });
+    (0, mocha_1.it)('should receive BadRequest Error without custom message', () => {
+        const err = lib_1.AppError.badRequest();
+        assert_1.default.deepStrictEqual(err.message, 'Bad request');
+        assert_1.default.deepStrictEqual(err.meta, { code: 400, httpStatus: 400 });
+    });
+    (0, mocha_1.it)('should receive ConcurrentRequest Error', () => {
+        const err = lib_1.AppError.concurrentRequest('Ups ...', { foo: 'bar' });
+        assert_1.default.deepStrictEqual(err.message, 'Concurrent request: Ups ...');
+        assert_1.default.deepStrictEqual(err.meta, { foo: 'bar', code: 409, httpStatus: 409 });
+    });
+    (0, mocha_1.it)('should receive ConcurrentRequest Error without custom message', () => {
+        const err = lib_1.AppError.concurrentRequest();
+        assert_1.default.deepStrictEqual(err.message, 'Concurrent request');
+        assert_1.default.deepStrictEqual(err.meta, { code: 409, httpStatus: 409 });
+    });
+    (0, mocha_1.it)('should receive is ConcurrentRequest Error', () => {
+        const err = lib_1.AppError.concurrentRequest();
+        assert_1.default.deepStrictEqual(lib_1.AppError.isConcurrentRequestError(err), true);
+    });
+    (0, mocha_1.it)('should receive Internal Error', () => {
+        const err = lib_1.AppError.internal('Ups ...', { foo: 'bar' });
+        assert_1.default.deepStrictEqual(err.message, 'Internal: Ups ...');
+        assert_1.default.deepStrictEqual(err.meta, { foo: 'bar', code: 500, httpStatus: 500 });
+    });
+    (0, mocha_1.it)('should receive Internal Error without custom message', () => {
+        const err = lib_1.AppError.internal();
+        assert_1.default.deepStrictEqual(err.message, 'Internal');
+        assert_1.default.deepStrictEqual(err.meta, { code: 500, httpStatus: 500 });
+    });
+    (0, mocha_1.it)('should receive Unauthorized Error', () => {
+        const err = lib_1.AppError.unauthorized('Ups ...', { foo: 'bar' });
+        assert_1.default.deepStrictEqual(err.message, 'Unauthorized: Ups ...');
+        assert_1.default.deepStrictEqual(err.meta, { foo: 'bar', code: 401, httpStatus: 401 });
+    });
+    (0, mocha_1.it)('should receive Unauthorized Error without custom message', () => {
+        const err = lib_1.AppError.unauthorized();
+        assert_1.default.deepStrictEqual(err.message, 'Unauthorized');
+        assert_1.default.deepStrictEqual(err.meta, { code: 401, httpStatus: 401 });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/__tests__/appError.test.ts

@@ -0,0 +1,77 @@
+import assert from 'assert';
+import { describe, it } from 'mocha';
+import { AppError } from '../lib';
+
+describe('packages/errors/AppError', () => {
+
+    it('should receive Error with additional Meta', () => {
+        const err = new AppError('');
+        err.setMeta({ foo: 'bar' });
+        assert.deepStrictEqual(err.meta, { foo: 'bar' });
+    });
+
+    it('should receive NotFound Error', () => {
+        const err = AppError.notFound('Ups ...', { foo: 'bar' });
+        assert.deepStrictEqual(err.message, 'Not found: Ups ...');
+        assert.deepStrictEqual(err.meta, { foo: 'bar', code: 404, httpStatus: 404 });
+    });
+
+    it('should receive NotFound Error without custom message', () => {
+        const err = AppError.notFound();
+        assert.deepStrictEqual(err.message, 'Not found');
+        assert.deepStrictEqual(err.meta, { code: 404, httpStatus: 404 });
+    });
+
+    it('should receive BadRequest Error', () => {
+        const err = AppError.badRequest('Ups ...', { foo: 'bar' });
+        assert.deepStrictEqual(err.message, 'Bad request: Ups ...');
+        assert.deepStrictEqual(err.meta, { foo: 'bar', code: 400, httpStatus: 400 });
+    });
+
+    it('should receive BadRequest Error without custom message', () => {
+        const err = AppError.badRequest();
+        assert.deepStrictEqual(err.message, 'Bad request');
+        assert.deepStrictEqual(err.meta, { code: 400, httpStatus: 400 });
+    });
+
+    it('should receive ConcurrentRequest Error', () => {
+        const err = AppError.concurrentRequest('Ups ...', { foo: 'bar' });
+        assert.deepStrictEqual(err.message, 'Concurrent request: Ups ...');
+        assert.deepStrictEqual(err.meta, { foo: 'bar', code: 409, httpStatus: 409 });
+    });
+
+    it('should receive ConcurrentRequest Error without custom message', () => {
+        const err = AppError.concurrentRequest();
+        assert.deepStrictEqual(err.message, 'Concurrent request');
+        assert.deepStrictEqual(err.meta, { code: 409, httpStatus: 409 });
+    });
+
+    it('should receive is ConcurrentRequest Error', () => {
+        const err = AppError.concurrentRequest();
+        assert.deepStrictEqual(AppError.isConcurrentRequestError(err), true);
+    });
+
+    it('should receive Internal Error', () => {
+        const err = AppError.internal('Ups ...', { foo: 'bar' });
+        assert.deepStrictEqual(err.message, 'Internal: Ups ...');
+        assert.deepStrictEqual(err.meta, { foo: 'bar', code: 500, httpStatus: 500 });
+    });
+
+    it('should receive Internal Error without custom message', () => {
+        const err = AppError.internal();
+        assert.deepStrictEqual(err.message, 'Internal');
+        assert.deepStrictEqual(err.meta, { code: 500, httpStatus: 500 });
+    });
+
+    it('should receive Unauthorized Error', () => {
+        const err = AppError.unauthorized('Ups ...', { foo: 'bar' });
+        assert.deepStrictEqual(err.message, 'Unauthorized: Ups ...');
+        assert.deepStrictEqual(err.meta, { foo: 'bar', code: 401, httpStatus: 401 });
+    });
+
+    it('should receive Unauthorized Error without custom message', () => {
+        const err = AppError.unauthorized();
+        assert.deepStrictEqual(err.message, 'Unauthorized');
+        assert.deepStrictEqual(err.meta, { code: 401, httpStatus: 401 });
+    });
+});

package/__tests__/errorHandler.test.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_utils_1 = __importDefault(require("@storyous/test-utils"));
+const koa_1 = __importDefault(require("koa"));
+const koa_router_1 = __importDefault(require("koa-router"));
+const mocha_1 = require("mocha");
+const winston_1 = require("winston");
+const lib_1 = require("../lib");
+const app = new koa_1.default();
+app.use((0, lib_1.initErrHandler)((0, winston_1.createLogger)()));
+const router = new koa_router_1.default();
+router.get('/internal', () => {
+    throw lib_1.AppError.internal();
+});
+router.get('/notFound', () => {
+    throw lib_1.AppError.notFound();
+});
+router.get('/err', () => {
+    throw new Error();
+});
+app.use(router.routes());
+(0, mocha_1.describe)('packages/errors/ErrorHandler', () => {
+    test_utils_1.default.init(() => app);
+    (0, mocha_1.it)('should badRequest', async () => {
+        await test_utils_1.default.request().get('/').expect(404);
+    });
+    (0, mocha_1.it)('should internal error thrown', async () => {
+        await test_utils_1.default.request().get('/internal').expect(500);
+    });
+    (0, mocha_1.it)('should notFound error thrown', async () => {
+        await test_utils_1.default.request().get('/notFound').expect(404);
+    });
+    (0, mocha_1.it)('should error thrown', async () => {
+        await test_utils_1.default.request().get('/err').expect(500);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JIYW5kbGVyLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJlcnJvckhhbmRsZXIudGVzdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLHNFQUE2QztBQUM3Qyw4Q0FBc0I7QUFDdEIsNERBQW1DO0FBQ25DLGlDQUFxQztBQUNyQyxxQ0FBdUM7QUFDdkMsZ0NBQWtEO0FBRWxELE1BQU0sR0FBRyxHQUFHLElBQUksYUFBRyxFQUFFLENBQUM7QUFDdEIsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFBLG9CQUFjLEVBQUMsSUFBQSxzQkFBWSxHQUFFLENBQUMsQ0FBQyxDQUFDO0FBQ3hDLE1BQU0sTUFBTSxHQUFHLElBQUksb0JBQVMsRUFBRSxDQUFDO0FBRS9CLE1BQU0sQ0FBQyxHQUFHLENBQUMsV0FBVyxFQUFFLEdBQUcsRUFBRTtJQUN6QixNQUFNLGNBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztBQUM5QixDQUFDLENBQUMsQ0FBQztBQUVILE1BQU0sQ0FBQyxHQUFHLENBQUMsV0FBVyxFQUFFLEdBQUcsRUFBRTtJQUN6QixNQUFNLGNBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztBQUM5QixDQUFDLENBQUMsQ0FBQztBQUVILE1BQU0sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLEdBQUcsRUFBRTtJQUNwQixNQUFNLElBQUksS0FBSyxFQUFFLENBQUM7QUFDdEIsQ0FBQyxDQUFDLENBQUM7QUFFSCxHQUFHLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO0FBRXpCLElBQUEsZ0JBQVEsRUFBQyw4QkFBOEIsRUFBRSxHQUFHLEVBQUU7SUFDMUMsb0JBQVMsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUM7SUFFMUIsSUFBQSxVQUFFLEVBQUMsbUJBQW1CLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDL0IsTUFBTSxvQkFBUyxDQUFDLE9BQU8sRUFBRSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbkQsQ0FBQyxDQUFDLENBQUM7SUFFSCxJQUFBLFVBQUUsRUFBQyw4QkFBOEIsRUFBRSxLQUFLLElBQUksRUFBRTtRQUMxQyxNQUFNLG9CQUFTLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMzRCxDQUFDLENBQUMsQ0FBQztJQUVILElBQUEsVUFBRSxFQUFDLDhCQUE4QixFQUFFLEtBQUssSUFBSSxFQUFFO1FBQzFDLE1BQU0sb0JBQVMsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzNELENBQUMsQ0FBQyxDQUFDO0lBRUgsSUFBQSxVQUFFLEVBQUMscUJBQXFCLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDakMsTUFBTSxvQkFBUyxDQUFDLE9BQU8sRUFBRSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDdEQsQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDLENBQUMsQ0FBQyJ9

package/__tests__/errorHandler.test.ts

@@ -0,0 +1,44 @@
+import testUtils from '@storyous/test-utils';
+import Koa from 'koa';
+import KoaRouter from 'koa-router';
+import { describe, it } from 'mocha';
+import { createLogger } from 'winston';
+import { AppError, initErrHandler } from '../lib';
+
+const app = new Koa();
+app.use(initErrHandler(createLogger()));
+const router = new KoaRouter();
+
+router.get('/internal', () => {
+    throw AppError.internal();
+});
+
+router.get('/notFound', () => {
+    throw AppError.notFound();
+});
+
+router.get('/err', () => {
+    throw new Error();
+});
+
+app.use(router.routes());
+
+describe('packages/errors/ErrorHandler', () => {
+    testUtils.init(() => app);
+
+    it('should badRequest', async () => {
+        await testUtils.request().get('/').expect(404);
+    });
+
+    it('should internal error thrown', async () => {
+        await testUtils.request().get('/internal').expect(500);
+    });
+
+    it('should notFound error thrown', async () => {
+        await testUtils.request().get('/notFound').expect(404);
+    });
+
+    it('should error thrown', async () => {
+        await testUtils.request().get('/err').expect(500);
+    });
+});

package/lib/appError.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AppError extends Error {
+    constructor(message, meta) {
+        super();
+        this.message = message;
+        this.code = (meta && meta.code) || null;
+        this.httpStatus = (meta && meta.httpStatus) || 500;
+        this.meta = meta || undefined;
+        this.redirect = undefined;
+    }
+    setMeta(meta) {
+        this.meta = meta;
+        return this;
+    }
+    static purifyStack(error) {
+        error.stack = error?.stack?.split('\n').filter((line, index) => index !== 1).join('\n');
+        return error;
+    }
+    static notFound(message, meta) {
+        let allMessage = 'Not found';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+        const error = new AppError(allMessage, ({
+            code: 404,
+            httpStatus: 404,
+            ...meta,
+        }));
+        return AppError.purifyStack(error);
+    }
+    static badRequest(message, meta) {
+        let allMessage = 'Bad request';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+        const error = new AppError(allMessage, ({
+            code: 400,
+            httpStatus: 400,
+            ...meta,
+        }));
+        return AppError.purifyStack(error);
+    }
+    static concurrentRequest(message, meta) {
+        let allMessage = 'Concurrent request';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+        const error = new AppError(allMessage, ({
+            code: 409,
+            httpStatus: 409,
+            ...meta,
+        }));
+        return AppError.purifyStack(error);
+    }
+    static internal(message, meta) {
+        let allMessage = 'Internal';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+        const error = new AppError(allMessage, ({
+            code: 500,
+            httpStatus: 500,
+            ...meta,
+        }));
+        return AppError.purifyStack(error);
+    }
+    static unauthorized(message, meta) {
+        let allMessage = 'Unauthorized';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+        const error = new AppError(allMessage, ({
+            code: 401,
+            httpStatus: 401,
+            ...meta,
+        }));
+        return AppError.purifyStack(error);
+    }
+    static isConcurrentRequestError(err) {
+        return err instanceof AppError && err.code === 409 && /^Concurrent request/.test(err.message);
+    }
+}
+exports.default = AppError;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/appError.ts

@@ -0,0 +1,117 @@
+export default class AppError extends Error {
+
+    public code?: number;
+
+    public httpStatus: number|string;
+
+    public meta?: Record<string, any>;
+
+    public redirect?: string;
+
+    constructor (message: string, meta?: any) {
+        super();
+
+        this.message = message;
+
+        this.code = (meta && meta.code) || null;
+
+        this.httpStatus = (meta && meta.httpStatus) || 500;
+
+        this.meta = meta || undefined;
+
+        this.redirect = undefined;
+    }
+
+    setMeta (meta: Record<string, any>): AppError {
+        this.meta = meta;
+
+        return this;
+    }
+
+    static purifyStack (error: AppError): AppError {
+        error.stack = error?.stack?.split('\n').filter((line, index) => index !== 1).join('\n');
+
+        return error;
+    }
+
+    static notFound (message?: string, meta?: Record<string, any>): AppError {
+
+        let allMessage = 'Not found';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+
+        const error = new AppError(allMessage, ({
+            code: 404,
+            httpStatus: 404,
+            ...meta,
+        }));
+
+        return AppError.purifyStack(error);
+    }
+
+    static badRequest (message?: string, meta?: Record<string, any>): AppError {
+        let allMessage = 'Bad request';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+
+        const error = new AppError(allMessage, ({
+            code: 400,
+            httpStatus: 400,
+            ...meta,
+        }));
+
+        return AppError.purifyStack(error);
+    }
+
+    static concurrentRequest (message?: string, meta?: Record<string, any>): AppError {
+        let allMessage = 'Concurrent request';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+
+        const error = new AppError(allMessage, ({
+            code: 409,
+            httpStatus: 409,
+            ...meta,
+        }));
+
+        return AppError.purifyStack(error);
+    }
+
+    static internal (message?: string, meta?: Record<string, any>): AppError {
+        let allMessage = 'Internal';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+
+        const error = new AppError(allMessage, ({
+            code: 500,
+            httpStatus: 500,
+            ...meta,
+        }));
+
+        return AppError.purifyStack(error);
+    }
+
+    static unauthorized (message?: string, meta?: Record<string, any>): AppError {
+        let allMessage = 'Unauthorized';
+        if (message) {
+            allMessage += `: ${message}`;
+        }
+
+        const error = new AppError(allMessage, ({
+            code: 401,
+            httpStatus: 401,
+            ...meta,
+        }));
+
+        return AppError.purifyStack(error);
+    }
+
+    static isConcurrentRequestError (err: Error): boolean {
+        return err instanceof AppError && err.code === 409 && /^Concurrent request/.test(err.message);
+    }
+
+}

package/lib/errorHandler.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const appError_1 = __importDefault(require("./appError"));
+const initErrHandler = (log) => async function (ctx, next) {
+    try {
+        await next();
+    }
+    catch (originalError) {
+        let err = originalError;
+        if (!(err instanceof appError_1.default)) {
+            if (err instanceof Error) {
+                // @ts-ignore
+                const redirect = err.redirect || null;
+                err = new appError_1.default(`${err.name}: ${err.message}`);
+                err.redirect = redirect;
+            }
+            else if (typeof err === 'string') {
+                err = new appError_1.default(err);
+            }
+            else {
+                err = new appError_1.default('Unknown error');
+            }
+            err.stack = originalError.stack;
+        }
+        const metaData = {
+            httpStatus: err.httpStatus || 500,
+            url: ctx.request.originalUrl,
+            query: ctx.request.query,
+            method: ctx.req.method,
+            remoteAddress: ctx.get('x-forwarded-for') || ctx.req.connection.remoteAddress,
+        };
+        if (err.code) {
+            metaData.code = err.code;
+        }
+        if (!ctx.request.is('multipart/*')) {
+            metaData.body = ctx.request.body;
+        }
+        if (ctx.req.headers && ctx.req.headers.referer) {
+            metaData.referer = ctx.req.headers.referer;
+        }
+        if (err.redirect) {
+            metaData.redirect = err.redirect;
+        }
+        const originalMeta = err.meta;
+        if (!(0, lodash_1.isEmpty)(err.meta)) {
+            metaData.meta = err.meta;
+        }
+        err.setMeta(metaData);
+        if (err.httpStatus === 404 || err.httpStatus === 401 || err.httpStatus === 429) {
+            log.warn(err);
+        }
+        else if (err.httpStatus === 500 || err.httpStatus === 408) {
+            log.error(err);
+        }
+        else {
+            log.info(err);
+        }
+        ctx.body = {
+            code: err.code,
+            message: err.message,
+            ...(0, lodash_1.pick)(originalMeta, err.publicFields || []),
+        };
+        ctx.status = err.httpStatus;
+    }
+};
+exports.default = initErrHandler;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/errorHandler.ts

@@ -0,0 +1,81 @@
+import { isEmpty, pick } from 'lodash';
+import { Logger } from 'winston';
+import AppError from './appError';
+
+const initErrHandler = (log: Logger) => async function (ctx: any, next: Function) {
+    try {
+        await next();
+    } catch (originalError:any) {
+
+        let err: any = originalError;
+
+        if (!(err instanceof AppError)) {
+
+            if (err instanceof Error) {
+                // @ts-ignore
+                const redirect = err.redirect || null;
+                err = new AppError(`${err.name}: ${err.message}`);
+                err.redirect = redirect;
+
+            } else if (typeof err === 'string') {
+                err = new AppError(err);
+
+            } else {
+                err = new AppError('Unknown error');
+            }
+
+            err.stack = originalError.stack;
+        }
+
+        const metaData: any = {
+            httpStatus: err.httpStatus || 500,
+            url: ctx.request.originalUrl,
+            query: ctx.request.query,
+            method: ctx.req.method,
+            remoteAddress: ctx.get('x-forwarded-for') || ctx.req.connection.remoteAddress,
+        };
+
+        if (err.code) {
+            metaData.code = err.code;
+        }
+
+        if (!ctx.request.is('multipart/*')) {
+            metaData.body = ctx.request.body;
+        }
+
+        if (ctx.req.headers && ctx.req.headers.referer) {
+            metaData.referer = ctx.req.headers.referer;
+        }
+
+        if (err.redirect) {
+            metaData.redirect = err.redirect;
+        }
+
+        const originalMeta = err.meta;
+
+        if (!isEmpty(err.meta)) {
+            metaData.meta = err.meta;
+        }
+
+        err.setMeta(metaData);
+
+        if (err.httpStatus === 404 || err.httpStatus === 401 || err.httpStatus === 429) {
+            log.warn(err);
+
+        } else if (err.httpStatus === 500 || err.httpStatus === 408) {
+            log.error(err);
+
+        } else {
+            log.info(err);
+        }
+
+        ctx.body = {
+            code: err.code,
+            message: err.message,
+            ...pick(originalMeta, err.publicFields || []),
+        };
+        ctx.status = err.httpStatus;
+    }
+};
+
+export default initErrHandler;

package/lib/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initErrHandler = exports.AppError = void 0;
+const appError_1 = __importDefault(require("./appError"));
+exports.AppError = appError_1.default;
+const errorHandler_1 = __importDefault(require("./errorHandler"));
+exports.initErrHandler = errorHandler_1.default;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSwwREFBa0M7QUFHekIsbUJBSEYsa0JBQVEsQ0FHRTtBQUZqQixrRUFBNEM7QUFFekIseUJBRlosc0JBQWMsQ0FFWSJ9

package/lib/index.ts

@@ -0,0 +1,4 @@
+import AppError from './appError';
+import initErrHandler from './errorHandler';
+
+export { AppError, initErrHandler };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@storyous/errors",
+  "version": "1.0.0",
+  "description": "",
+  "homepage": "https://github.com/Storyous/mono-utils#readme",
+  "license": "ISC",
+  "main": "lib/index.ts",
+  "scripts": {
+    "start": "tsc",
+    "build": "tsc && npm publish"
+  },
+  "mocha": {
+    "recursive": true,
+    "timeout": 15000,
+    "extension": [
+      "ts"
+    ],
+    "exit": true,
+    "require": "ts-node/register"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Storyous/mono-utils.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Storyous/mono-utils/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "winston": "^3.7.2"
+  },
+  "devDependencies": {
+    "@storyous/test-utils": "^1.0.0"
+  },
+  "gitHead": "2ba0209d33ac7cd2fd1136a9123134f656750102"
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "extends": "../../tsconfig.json",
+
+    "include": [
+        "lib",
+        "__tests__"
+    ]
+}