@openstax/ts-utils 1.33.1 → 1.34.0

package/packages/utils/src/guards/index.spec.ts

@@ -0,0 +1,58 @@
+import { ifDefined, isDefined, isNotNull, isNumber, isPlainObject } from '.';
+
+describe('ifDefined', () => {
+  it('returns input', () => {
+    expect(ifDefined('input', 'default')).toBe('input');
+  });
+  it('returns default', () => {
+    expect(ifDefined(undefined, 'default')).toBe('default');
+  });
+});
+
+describe('isNumber', () => {
+  it('returns true', () => {
+    expect(isNumber(5)).toBe(true);
+  });
+  it('returns false', () => {
+    expect(isNumber('5')).toBe(false);
+  });
+});
+
+describe('isDefined', () => {
+  it('is defined', () => {
+    expect(isDefined('asdf')).toBe(true);
+  });
+  it('null is defined', () => {
+    expect(isDefined(null)).toBe(true);
+  });
+  it('false is defined', () => {
+    expect(isDefined(false)).toBe(true);
+  });
+  it('isn\'t defined', () => {
+    expect(isDefined(undefined)).toBe(false);
+  });
+});
+
+describe('isNotNull', () => {
+  it('is not null', () => {
+    expect(isNotNull('asdf')).toBe(true);
+  });
+  it('null is null', () => {
+    expect(isNotNull(null)).toBe(false);
+  });
+  it('false is not null', () => {
+    expect(isNotNull(false)).toBe(true);
+  });
+  it('undefined is not null', () => {
+    expect(isNotNull(undefined)).toBe(true);
+  });
+});
+
+describe('isPlainObject', () => {
+  it('is plain', () => {
+    expect(isPlainObject({})).toBe(true);
+  });
+  it('is not plain', () => {
+    expect(isPlainObject(new Error())).toBe(false);
+  });
+});

package/{dist/esm/guards/index.d.ts → packages/utils/src/guards/index.ts}

@@ -5,7 +5,8 @@
  *
  * `const result = (array as Array<string | undefined>).filter(isDefined);`
  */
-export declare const isDefined: <X>(x: X) => x is Exclude<X, undefined>;
+export const isDefined = <X>(x: X): x is Exclude<X, undefined> => x !== undefined;
+
 /**
  * checks if a thing is not null. while often easy to do with a simple if statement,
  * in certain situations the guard is required and its nice to have one pre-defined.
@@ -13,7 +14,8 @@ export declare const isDefined: <X>(x: X) => x is Exclude<X, undefined>;
  *
  * `const result = (array as Array<string | null>).filter(isNotNull);`
  */
-export declare const isNotNull: <X>(x: X) => x is Exclude<X, null>;
+export const isNotNull = <X>(x: X): x is Exclude<X, null> => x !== null;
+
 /**
  * checks if a thing is a number. while often easy to do with a simple if statement, in certain
  * situations the guard is required and its nice to have one pre-defined. E.g. in the following
@@ -21,18 +23,19 @@ export declare const isNotNull: <X>(x: X) => x is Exclude<X, null>;
  *
  * `const result = (array as Array<number | undefined>).filter(isNumber);`
  */
-export declare const isNumber: (x: any) => x is number;
+export const isNumber = (x: any): x is number => typeof x === 'number';
+
 /**
  * a guard for plain old javascript objects that are not based on some other prototype,
  * for example making them safe to JSON stringify and stuff
  */
-export declare const isPlainObject: (thing: any) => thing is {
-    [key: string]: any;
-};
+export const isPlainObject = (thing: any): thing is {[key: string]: any} =>
+  thing instanceof Object && thing.__proto__.constructor.name === 'Object';
+
 /**
  * if the first thing is defined it uses it, otherwise it returns the second thing. this isn't
  * really a guard its just a way to provide a default value without creating a coverage branch.
  *
  * @example const valueWithDefault = ifDefined(thing, 'default value')
  */
-export declare const ifDefined: <X, D>(x: X, d: D) => D | Exclude<X, undefined>;
+export const ifDefined = <X, D>(x: X, d: D) => isDefined(x) ? x : d;

package/packages/utils/src/index.spec.ts

