feat: factor response library out of io-ts-http

Author: bitgopatmcl

package-lock.json

@@ -6,13 +6,7 @@
 import express from 'express';
 import * as PathReporter from 'io-ts/lib/PathReporter';
 
-import {
-  ApiSpec,
-  HttpResponseCodes,
-  HttpRoute,
-  RequestType,
-  ResponseType,
-} from '@api-ts/io-ts-http';
+import { ApiSpec, HttpRoute, RequestType, ResponseType } from '@api-ts/io-ts-http';
 
 import { apiTsPathToExpress } from './path';
 
@@ -33,9 +27,6 @@ const createNamedFunction = <F extends (...args: any) => void>(
   fn: F,
 ): F => Object.defineProperty(fn, 'name', { value: name });
 
-const isKnownStatusCode = (code: string): code is keyof typeof HttpResponseCodes =>
-  HttpResponseCodes.hasOwnProperty(code);
-
 const decodeRequestAndEncodeResponse = <Route extends HttpRoute>(
   apiName: string,
   httpRoute: Route,
@@ -65,22 +56,12 @@ const decodeRequestAndEncodeResponse = <Route extends HttpRoute>(
         return;
       }
 
-      // Take the first match -- the implication is that the ordering of declared response
-      // codecs is significant!
-      for (const [statusCode, responseCodec] of Object.entries(httpRoute.response)) {
-        if (rawResponse.type !== statusCode) {
+      for (const [statusCodeStr, responseCodec] of Object.entries(httpRoute.response)) {
+        const statusCode = Number(statusCodeStr);
+        if (!Number.isInteger(statusCode) || rawResponse.type !== statusCode) {
           continue;
         }
 
-        if (!isKnownStatusCode(statusCode)) {
-          console.warn(
-            `Got unrecognized status code ${statusCode} for ${apiName} ${httpRoute.method}`,
-          );
-          res.status(500);
-          res.end();
-          return;
-        }
-
         // We expect that some route implementations may "beat the type
         // system away with a stick" and return some unexpected values
         // that fail to encode, so we catch errors here just in case
@@ -96,8 +77,7 @@ const decodeRequestAndEncodeResponse = <Route extends HttpRoute>(
           res.end();
           return;
         }
-        // DISCUSS: safer ways to handle this cast
-        res.writeHead(HttpResponseCodes[statusCode], {
+        res.writeHead(statusCode, {
           'Content-Type': 'application/json',
         });
         res.write(JSON.stringify(response));

packages/express-wrapper/src/index.ts

@@ -5,7 +5,6 @@ import express from 'express';
 import supertest from 'supertest';
 
 import { ApiSpec, apiSpec, httpRequest, httpRoute, optional } from '@api-ts/io-ts-http';
-import { Response } from '@api-ts/response';
 import { buildApiClient, supertestRequestFactory } from '@api-ts/superagent-wrapper';
 
 import { createServer } from '../src';
@@ -24,17 +23,17 @@ const PutHello = httpRoute({
   }),
   response: {
     // TODO: create prettier names for these codecs at the io-ts-http level
-    ok: t.type({
+    200: t.type({
       message: t.string,
       appMiddlewareRan: t.boolean,
       routeMiddlewareRan: t.boolean,
     }),
-    invalidRequest: t.type({
+    400: t.type({
       errors: t.string,
     }),
-    notFound: t.unknown,
+    404: t.unknown,
     // DISCUSS: what if a response isn't listed here but shows up?
-    internalError: t.unknown,
+    500: t.unknown,
   },
 });
 type PutHello = typeof PutHello;
@@ -48,7 +47,7 @@ const GetHello = httpRoute({
     },
   }),
   response: {
-    ok: t.type({
+    200: t.type({
       id: t.string,
     }),
   },
@@ -78,21 +77,31 @@ const CreateHelloWorld = async (parameters: {
   routeMiddlewareRan?: boolean;
 }) => {
   if (parameters.secretCode === 0) {
-    return Response.invalidRequest({
-      errors: 'Please do not tell me zero! I will now explode',
-    });
+    return {
+      type: 400,
+      payload: {
+        errors: 'Please do not tell me zero! I will now explode',
+      },
+    } as const;
   }
-  return Response.ok({
-    message:
-      parameters.secretCode === 42
-        ? 'Everything you see from here is yours'
-        : "Who's there?",
-    appMiddlewareRan: parameters.appMiddlewareRan ?? false,
-    routeMiddlewareRan: parameters.routeMiddlewareRan ?? false,
-  });
+  return {
+    type: 200,
+    payload: {
+      message:
+        parameters.secretCode === 42
+          ? 'Everything you see from here is yours'
+          : "Who's there?",
+      appMiddlewareRan: parameters.appMiddlewareRan ?? false,
+      routeMiddlewareRan: parameters.routeMiddlewareRan ?? false,
+    },
+  } as const;
 };
 
-const GetHelloWorld = async (params: { id: string }) => Response.ok(params);
+const GetHelloWorld = async (params: { id: string }) =>
+  ({
+    type: 200,
+    payload: params,
+  } as const);
 
 test('should offer a delightful developer experience', async (t) => {
   const app = createServer(ApiSpec, (app: express.Application) => {

packages/express-wrapper/test/server.test.ts

@@ -17,7 +17,6 @@
     "test": "nyc --reporter=lcov --reporter=text --reporter=json-summary mocha test/**/*.test.ts --require ts-node/register --exit"
   },
   "dependencies": {
-    "@api-ts/response": "0.0.0-semantically-released",
     "fp-ts": "2.11.8",
     "io-ts": "2.1.3",
     "io-ts-types": "0.5.16",

packages/io-ts-http/package.json

@@ -1,44 +1,9 @@
 import * as t from 'io-ts';
 
-import { Status } from '@api-ts/response';
-
 export type HttpResponse = {
-  [K in Status]?: t.Mixed;
+  [K: number]: t.Mixed;
 };
 
-export type KnownResponses<Response extends HttpResponse> = {
-  [K in keyof Response]: K extends Status
-    ? undefined extends Response[K]
-      ? never
-      : K
-    : never;
-}[keyof Response];
-
-export const HttpResponseCodes = {
-  ok: 200,
-  invalidRequest: 400,
-  unauthenticated: 401,
-  permissionDenied: 403,
-  notFound: 404,
-  rateLimitExceeded: 429,
-  internalError: 500,
-  serviceUnavailable: 503,
-} as const;
-
-export type HttpResponseCodes = typeof HttpResponseCodes;
-
-// Create a type-level assertion that the HttpResponseCodes map contains every key
-// in the Status union of string literals, and no unexpected keys. Violations of
-// this assertion will cause compile-time errors.
-//
-// Thanks to https://stackoverflow.com/a/67027737
-type ShapeOf<T> = Record<keyof T, any>;
-type AssertKeysEqual<X extends ShapeOf<Y>, Y extends ShapeOf<X>> = never;
-type _AssertHttpStatusCodeIsDefinedForAllResponses = AssertKeysEqual<
-  { [K in Status]: number },
-  HttpResponseCodes
->;
-
 export type ResponseTypeForStatus<
   Response extends HttpResponse,
   S extends keyof Response,

packages/io-ts-http/src/httpResponse.ts

@@ -1,8 +1,7 @@
 import * as t from 'io-ts';
 
-import { HttpResponse, KnownResponses } from './httpResponse';
-import { httpRequest, HttpRequestCodec } from './httpRequest';
-import { Status } from '@api-ts/response';
+import { HttpResponse } from './httpResponse';
+import { HttpRequestCodec } from './httpRequest';
 
 export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';
 
@@ -13,17 +12,15 @@ export type HttpRoute = {
   readonly response: HttpResponse;
 };
 
-type ResponseItem<Status, Codec extends t.Mixed | undefined> = Codec extends t.Mixed
-  ? {
-      type: Status;
-      payload: t.TypeOf<Codec>;
-    }
-  : never;
-
 export type RequestType<T extends HttpRoute> = t.TypeOf<T['request']>;
 export type ResponseType<T extends HttpRoute> = {
-  [K in KnownResponses<T['response']>]: ResponseItem<K, T['response'][K]>;
-}[KnownResponses<T['response']>];
+  [K in keyof T['response']]: T['response'][K] extends t.Mixed
+    ? {
+        type: K;
+        payload: t.TypeOf<T['response'][K]>;
+      }
+    : never;
+}[keyof T['response']];
 
 export type ApiSpec = {
   [Key: string]: {

packages/io-ts-http/src/httpRoute.ts

@@ -10,7 +10,7 @@ const MyRoute = h.httpRoute({
   method: 'GET',
   request: h.httpRequest({}),
   response: {
-    ok: t.array(t.string),
+    200: t.array(t.string),
   },
 });
 

packages/openapi-generator/corpus/test-array-property.ts

@@ -10,7 +10,7 @@ const MyRoute = h.httpRoute({
   method: 'GET',
   request: h.httpRequest({}),
   response: {
-    ok: t.literal(false),
+    200: t.literal(false),
   },
 });
 

packages/openapi-generator/corpus/test-boolean-literal.ts

@@ -10,7 +10,10 @@ const MyRoute = h.httpRoute({
   method: 'GET',
   request: h.httpRequest({}),
   response: {
-    ok: t.union([t.type({ key: t.literal('foo') }), t.type({ key: t.literal('bar') })]),
+    200: t.union([
+      t.type({ key: t.literal('foo') }),
+      t.type({ key: t.literal('bar') }),
+    ]),
   },
 } as const);
 

packages/openapi-generator/corpus/test-discriminated-union.ts

@@ -10,7 +10,7 @@ const MyRoute = h.httpRoute({
   method: 'GET',
   request: h.httpRequest({}),
   response: {
-    ok: t.intersection([t.type({ foo: t.string }), t.type({ bar: t.string })]),
+    200: t.intersection([t.type({ foo: t.string }), t.type({ bar: t.string })]),
   },
 });