Fix: Correct type inference for t.Date() in query parameters

src/treaty2/types.ts

@@ -58,6 +58,16 @@ type IsSuccessCode<S extends number> = S extends SuccessCodeRange ? true : false
 type MaybeArray<T> = T | T[]
 type MaybePromise<T> = T | Promise<T>
 
+type SerializeQueryParams<T> = T extends Record<string, any>
+  ? {
+      [K in keyof T]: T[K] extends Date
+        ? string
+        : T[K] extends Date | undefined
+          ? string | undefined
+          : T[K]
+    }
+  : T
+
 export namespace Treaty {
     interface TreatyParam {
         fetch?: RequestInit
@@ -76,7 +86,7 @@ export namespace Treaty {
             : K]: K extends 'subscribe' // ? Websocket route
             ? MaybeEmptyObject<Route['subscribe']['headers'], 'headers'> &
                   MaybeEmptyObject<
-                      Route['subscribe']['query'],
+                      SerializeQueryParams<Route['subscribe']['query']>,
                       'query'
                   > extends infer Param
                 ? (options?: Param) => EdenWS<Route['subscribe']>
@@ -89,7 +99,7 @@ export namespace Treaty {
                     response: infer Res extends Record<number, unknown>
                 }
               ? MaybeEmptyObject<Headers, 'headers'> &
-                    MaybeEmptyObject<Query, 'query'> extends infer Param
+                    MaybeEmptyObject<SerializeQueryParams<Query>, 'query'> extends infer Param
                   ? {} extends Param
                       ? undefined extends Body
                           ? K extends 'get' | 'head'

test/types/treaty2.ts

@@ -31,6 +31,11 @@ const app = new Elysia()
             username: t.String()
         })
     })
+    .get('/date/query', ({ query }) => query, {
+        query: t.Object({
+            since: t.Date()
+        })
+    })
     .get('/queries', ({ query }) => query, {
         query: t.Object({
             username: t.String(),
@@ -499,6 +504,36 @@ type ValidationError = {
     >()
 }
 
+// ? Get should have 1 parameter with type string (for the underlying `t.Date` in the schema)
+{
+    type Route = api['date']['query']['get']
+
+    expectTypeOf<Route>().parameter(0).toEqualTypeOf<{
+        headers?: Record<string, unknown> | undefined
+        query: {
+            since: string
+        }
+        fetch?: RequestInit | undefined
+    }>()
+
+    expectTypeOf<Route>().parameter(1).toBeUndefined()
+
+    type Res = Result<Route>
+
+    expectTypeOf<Res>().toEqualTypeOf<
+        | {
+              data: {
+                  since: Date
+              }
+              error: null
+              response: Response
+              status: number
+              headers: HeadersInit | undefined
+          }
+        | ValidationError
+    >()
+}
+
 // ? Get should have 1 parameter and is required when query is defined
 {
     type Route = api['queries']['get']