feat(types): type $fetch to match json serialization output

src/types/fetch.ts

@@ -1,5 +1,6 @@
 import type { RouterMethod } from "h3";
 import type { FetchRequest, FetchOptions, FetchResponse } from "ofetch";
+import type { Serialize, Simplify } from "./serialize";
 import type { MatchedRoutes } from "./utils";
 
 // An interface to extend in a local project
@@ -16,7 +17,11 @@ export type MiddlewareOf<
   Route extends string,
   Method extends RouterMethod | "default"
 > = Method extends keyof InternalApi[MatchedRoutes<Route>]
-  ? Exclude<InternalApi[MatchedRoutes<Route>][Method], Error | void>
+  ? Simplify<
+      Serialize<
+        Exclude<InternalApi[MatchedRoutes<Route>][Method], Error | void>
+      >
+    >
   : never;
 
 export type TypedInternalResponse<

src/types/serialize.ts

@@ -0,0 +1,56 @@
+/**
+ * @link https://github.com/remix-run/remix/blob/2248669ed59fd716e267ea41df5d665d4781f4a9/packages/remix-server-runtime/serialize.ts
+ */
+type JsonPrimitive =
+  | string
+  | number
+  | boolean
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | String
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | Number
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | Boolean
+  | null;
+// eslint-disable-next-line @typescript-eslint/ban-types
+type NonJsonPrimitive = undefined | Function | symbol;
+
+/*
+ * `any` is the only type that can let you equate `0` with `1`
+ * See https://stackoverflow.com/a/49928360/1490091
+ */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+
+type FilterKeys<TObj extends object, TFilter> = {
+  [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never;
+}[keyof TObj];
+
+// prettier-ignore
+export type Serialize<T> =
+ IsAny<T> extends true ? any :
+ T extends JsonPrimitive ? T :
+ T extends Map<any,any> | Set<any> ? Record<string, never> :
+ T extends NonJsonPrimitive ? never :
+ T extends { toJSON(): infer U } ? U :
+ T extends [] ? [] :
+ T extends [unknown, ...unknown[]] ? SerializeTuple<T> :
+ T extends ReadonlyArray<infer U> ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] :
+ T extends object ? SerializeObject<T> :
+ never;
+
+/** JSON serialize [tuples](https://www.typescriptlang.org/docs/handbook/2/objects.html#tuple-types) */
+type SerializeTuple<T extends [unknown, ...unknown[]]> = {
+  [k in keyof T]: T[k] extends NonJsonPrimitive ? null : Serialize<T[k]>;
+};
+
+/** JSON serialize objects (not including arrays) and classes */
+type SerializeObject<T extends object> = {
+  [k in keyof Omit<T, FilterKeys<T, NonJsonPrimitive>>]: Serialize<T[k]>;
+};
+
+/**
+ * @see https://github.com/ianstormtaylor/superstruct/blob/7973400cd04d8ad92bbdc2b6f35acbfb3c934079/src/utils.ts#L323-L325
+ */
+export type Simplify<TType> = TType extends any[] | Date
+  ? TType
+  : { [K in keyof TType]: TType[K] };

test/fixture/api/serialized/date.ts

@@ -0,0 +1 @@
+export default defineEventHandler(() => ({ createdAt: new Date() }));

test/fixture/api/serialized/function.ts

@@ -0,0 +1,3 @@
+export default defineEventHandler(() => {
+  return { foo: () => 'foo' }
+});

test/fixture/api/serialized/map.ts

@@ -0,0 +1,3 @@
+export default defineEventHandler(() => {
+  return { foo: new Map<string, number>([["key", 2]]) };
+});

test/fixture/api/serialized/set.ts

@@ -0,0 +1,3 @@
+export default defineEventHandler(() => {
+  return { foo: new Set(["item"]) };
+});

test/fixture/api/serialized/tuple.ts

@@ -0,0 +1,3 @@
+export default defineEventHandler(() => {
+  return ["foo", new Date()] as [string, Date];
+});

test/fixture/types.ts

@@ -191,4 +191,32 @@ describe("API routes", () => {
       $fetch("/api/methods/default", { method: "POST" })
     ).toMatchTypeOf<Promise<"Default override">>();
   });
+
+  it("generates types matching JSON serialization output", () => {
+    expectTypeOf($fetch("/api/serialized/date")).toMatchTypeOf<
+      Promise<{
+        createdAt: string;
+      }>
+    >();
+
+    expectTypeOf($fetch("/api/serialized/function")).toMatchTypeOf<
+      Promise<object>
+    >();
+
+    expectTypeOf($fetch("/api/serialized/map")).toMatchTypeOf<
+      Promise<{
+        foo: Record<string, never>;
+      }>
+    >();
+
+    expectTypeOf($fetch("/api/serialized/set")).toMatchTypeOf<
+      Promise<{
+        foo: Record<string, never>;
+      }>
+    >();
+
+    expectTypeOf($fetch("/api/serialized/tuple")).toMatchTypeOf<
+      Promise<[string, string]>
+    >();
+  });
 });