@@ -0,0 +1,471 @@
+import { retryWithDelay } from './misc/helpers';
+import { coerceArray, flow, fnIf, getKeyValue, getKeyValueOr, hashValue, mapFind, memoize, merge, once, partitionSequence, putKeyValue, roundToPrecision, tuple } from '.';
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('mapFind', () => {
+  it('finds first result', () => {
+    const array = [{a: 0}, {a: 2}, {a: 0}, {a: 1}];
+    const result = mapFind(array, x => x.a);
+
+    expect(result).toBe(2);
+  });
+
+  it('finds first result with predicate', () => {
+    const array = [{a: 0}, {a: 2}, {a: 0}, {a: 1}];
+    const result = mapFind(array, x => x.a, x => x === 1);
+
+    expect(result).toBe(1);
+  });
+
+  it('fails to find result', () => {
+    const array: {a: number; b?: number}[] = [{a: 0}, {a: 2}, {a: 0}, {a: 1}];
+    const result = mapFind(array, x => x.b);
+
+    expect(result).toBeUndefined();
+  });
+
+  it('fails to find result with predicate', () => {
+    const array = [{a: 0}, {a: 2}, {a: 0}, {a: 1}];
+    const result = mapFind(array, x => x.a, x => x === 3);
+
+    expect(result).toBeUndefined();
+  });
+});
+
+describe('hashValue', () => {
+  it('hashes a string', () => {
+    expect(hashValue('a string')).toEqual(expect.any(String));
+    expect(hashValue('a string')).toEqual(hashValue('a string'));
+    expect(hashValue('a string')).not.toEqual(hashValue('a different string'));
+  });
+  it('hashes a boolean', () => {
+    expect(hashValue(true)).toEqual(expect.any(String));
+    expect(hashValue(true)).toEqual(hashValue(true));
+    expect(hashValue(true)).not.toEqual(hashValue(false));
+  });
+  it('hashes a number', () => {
+    expect(hashValue(1)).toEqual(expect.any(String));
+    expect(hashValue(1)).toEqual(hashValue(1));
+    expect(hashValue(1)).not.toEqual(hashValue(2));
+  });
+  it('hashes a list', () => {
+    expect(hashValue([1,2])).toEqual(expect.any(String));
+    expect(hashValue([1,2])).toEqual(hashValue([1,2]));
+    expect(hashValue([1,2])).not.toEqual(hashValue([2,3]));
+  });
+  it('hashes an object', () => {
+    expect(hashValue({one: 'one'})).toEqual(expect.any(String));
+    expect(hashValue({one: 'one'})).toEqual(hashValue({one: 'one'}));
+    expect(hashValue({one: 'one'})).not.toEqual(hashValue({two: 'two'}));
+    expect(hashValue({one: 'one', two: 'two'})).toEqual(hashValue({two: 'two', one: 'one'}));
+  });
+});
+
+describe('object access', () => {
+  it('gets key value', () => {
+    expect(getKeyValue('theKey')({theKey: 'theValue'})).toBe('theValue');
+  });
+  it('gets key value with default', () => {
+    expect(getKeyValueOr('theKey', 'defaultValue')({theKey: 'theValue'})).toBe('theValue');
+  });
+  it('gets default value', () => {
+    expect(getKeyValueOr('theKey', 'defaultValue')({theKey: null})).toBe('defaultValue');
+  });
+  it('puts key value', () => {
+    expect(putKeyValue('theKey')({theKey: 'theValue'}, 'newValue')).toEqual({theKey: 'newValue'});
+  });
+});
+
+describe('once', () => {
+  it('calls once', () => {
+    const spy = jest.fn(x => x);
+    const onceSpy = once(spy);
+
+    expect(onceSpy(5)).toBe(5);
+    expect(onceSpy(1)).toBe(5);
+    expect(onceSpy(7)).toBe(5);
+    expect(onceSpy(2)).toBe(5);
+
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls once when result is falsy', () => {
+    const spy = jest.fn(_x => null);
+    const onceSpy = once(spy);
+
+    expect(onceSpy(5)).toBeNull();
+    expect(onceSpy(1)).toBeNull();
+    expect(onceSpy(7)).toBeNull();
+    expect(onceSpy(2)).toBeNull();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it('calls multiple times when the function throws', () => {
+    const spy = jest.fn((_x) => { throw new Error('Bad Request'); });
+    const onceSpy = once(spy);
+
+    expect(() => onceSpy(1)).toThrow('Bad Request');
+    expect(() => onceSpy(2)).toThrow('Bad Request');
+
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+
+  it('calls multiple times when the function returns a Promise that rejects (when it rejects)', async() => {
+    const spy = jest.fn(async(_x) => { throw new Error('Bad Request'); });
+    const onceSpy = once(spy);
+
+    const promise1 = onceSpy(1);
+    const promise2 = onceSpy(2);
+
+    await expect(promise1).rejects.toThrow('Bad Request');
+    await expect(promise2).rejects.toThrow('Bad Request');
+
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    await expect(onceSpy(3)).rejects.toThrow('Bad Request');
+
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe('merge', () => {
+  it('merges simple object', () => {
+    expect(merge({key1: 'value1'}, {key2: 'value2'})).toEqual({key1: 'value1', key2: 'value2'});
+  });
+
+  it('merges objects recursively', () => {
+    expect(merge(
+      {key1: 'value1', subObject: {subKey1: 'subValue1'}},
+      {key2: 'value2', subObject: {subKey2: 'subValue2'}}
+    )).toEqual({key1: 'value1', key2: 'value2', subObject: {subKey1: 'subValue1', subKey2: 'subValue2'}});
+  });
+
+  it('merges arrays recursively', () => {
+    expect(merge(
+      {key1: 'value1', subArray: ['subValue1']},
+      {key2: 'value2', subArray: ['subValue2']}
+    )).toEqual({key1: 'value1', key2: 'value2', subArray: ['subValue1', 'subValue2']});
+  });
+
+  it('last value for common key wins', () => {
+    expect(merge({key: 'value1'}, {key: 'value2'})).toEqual({key: 'value2'});
+  });
+
+  it('object references work when unmerged', () => {
+    const subObject1 = {subKey1: 'subValue1'};
+    const subObject2 = {subKey2: 'subValue2'};
+    const merged = merge(
+      {key1: 'value1', subObject1, subObject: subObject1},
+      {key2: 'value2', subObject2, subObject: subObject2}
+    );
+
+    expect(merged.subObject1).toBe(subObject1);
+    expect(merged.subObject2).toBe(subObject2);
+    expect(merged.subObject).not.toBe(subObject1);
+    expect(merged.subObject).not.toBe(subObject2);
+  });
+});
+
+describe('tuple', () => {
+  it('works', () => {
+    expect(tuple(1,2)).toEqual([1,2]);
+  });
+});
+
+describe('fnIf', () => {
+  it('returns one', () => {
+    expect(fnIf(true, 'this one', 'not this one')).toBe('this one');
+  });
+
+  it('returns two', () => {
+    expect(fnIf(false, 'not this one', 'this one')).toBe('this one');
+  });
+});
+
+describe('roundToPrecision', () => {
+  it('rounds positive places', () => {
+    expect(roundToPrecision(1234.123, 2)).toBe(1200);
+  });
+
+  it('rounds negative places', () => {
+    expect(roundToPrecision(1234.123, -2)).toBe(1234.12);
+  });
+
+  it('rounds up 5s', () => {
+    expect(roundToPrecision(1234.125, -2)).toBe(1234.13);
+  });
+});
+
+describe('memoize', () => {
+  it('memoizes', () => {
+    const fn = jest.fn((x: number) => x * 2);
+    const fnM = memoize(fn);
+
+    expect(fnM(3)).toBe(6);
+    expect(fnM(3)).toBe(6);
+    expect(fnM(3)).toBe(6);
+    expect(fnM(1)).toBe(2);
+    expect(fnM(1)).toBe(2);
+    expect(fnM(7)).toBe(14);
+
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+
+  it('handles multiple arguments', () => {
+    const fn = jest.fn((x: number, y: number, z: number = 1) => x * y * z);
+    const fnM = memoize(fn);
+
+    expect(fnM(3, 2)).toBe(6);
+    expect(fnM(3, 2)).toBe(6);
+    expect(fnM(3, 3)).toBe(9);
+    expect(fnM(3, 3, 2)).toBe(18);
+    expect(fnM(3, 3, 2)).toBe(18);
+    expect(fnM(1, 2)).toBe(2);
+    expect(fnM(1, 2)).toBe(2);
+    expect(fnM(7, 2)).toBe(14);
+
+    expect(fn).toHaveBeenCalledTimes(5);
+  });
+
+  it('memoizes object arguments', () => {
+    const fn = jest.fn((x: number, {y, z}: {y: number; z?: number}) => x * y * (z || 1));
+    const fnM = memoize(fn);
+
+    const two = {y: 2};
+    const threeTwo = {y:3, z: 2};
+
+    expect(fnM(3, two)).toBe(6);
+    expect(fnM(3, two)).toBe(6);
+    expect(fnM(3, {y: 3})).toBe(9);
+    expect(fnM(3, threeTwo)).toBe(18);
+    expect(fnM(3, threeTwo)).toBe(18);
+    expect(fnM(1, two)).toBe(2);
+    expect(fnM(1, two)).toBe(2);
+    expect(fnM(7, two)).toBe(14);
+
+    expect(fn).toHaveBeenCalledTimes(5);
+  });
+
+  describe('without WeakMap support', () => {
+    const weakMapBak = global.WeakMap;
+
+    beforeEach(() => {
+      delete (global as any).WeakMap;
+    });
+
+    afterEach(() => {
+      (global as any).WeakMap = weakMapBak;
+    });
+
+    it('still works', () => {
+      const fn = jest.fn((x: number, y: number, z: number = 1) => x * y * z);
+      const fnM = memoize(fn);
+
+      expect(fnM(3, 2)).toBe(6);
+      expect(fnM(3, 2)).toBe(6);
+      expect(fnM(3, 3)).toBe(9);
+      expect(fnM(3, 3, 2)).toBe(18);
+      expect(fnM(3, 3, 2)).toBe(18);
+      expect(fnM(1, 2)).toBe(2);
+      expect(fnM(1, 2)).toBe(2);
+      expect(fnM(7, 2)).toBe(14);
+
+      expect(fn).toHaveBeenCalledTimes(5);
+    });
+
+    it('doesn\'t memoize object arguments', () => {
+      const fn = jest.fn((x: number, {y, z}: {y: number; z?: number}) => x * y * (z || 1));
+      const fnM = memoize(fn);
+
+      const two = {y: 2};
+      const threeTwo = {y:3, z: 2};
+
+      expect(fnM(3, two)).toBe(6);
+      expect(fnM(3, two)).toBe(6);
+      expect(fnM(3, {y: 3})).toBe(9);
+      expect(fnM(3, threeTwo)).toBe(18);
+      expect(fnM(3, threeTwo)).toBe(18);
+      expect(fnM(1, two)).toBe(2);
+      expect(fnM(1, two)).toBe(2);
+      expect(fnM(7, two)).toBe(14);
+
+      expect(fn).toHaveBeenCalledTimes(8);
+    });
+  });
+
+  it('calls multiple times when the function returns a Promise that rejects (when it rejects)', async() => {
+    const spy = jest.fn(async(_x) => { throw new Error('Bad Request'); });
+    const memoized = memoize(spy);
+
+    const promise1 = memoized(1);
+    const promise2 = memoized(1);
+    const promise3 = memoized(2);
+
+    await expect(promise1).rejects.toThrow('Bad Request');
+    await expect(promise2).rejects.toThrow('Bad Request');
+    await expect(promise3).rejects.toThrow('Bad Request');
+
+    expect(spy).toHaveBeenCalledTimes(2);
+
+    await expect(memoized(2)).rejects.toThrow('Bad Request');
+
+    expect(spy).toHaveBeenCalledTimes(3);
+  });
+});
+
+describe('partitionSequence', () => {
+  it('partitions a sequence by predicate', () => {
+    expect(partitionSequence(
+      (n: number) => ({value: n % 2}),
+      [1,2,3,4,5,6,7,8]
+    )).toEqual([
+      [1, [1]],
+      [0, [2]],
+      [1, [3]],
+      [0, [4]],
+      [1, [5]],
+      [0, [6]],
+      [1, [7]],
+      [0, [8]],
+    ]);
+    expect(partitionSequence(
+      (n: number) => ({value: Math.floor(n / 3)}),
+      [1,2,3,4,5,6,7,8]
+    )).toEqual([
+      [0, [1,2]],
+      [1, [3,4, 5]],
+      [2, [6,7,8]],
+    ]);
+  });
+
+  it('partitions a sequence with running predicate', () => {
+    expect(partitionSequence(
+      (n: number, p?: {min: number; max: number}) =>
+        p && p.max + 1 === n
+          ? {value: {...p, max: n}, matches: true}
+          : {value: {min: n, max: n}, matches: false}
+      , [1,2,3,5,6,8]
+    )).toEqual([
+      [{min: 1, max: 3}, [1,2,3]],
+      [{min: 5,max: 6}, [5,6]],
+      [{min: 8,max: 8}, [8]],
+    ]);
+  });
+});
+
+describe('flow', () => {
+  it('flows', () => {
+    const fn = flow(
+      (n: number) => n * 4,
+      (n: number) => n.toString(),
+      (s: string) => [s, s],
+      (a: string[]) => a.join(', ')
+    );
+
+    expect(fn(2)).toBe('8, 8');
+  });
+});
+
+describe('coerceArray', () => {
+  it('coerces', () => {
+    expect(coerceArray('value')).toEqual(['value']);
+  });
+
+  it('no-ops', () => {
+    const array = ['foo'];
+    expect(coerceArray(array)).toBe(array);
+  });
+
+  it('handles undefined', () => {
+    expect(coerceArray(undefined)).toEqual([]);
+  });
+});
+
+describe('retryWithDelay', () => {
+  let setTimeoutSpy: jest.SpyInstance;
+  let timeouts: Array<number | undefined>;
+
+  const doBeforeEach = () => {
+    timeouts = [];
+    setTimeoutSpy = jest.spyOn(global, 'setTimeout')
+      .mockImplementation((fn, timeout) => {
+        timeouts.push(timeout);
+        fn();
+        return 1 as any;
+      });
+  };
+
+  const doAfterEach = () => {
+    setTimeoutSpy.mockReset();
+  };
+
+  beforeEach(doBeforeEach);
+  afterEach(doAfterEach);
+
+  it('runs once without delay', async() => {
+    const fn = jest.fn().mockReturnValue(Promise.resolve('hello'));
+    const result = await retryWithDelay(fn);
+    expect(setTimeoutSpy).not.toHaveBeenCalled();
+    expect(result).toBe('hello');
+  });
+
+  it('aborts without retrying', async() => {
+    const fn = jest.fn().mockImplementation(async abort => {
+      abort(new Error('cool error'));
+      throw new Error('unreachable code');
+    });
+    await expect(() => retryWithDelay(fn)).rejects.toThrow('cool error');
+    expect(setTimeoutSpy).not.toHaveBeenCalled();
+  });
+
+  it('retries within expected delay bounds', async() => {
+    for (let i = 0; i < 100; i++) {
+      doBeforeEach();
+      const fn = jest.fn()
+        .mockReturnValueOnce(Promise.reject(new Error('nope')))
+        .mockReturnValue(Promise.resolve('hello'));
+
+      const result = await retryWithDelay<string>(fn);
+
+      expect(result).toBe('hello');
+
+      expect(setTimeoutSpy).toHaveBeenCalledTimes(1);
+      expect(timeouts).toHaveLength(1);
+
+      expect(timeouts[0]).toBeGreaterThan(50);
+      expect(timeouts[0]).toBeLessThan(150);
+      doAfterEach();
+    }
+  });
+
+  it('throws when it runs out of attempts', async() => {
+    for (let i = 0; i < 100; i++) {
+      doBeforeEach();
+      const fn = jest.fn()
+        .mockReturnValueOnce(Promise.reject(new Error('nope')))
+        .mockReturnValueOnce(Promise.reject(new Error('nope')))
+        .mockReturnValueOnce(Promise.reject(new Error('nope')))
+        .mockReturnValueOnce(Promise.reject(new Error('nope')))
+        .mockReturnValue(Promise.resolve('hello'));
+
+      await expect(() => retryWithDelay<string>(fn, {retries: 3})).rejects.toThrow('nope');
+
+      expect(setTimeoutSpy).toHaveBeenCalledTimes(3);
+      expect(timeouts).toHaveLength(3);
+
+      expect(timeouts[0]).toBeGreaterThan(50);
+      expect(timeouts[0]).toBeLessThan(150);
+
+      expect(timeouts[1]).toBeGreaterThan(150);
+      expect(timeouts[1]).toBeLessThan(250);
+
+      expect(timeouts[2]).toBeGreaterThan(250);
+      expect(timeouts[2]).toBeLessThan(350);
+      doAfterEach();
+    }
+  });
+});

package/packages/utils/src/middleware/apiErrorHandler.spec.ts

@@ -0,0 +1,65 @@
+import { ForbiddenError, InvalidRequestError, NotFoundError, SessionExpiredError, UnauthorizedError, ValidationError } from '../errors';
+import { createCoreLogger, Logger } from '../services/logger';
+import { createErrorHandler } from './apiErrorHandler';
+
+describe('errorHandler', () => {
+  let logSpy: jest.SpyInstance;
+  let logger: Logger;
+
+  beforeEach(() => {
+    logSpy = jest.fn();
+    logger = createCoreLogger(logSpy as any);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('handles InvalidRequestError with 400', async () => {
+    expect(await createErrorHandler()(new InvalidRequestError(), logger)).toEqual(expect.objectContaining({statusCode: 400}));
+  });
+
+  it('handles UnauthorizedError with 401', async() => {
+    expect(await createErrorHandler()(new UnauthorizedError(), logger)).toEqual(expect.objectContaining({statusCode: 401}));
+  });
+
+  it('handles ForbiddenError with 403', async() => {
+    expect(await createErrorHandler()(new ForbiddenError(), logger)).toEqual(expect.objectContaining({statusCode: 403}));
+  });
+
+  it('handles NotFoundError with 404', async () => {
+    expect(await createErrorHandler()(new NotFoundError(), logger)).toEqual(expect.objectContaining({statusCode: 404}));
+  });
+
+  it('handles ValidationError with 422', async () => {
+    const error = new ValidationError({field: 'value'});
+    expect(await createErrorHandler()(error, logger)).toMatchInlineSnapshot(`
+{
+  "body": "{"field":"value"}",
+  "data": {
+    "field": "value",
+  },
+  "headers": {
+    "content-type": "application/json",
+  },
+  "statusCode": 422,
+}
+`);
+  });
+
+  it('handles SessionExpired error with 440', async() => {
+    expect(await createErrorHandler()(new SessionExpiredError(), logger)).toEqual(expect.objectContaining(({
+      statusCode: 440,
+      body: '440 SessionExpiredError'
+    })));
+  });
+
+  it('handles unknown error with 500', async() => {
+    expect(await createErrorHandler()(new Error(), logger)).toEqual(expect.objectContaining({statusCode: 500}));
+  });
+
+  it('logs unknown error', async () => {
+    await createErrorHandler()(new Error(), logger);
+    expect(logSpy).toHaveBeenCalled();
+  });
+});

package/packages/utils/src/middleware/apiErrorHandler.ts

@@ -0,0 +1,67 @@
+import {
+  ForbiddenError,
+  InvalidRequestError,
+  isAppError,
+  NotFoundError,
+  SessionExpiredError,
+  UnauthorizedError,
+  ValidationError,
+} from '../errors';
+import type { ApiResponse } from '../routing';
+import { apiJsonResponse, apiTextResponse } from '../routing';
+import type { Logger } from '../services/logger';
+import { Level } from '../services/logger';
+
+export type DefaultErrors = {
+  InvalidRequestError: InvalidRequestError;
+  UnauthorizedError: UnauthorizedError;
+  ForbiddenError: ForbiddenError;
+  NotFoundError: NotFoundError;
+  ValidationError: ValidationError;
+  SessionExpiredError: SessionExpiredError;
+};
+
+export type Handlers<E> = {
+  [T in keyof E]?: (e: E[T], logger: Logger) => ApiResponse<number, any>;
+};
+
+export const defaultHandlers: Handlers<DefaultErrors> = {
+  InvalidRequestError: (e) => apiTextResponse(400, `400 ${e.message}`),
+  UnauthorizedError: (e) => apiTextResponse(401, `401 ${e.message}`),
+  ForbiddenError: (e) => apiTextResponse(403, `403 ${e.message}`),
+  NotFoundError: (e) => apiTextResponse(404, `404 ${e.message}`),
+  ValidationError: (e) => apiJsonResponse(422, e.getData()),
+  SessionExpiredError: (e) => apiTextResponse(440, `440 ${e.message}`),
+};
+
+/**
+ * Creates an error handler. Provides default handlers for `UnauthorizedError`,
+ * `SessionExpiredError`, `NotFoundError`, and `InvalidRequestError`. User-specified
+ * handlers can be added to these. If no handler is found, the error is logged and
+ * a 500 text response is returned.
+ *
+ * @param inputHandlers a map of errors to handler functions
+ */
+export const createErrorHandler = <Errors = DefaultErrors>(inputHandlers?: Handlers<Errors>) => {
+  const handlers = {...defaultHandlers, ...inputHandlers};
+
+  return async(e: Error, logger: Logger) => {
+    const name = isAppError(e) ? e.constructor.TYPE : e.constructor.name;
+    const handler = handlers[name as keyof typeof handlers];
+    const logLevel = handler ? Level.Info : Level.Error;
+
+    logger.logEvent(logLevel, {
+      name: e.name,
+      message: e.message,
+      stack: e.stack,
+    });
+
+    if (handler) {
+      // convincing typescript that this error is the right kind for the handler
+      // we looked up based on the errors name is very annoying
+      return handler(e as any, logger);
+    }
+
+    return apiTextResponse(500, '500 Error');
+  };
+};