feat(core): allow entire contract to be passed to TsRestResponseError (#579)

Author: Gabrola

.changeset/proud-moons-flow.md

@@ -0,0 +1,5 @@
+---
+'@ts-rest/core': minor
+---
+
+Allow entire contract to be passed to `TsRestResponseError` so common responses can be thrown easily

apps/docs/docs/core/server-errors.md

@@ -14,6 +14,15 @@ throw new TsRestResponseError(contract.getPost, {
 });
 ```
 
+You can also pass an entire contract to the `TsRestResponseError` constructor, and it will allow you to pass responses that are common to all endpoints.
+
+```typescript
+throw new TsRestResponseError(contract, {
+  status: 404,
+  body: { message: 'Not Found' },
+});
+```
+
 :::caution
 
 Any thrown `TsRestResponseError` will NOT be caught by any error handlers, and will be served as a response straight away.

libs/ts-rest/core/src/lib/response-error.spec.ts

@@ -0,0 +1,67 @@
+import type { Equal, Expect } from './test-helpers';
+import { initContract } from './dsl';
+import { z } from 'zod';
+import { TsRestResponseError } from './response-error';
+import { HTTPStatusCode } from './status-codes';
+
+const c = initContract();
+
+const contract = c.router(
+  {
+    posts: {
+      getPost: {
+        method: 'GET',
+        path: '/posts/:id',
+        responses: {
+          200: z.object({
+            id: z.number(),
+            content: z.string(),
+          }),
+        },
+      },
+    },
+    users: {
+      getUser: {
+        method: 'GET',
+        path: '/users/:id',
+        responses: {
+          200: z.object({
+            id: z.number(),
+            name: z.string(),
+          }),
+        },
+      },
+    },
+  },
+  {
+    commonResponses: {
+      404: z.object({
+        message: z.string(),
+      }),
+    },
+  },
+);
+
+describe('TsRestResponseError', () => {
+  it('correctly sets response type for single endpoint', () => {
+    type ResponseType = Expect<
+      Equal<
+        ConstructorParameters<
+          typeof TsRestResponseError<typeof contract.posts.getPost>
+        >[1],
+        | { status: 200; body: { id: number; content: string } }
+        | { status: 404; body: { message: string } }
+        | { status: Exclude<HTTPStatusCode, 200 | 404>; body: unknown }
+      >
+    >;
+  });
+
+  it('correctly sets response type for entire contract', () => {
+    type ResponseType = Expect<
+      Equal<
+        ConstructorParameters<typeof TsRestResponseError<typeof contract>>[1],
+        { status: 404; body: { message: string } }
+      >
+    >;
+  });
+});

libs/ts-rest/core/src/lib/response-error.ts

@@ -1,15 +1,21 @@
-import { AppRoute } from './dsl';
-import { ServerInferResponses } from './infer-types';
+import { AppRoute, AppRouter, AppRouteResponse } from './dsl';
+import { ResolveResponseType, ServerInferResponses } from './infer-types';
 import { HTTPStatusCode } from './status-codes';
+import { CommonAndEqual, ZodInputOrType } from './type-utils';
 
-export class TsRestResponseError<T extends AppRoute> extends Error {
+export class TsRestResponseError<T extends AppRoute | AppRouter> extends Error {
   public statusCode: HTTPStatusCode;
   public body: any;
 
-  constructor(route: T, response: ServerInferResponses<T>) {
+  constructor(
+    route: T,
+    response: T extends AppRouter
+      ? ServerCommonResponses<T>
+      : ServerInferResponses<T>,
+  ) {
     super();
 
-    this.statusCode = response.status;
+    this.statusCode = response.status as HTTPStatusCode;
     this.body = response.body;
     this.name = this.constructor.name;
 
@@ -27,3 +33,29 @@ export class TsRestResponseError<T extends AppRoute> extends Error {
     }
   }
 }
+
+type FlattenAppRouter<T extends AppRouter | AppRoute> = T extends AppRoute
+  ? T
+  : {
+      [TKey in keyof T]: T[TKey] extends AppRoute
+        ? T[TKey]
+        : T[TKey] extends AppRouter
+        ? FlattenAppRouter<T[TKey]>
+        : never;
+    }[keyof T];
+
+type AppRouterCommonResponses<T extends AppRouter> = CommonAndEqual<
+  FlattenAppRouter<T>['responses']
+>;
+
+type ServerCommonResponses<
+  T extends AppRouter,
+  TResponses = AppRouterCommonResponses<T>,
+> = {
+  [K in keyof TResponses]: {
+    status: K;
+    body: TResponses[K] extends AppRouteResponse
+      ? ZodInputOrType<ResolveResponseType<TResponses[K]>>
+      : never;
+  };
+}[keyof TResponses];

libs/ts-rest/core/src/lib/type-utils.ts

@@ -180,3 +180,23 @@ export type Not<B extends boolean> = {
   false: true;
   true: false;
 }[`${B}`];
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never;
+
+type CommonKeys<T, R = {}> = R extends T
+  ? keyof T & CommonKeys<Exclude<T, R>>
+  : keyof T;
+
+type Common<T> = Pick<T, CommonKeys<T>>;
+
+type RemoveUnionProperties<T> = {
+  [TKey in keyof T as [T[TKey]] extends [UnionToIntersection<T[TKey]>]
+    ? TKey
+    : never]: T[TKey];
+};
+
+export type CommonAndEqual<T> = RemoveUnionProperties<Common<T>>;