@openstax/ts-utils 1.33.1 → 1.34.0

package/{dist/esm/routing/helpers.js → packages/utils/src/routing/helpers.ts}

@@ -1,6 +1,8 @@
 import { assertErrorInstanceOf } from '../assertions';
 import { InvalidRequestError } from '../errors';
 import { isPlainObject } from '../guards';
+import type { HttpHeaders } from '.';
+
 /**
  * Get the value of a header, case insensitive; note if there are multiple headers of the same
  * value, this only returns the first value
@@ -8,41 +10,50 @@ import { isPlainObject } from '../guards';
  * @param headers
  * @param name the name of the header, case ignored
  */
-export const getHeader = (headers, name) => {
-    const key = Object.keys(headers).find(header => header.toLowerCase() === name.toLowerCase());
-    const value = key ? headers[key] : undefined;
-    return value instanceof Array
-        ? value[0]
-        : value;
+export const getHeader = (headers: HttpHeaders, name: string) => {
+  const key = Object.keys(headers).find(header => header.toLowerCase() === name.toLowerCase());
+  const value = key ? headers[key] : undefined;
+
+  return value instanceof Array
+    ? value[0]
+    : value
+  ;
 };
+
 /**
  * Gets the body of a request
  * @param request
  * @throws InvalidRequestError if the content type is not application/json or not parsable
  */
-export const getRequestBody = (request) => {
-    if (getHeader(request.headers, 'content-type') !== 'application/json') {
-        throw new InvalidRequestError('unknown content type: ' + getHeader(request.headers, 'content-type'));
-    }
-    if (!request.body) {
-        return {};
-    }
-    try {
-        return JSON.parse(request.body);
-    }
-    catch (error) {
-        // Since the body is provided by the user, invalid JSON in the body is an invalid request
-        // We return the message which tells them why the JSON is invalid, but no backtrace
-        throw new InvalidRequestError(assertErrorInstanceOf(error, SyntaxError).message);
-    }
+export const getRequestBody = (request: {headers: HttpHeaders; body?: string | undefined}) => {
+  if (getHeader(request.headers, 'content-type') !== 'application/json') {
+    throw new InvalidRequestError(
+      'unknown content type: ' + getHeader(request.headers, 'content-type')
+    );
+  }
+
+  if (!request.body) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(request.body);
+  } catch (error) {
+    // Since the body is provided by the user, invalid JSON in the body is an invalid request
+    // We return the message which tells them why the JSON is invalid, but no backtrace
+    throw new InvalidRequestError(assertErrorInstanceOf(error, SyntaxError).message);
+  }
 };
+
 /* utils and middleware for loading request payload (must follow this pattern for `PayloadForRoute` to work) */
+
 /**
  * stub validator because writing validators is annoying
  */
-export const unsafePayloadValidator = () => (input) => {
-    return isPlainObject(input) && Object.keys(input).length > 0;
+export const unsafePayloadValidator = <T>() => (input: any): input is T => {
+  return isPlainObject(input) && Object.keys(input).length > 0;
 };
+
 /**
  * Middleware that validates the request payload and adds it to the middleware (with key `payload`)
  * so it can be accessed downstream.
@@ -73,11 +84,12 @@ export const unsafePayloadValidator = () => (input) => {
  *   }
  * );
  */
-export const requestPayloadProvider = (validator) => () => (requestServices) => {
-    const payload = getRequestBody(requestServices.request);
-    // for more precise error messages, throw your own InvalidRequestError from your validator function
-    if (!validator(payload)) {
-        throw new InvalidRequestError();
-    }
-    return { ...requestServices, payload };
+export const requestPayloadProvider = <T>(validator: (input: any) => input is T) => () => <M extends {request: Parameters<typeof getRequestBody>[0]}>(requestServices: M) => {
+  const payload = getRequestBody(requestServices.request) as T;
+
+  // for more precise error messages, throw your own InvalidRequestError from your validator function
+  if (!validator(payload)) {
+    throw new InvalidRequestError();
+  }
+  return {...requestServices, payload};
 };

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

@@ -0,0 +1,553 @@
+import { getKeyValue } from '..';
+import { InvalidRequestError, UnauthorizedError } from '../errors';
+import { makeComposeMiddleware } from '../middleware';
+import { apiHtmlResponse, apiJsonResponse, apiTextResponse, getHeader, getRequestBody, makeCreateRoute, makeGetRequestResponder, makeRenderRouteUrl, requestPayloadProvider, unsafePayloadValidator } from '../routing';
+import { createConsoleLogger } from '../services/logger/console';
+import { routesList } from '.';
+
+interface RouteRequest {
+  path: string;
+}
+interface RouteResponse {
+  body: string;
+}
+// ts weak type makes this fail if it has no properties
+type AppServices = {
+  asdf: string;
+};
+
+const composeMiddleware = makeComposeMiddleware<AppServices, {}>();
+const createRoute = makeCreateRoute<AppServices, RouteRequest, {}>();
+
+describe('getRequestBody', () => {
+  it('gets it', () => {
+    const request = {
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: '{"foo":"bar"}'
+    };
+    expect(getRequestBody(request)).toEqual({foo: 'bar'});
+  });
+
+  it('defaults to empty object', () => {
+    const request = {
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: ''
+    };
+    expect(getRequestBody(request)).toEqual({});
+  });
+
+  it('throws if json content type is not set', () => {
+    const request = {
+      headers: {
+        'content-type': 'application/text'
+      },
+      body: '{"foo":"bar"}'
+    };
+    expect(() => getRequestBody(request)).toThrow();
+  });
+
+  it('throws if content type is not set', () => {
+    const request = {
+      headers: {
+      },
+      body: '{"foo":"bar"}'
+    };
+    expect(() => getRequestBody(request)).toThrow();
+  });
+
+  it('throws if body is not valid json', () => {
+    const request = {
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: 'foobar'
+    };
+    expect(() => getRequestBody(request)).toThrow();
+  });
+});
+
+describe('getRequestResponder', () => {
+  const services = {asdf: 'asdf'};
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('executes static route', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
+      body: 'response to test route 1'
+    })});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path')
+    });
+    const result = getRequestResponder(services)(request);
+
+    expect(result?.body).toBe('response to test route 1');
+  });
+
+  it('uses route matcher', () => {
+    const request = {
+      path: '/foo'
+    };
+    const createRouteWithExtra = makeCreateRoute<AppServices, RouteRequest, {theOne: boolean}>();
+
+    const testRoute1 = createRouteWithExtra({name: 'test', theOne: false, path: '/foo', handler: () => ({
+      body: 'response to test route 1'
+    })});
+    const testRoute2 = createRouteWithExtra({name: 'test', theOne: true, path: '/foo', handler: () => ({
+      body: 'response to test route 2'
+    })});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute1 | typeof testRoute2, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute1, testRoute2]),
+      routeMatcher: (_request, route) => route.theOne,
+      pathExtractor: getKeyValue('path')
+    });
+    const result = getRequestResponder(services)(request);
+
+    expect(result?.body).toBe('response to test route 2');
+  });
+
+  it('executes parameterized route', () => {
+    const request = {
+      path: '/foo/some-path'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo/:part', handler: (params: {part: string}) => ({
+      body: 'response to test route 2: ' + params.part
+    })});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path')
+    });
+
+    const result = getRequestResponder(services)(request);
+
+    expect(result?.body).toBe('response to test route 2: some-path');
+  });
+
+  it('returns undefined for unknown route', () => {
+    const request = {
+      path: '/foobar'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
+      body: 'response to test route 1'
+    })});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path')
+    });
+
+    const result = getRequestResponder(services)(request);
+
+    expect(result).toBeUndefined();
+  });
+
+  it('rethrows errors without an error handler', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
+      throw new UnauthorizedError();
+    }});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path')
+    });
+
+    expect(() => getRequestResponder(services)(request)).toThrow(UnauthorizedError);
+  });
+
+  it('rethrows errors with an error handler', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
+      throw new UnauthorizedError();
+    }});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+      errorHandler: (e: Error) => {
+        throw e;
+      }
+    });
+
+    expect(() => getRequestResponder(services)(request)).toThrow(UnauthorizedError);
+  });
+
+  it('handles errors with an error handler', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
+      throw new UnauthorizedError();
+    }});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+      errorHandler: (_e: Error) => {
+        return {body: 'handled'};
+      }
+    });
+
+    const result = getRequestResponder(services)(request);
+
+    expect(result?.body).toBe('handled');
+  });
+
+  it('handles async errors with an error handler', async() => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: async() => {
+      throw new UnauthorizedError();
+    }});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, Promise<RouteResponse>>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+      errorHandler: async(_e: Error) => {
+        return {body: 'handled'};
+      }
+    });
+
+    const result = await getRequestResponder(services)(request);
+
+    expect(result?.body).toBe('handled');
+  });
+
+  it('handles errors with middleware with an error handler', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
+      throw new UnauthorizedError();
+    }});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+      errorHandler: (_e: Error) => {
+        return {body: 'handled'};
+      }
+    });
+
+    const result = getRequestResponder(services, () => (response) => response ? {body: `hello - ${response.body}`} : response)(request);
+
+    expect(result?.body).toBe('hello - handled');
+  });
+
+  it('handles async errors with middleware with an error handler', async() => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: async() => {
+      throw new UnauthorizedError();
+    }});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, Promise<RouteResponse>>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+      errorHandler: async(_e: Error) => {
+        return {body: 'handled'};
+      }
+    });
+
+    const result = await getRequestResponder(services, () => async(response) => {
+      const result = await response;
+      return result ? {body: `hello - ${result.body}`} : result;
+    })(request);
+
+    expect(result?.body).toBe('hello - handled');
+  });
+
+  it('handles errors from middleware with an error handler', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo',
+      requestServiceProvider: composeMiddleware(
+        () => (): {} => {
+          throw new Error();
+        }
+      )},
+      (): RouteResponse => {
+        return {body: 'asdf'};
+      }
+    );
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+      errorHandler: (_e: Error) => {
+        return {body: 'handled'};
+      }
+    });
+
+    const result = getRequestResponder(services)(request);
+
+    expect(result?.body).toBe('handled');
+  });
+
+  it('handles async errors from middleware with an error handler', async() => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo',
+      requestServiceProvider: composeMiddleware(
+        () => (): {} => {
+          throw new Error();
+        }
+      )},
+      async() => {
+        return {body: 'asdf'};
+      }
+    );
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, Promise<RouteResponse>>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+      errorHandler: async(_e: Error) => {
+        return {body: 'handled'};
+      }
+    });
+
+    const result = await getRequestResponder(services)(request);
+
+    expect(result?.body).toBe('handled');
+  });
+
+  it('rethrows errors from middleware without an error handler', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const requestServiceProvider = composeMiddleware(
+      () => (): {} => {
+        throw new UnauthorizedError();
+      }
+    );
+
+    const testRoute = createRoute({name: 'test', path: '/foo', requestServiceProvider, handler: (): RouteResponse => {
+      return {body: 'asdf'};
+    }});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+    });
+
+    expect(() => getRequestResponder(services)(request)).toThrow(UnauthorizedError);
+  });
+
+  it('rethrows errors from middleware with an error handler', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: (): RouteResponse => {
+      throw new UnauthorizedError();
+    }});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+      errorHandler: (e: Error) => {
+        throw e;
+      }
+    });
+
+    expect(() => getRequestResponder(services)(request)).toThrow(UnauthorizedError);
+  });
+
+  it('uses middleware on route response', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
+      body: 'response to test route 1'
+    })});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+    });
+
+    const result = getRequestResponder(services, () => (response) => response ? {body: `hello - ${response.body}`} : response)(request);
+
+    expect(result?.body).toBe('hello - response to test route 1');
+  });
+
+  it('uses middleware on unknown response', () => {
+    const request = {
+      path: '/foobar'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
+      body: 'response to test route 1'
+    })});
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      pathExtractor: getKeyValue('path'),
+    });
+
+    const result = getRequestResponder(services, () => (response) => response ? response : 'default')(request);
+
+    expect(result).toBe('default');
+  });
+
+  it('attaches request context to logger', () => {
+    const request = {
+      path: '/foo'
+    };
+
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({
+      body: 'response to test route 1'
+    })});
+
+    const logger = createConsoleLogger();
+    const subContext = logger.createSubContext();
+    const setContextSpy = jest.spyOn(logger, 'setContext');
+    jest.spyOn(logger, 'createSubContext').mockReturnValue(subContext);
+    const setSubContextSpy = jest.spyOn(subContext, 'setContext');
+
+    const getRequestResponder = makeGetRequestResponder<AppServices, typeof testRoute, RouteRequest, RouteResponse>()({
+      routes: () => ([testRoute]),
+      logExtractor: request => ({path: request.path}),
+      pathExtractor: getKeyValue('path')
+    });
+    getRequestResponder({...services, logger})(request);
+
+    expect(setContextSpy).not.toHaveBeenCalled();
+    expect(setSubContextSpy).toHaveBeenCalledWith({path: '/foo'});
+  });
+});
+
+describe('getHeader', () => {
+  it('ignores multi-value headers', () => {
+    expect(getHeader({headerKey: ['value1', 'value2']}, 'headerKey')).toBe('value1');
+  });
+});
+
+describe('renderRouteUrl', () => {
+  it('renders routes', () => {
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({body: 'asdf'})});
+    const renderRouteUrl = makeRenderRouteUrl<typeof testRoute>();
+
+    expect(renderRouteUrl(testRoute, undefined)).toBe('/foo');
+  });
+
+ it('renders routes with params', () => {
+    const testRoute = createRoute({name: 'test', path: '/foo/:part', handler: (_param: {part: string}) => ({body: 'asdf'})});
+    const renderRouteUrl = makeRenderRouteUrl<typeof testRoute>();
+
+    expect(renderRouteUrl(testRoute, {part: 'foo'})).toBe('/foo/foo');
+  });
+
+  it('renders routes with query', () => {
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({body: 'asdf'})});
+    const renderRouteUrl = makeRenderRouteUrl<typeof testRoute>();
+
+    expect(renderRouteUrl(testRoute, undefined, {param: 'someParam'})).toBe('/foo?param=someParam');
+  });
+});
+
+describe('apiJsonResponse', () => {
+  it('makes a response', () => {
+    expect(apiJsonResponse(200, {key: 'value'})).toEqual({
+      statusCode: 200,
+      data: {key: 'value'},
+      body: '{"key":"value"}',
+      headers: {'content-type': 'application/json'}
+    });
+  });
+});
+
+describe('apiTextResponse', () => {
+  it('makes a response', () => {
+    expect(apiTextResponse(200, 'some text')).toEqual({
+      statusCode: 200,
+      data: 'some text',
+      body: 'some text',
+      headers: {'content-type': 'text/plain'}
+    });
+  });
+});
+
+describe('apiHtmlResponse', () => {
+  it('makes a response', () => {
+    expect(apiHtmlResponse(200, 'some text')).toEqual({
+      statusCode: 200,
+      data: 'some text',
+      body: 'some text',
+      headers: {'content-type': 'text/html'}
+    });
+  });
+});
+
+describe('requestPayloadProvider', () => {
+  it('provides a payload', () => {
+    const provider = requestPayloadProvider(unsafePayloadValidator<{key: string}>());
+    const {payload} = provider()({
+      request: {headers: {'content-type': 'application/json'}, body: '{"key":"string"}'}
+    });
+
+    expect(payload).toEqual({key: 'string'});
+  });
+
+  it('doesn\'t fuss with type', () => {
+    const request = {otherRequestValue: 'someValue', headers: {'content-type': 'application/json'}, body: '{"key":"string"}'};
+    const composeMiddleware = makeComposeMiddleware<{}, {request: typeof request}>();
+    const provider = requestPayloadProvider(unsafePayloadValidator<{key: string}>());
+    const result = composeMiddleware(provider)({})({request});
+
+    expect(result.request.otherRequestValue).toBe('someValue');
+  });
+
+  it('throws when validator fails', () => {
+    const validatorThatFails = (_input: any): _input is {key: string} => false;
+
+    const provider = requestPayloadProvider(validatorThatFails);
+
+    expect(() =>
+      provider()({
+        request: {headers: {'content-type': 'application/json'}, body: '{"key":"string"}'}
+      })
+    ).toThrow(InvalidRequestError);
+  });
+});
+
+describe('routesList', () => {
+  it ('returns route list', () => {
+    const testRoute = createRoute({name: 'test', path: '/foo', handler: () => ({body: 'asdf'})});
+    const list = routesList([testRoute]);
+    expect(list[0]).toBe(testRoute);
+  });
+});