@orpc/server 0.0.0 → 0.0.3

package/src/adapters/fetch.test.ts

@@ -195,7 +195,7 @@ describe('procedure throw error', () => {
         .input(z.object({}))
         .output(z.string())
         .handler(() => {
-          return 'dinwwwh'
+          return 'unnoq'
         }),
     })
 
@@ -332,7 +332,7 @@ describe('file upload', () => {
 
   const blob1 = new Blob(['hello'], { type: 'text/plain;charset=utf-8' })
   const blob2 = new Blob(['"world"'], { type: 'image/png' })
-  const blob3 = new Blob(['dinwwwh'], { type: 'application/octet-stream' })
+  const blob3 = new Blob(['unnoq'], { type: 'application/octet-stream' })
 
   it('single file', async () => {
     const rForm = new FormData()
@@ -358,7 +358,7 @@ describe('file upload', () => {
     expect(file0).toBeInstanceOf(File)
     expect(file0.name).toBe('blob')
     expect(file0.type).toBe('application/octet-stream')
-    expect(await file0.text()).toBe('dinwwwh')
+    expect(await file0.text()).toBe('unnoq')
   })
 
   it('multiple file', async () => {
@@ -397,3 +397,159 @@ describe('file upload', () => {
     expect(await file1.text()).toBe('"world"')
   })
 })
+
+describe('accept header', () => {
+  const router = os.router({
+    ping: os.handler(async () => 'pong'),
+  })
+  const handler = createFetchHandler({
+    router,
+  })
+
+  it('application/json', async () => {
+    const response = await handler({
+      prefix: '/orpc',
+      request: new Request('http://localhost/orpc/ping', {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+        },
+      }),
+    })
+
+    expect(response.headers.get('Content-Type')).toEqual('application/json')
+
+    expect(await response.json()).toEqual('pong')
+  })
+
+  it('multipart/form-data', async () => {
+    const response = await handler({
+      prefix: '/orpc',
+      request: new Request('http://localhost/orpc/ping', {
+        method: 'POST',
+        headers: {
+          Accept: 'multipart/form-data',
+        },
+      }),
+    })
+
+    expect(response.headers.get('Content-Type')).toContain(
+      'multipart/form-data',
+    )
+
+    const form = await response.formData()
+    expect(form.get('')).toEqual('pong')
+  })
+
+  it('application/x-www-form-urlencoded', async () => {
+    const response = await handler({
+      prefix: '/orpc',
+      request: new Request('http://localhost/orpc/ping', {
+        method: 'POST',
+        headers: {
+          Accept: 'application/x-www-form-urlencoded',
+        },
+      }),
+    })
+
+    expect(response.headers.get('Content-Type')).toEqual(
+      'application/x-www-form-urlencoded',
+    )
+
+    const params = new URLSearchParams(await response.text())
+    expect(params.get('')).toEqual('pong')
+  })
+
+  it('*/*', async () => {
+    const response = await handler({
+      prefix: '/orpc',
+      request: new Request('http://localhost/orpc/ping', {
+        method: 'POST',
+        headers: {
+          Accept: '*/*',
+        },
+      }),
+    })
+
+    expect(response.headers.get('Content-Type')).toEqual('application/json')
+    expect(await response.json()).toEqual('pong')
+  })
+
+  it('invalid', async () => {
+    const response = await handler({
+      prefix: '/orpc',
+      request: new Request('http://localhost/orpc/ping', {
+        method: 'POST',
+        headers: {
+          Accept: 'invalid',
+        },
+      }),
+    })
+
+    expect(response.headers.get('Content-Type')).toEqual('application/json')
+    expect(await response.json()).toEqual({
+      code: 'NOT_ACCEPTABLE',
+      message: 'Unsupported content-type: invalid',
+      status: 406,
+    })
+  })
+})
+
+describe('dynamic params', () => {
+  const router = os.router({
+    deep: os
+      .route({
+        method: 'GET',
+        path: '/{id}/{id2}',
+      })
+      .input(
+        z.object({
+          id: z.number(),
+          id2: z.string(),
+        }),
+      )
+      .handler((input) => input),
+
+    find: os
+      .route({
+        method: 'GET',
+        path: '/{id}',
+      })
+      .input(
+        z.object({
+          id: z.number(),
+        }),
+      )
+      .handler((input) => input),
+  })
+
+  const handlers = [
+    createFetchHandler({
+      router,
+    }),
+    createFetchHandler({
+      router,
+      serverless: true,
+    }),
+  ]
+
+  it.each(handlers)('should handle dynamic params', async (handler) => {
+    const response = await handler({
+      request: new Request('http://localhost/123'),
+    })
+
+    expect(response.status).toEqual(200)
+    expect(response.headers.get('Content-Type')).toEqual('application/json')
+    expect(await response.json()).toEqual({ id: 123 })
+  })
+
+  it.each(handlers)('should handle deep dynamic params', async (handler) => {
+    const response = await handler({
+      request: new Request('http://localhost/123/dfdsfds'),
+    })
+
+    expect(response.status).toEqual(200)
+    expect(response.headers.get('Content-Type')).toEqual('application/json')
+    expect(await response.json()).toEqual({ id: 123, id2: 'dfdsfds' })
+  })
+})

package/src/adapters/fetch.ts

@@ -10,6 +10,7 @@ import {
   type PartialOnUndefinedDeep,
   get,
   isPlainObject,
+  mapValues,
   trim,
 } from '@orpc/shared'
 import { ORPCError } from '@orpc/shared/error'
@@ -18,6 +19,7 @@ import {
   ORPCSerializer,
   OpenAPIDeserializer,
   OpenAPISerializer,
+  zodCoerce,
 } from '@orpc/transformer'
 import { LinearRouter } from 'hono/router/linear-router'
 import { RegExpRouter } from 'hono/router/reg-exp-router'
@@ -73,7 +75,7 @@ export function createFetchHandler<TRouter extends Router<any>>(
   return async (requestOptions) => {
     const isORPCTransformer =
       requestOptions.request.headers.get(ORPC_HEADER) === ORPC_HEADER_VALUE
-    const accept = requestOptions.request.headers.get('Accept') ?? undefined
+    const accept = requestOptions.request.headers.get('Accept') || undefined
 
     const serializer = isORPCTransformer
       ? new ORPCSerializer()
@@ -86,7 +88,7 @@ export function createFetchHandler<TRouter extends Router<any>>(
 
         let path: string[] | undefined
         let procedure: WELL_DEFINED_PROCEDURE | undefined
-        let params: Record<string, string | number> | undefined
+        let params: Record<string, string> | undefined
 
         if (isORPCTransformer) {
           path = trim(pathname, '/').split('/').map(decodeURIComponent)
@@ -96,13 +98,28 @@ export function createFetchHandler<TRouter extends Router<any>>(
             procedure = val
           }
         } else {
-          const [[match]] = routing.match(
+          const [matches, params_] = routing.match(
             requestOptions.request.method,
             pathname,
           )
-          path = match?.[0][0]
-          procedure = match?.[0][1]
-          params = match?.[1]
+
+          const [match] = matches.sort((a, b) => {
+            return Object.keys(a[1]).length - Object.keys(b[1]).length
+          })
+
+          if (match) {
+            path = match[0][0]
+            procedure = match[0][1]
+
+            if (params_) {
+              params = mapValues(
+                (match as any)[1]!,
+                (v) => params_[v as number]!,
+              )
+            } else {
+              params = match[1] as Record<string, string>
+            }
+          }
 
           if (!path || !procedure) {
             path = trim(pathname, '/').split('/').map(decodeURIComponent)
@@ -148,18 +165,28 @@ export function createFetchHandler<TRouter extends Router<any>>(
         })()
 
         const input = (() => {
-          if (
-            params &&
-            Object.keys(params).length > 0 &&
-            (input_ === undefined || isPlainObject(input_))
-          ) {
-            return {
-              ...params,
-              ...input_,
-            }
+          if (!params || Object.keys(params).length === 0) {
+            return input_
+          }
+
+          const coercedParams = procedure.zz$p.contract.zz$cp.InputSchema
+            ? (zodCoerce(
+                procedure.zz$p.contract.zz$cp.InputSchema,
+                { ...params },
+                {
+                  bracketNotation: true,
+                },
+              ) as object)
+            : params
+
+          if (input_ !== undefined && !isPlainObject(input_)) {
+            return coercedParams
           }
 
-          return input_
+          return {
+            ...coercedParams,
+            ...input_,
+          }
         })()
 
         const caller = createProcedureCaller({
@@ -180,21 +207,28 @@ export function createFetchHandler<TRouter extends Router<any>>(
         })
       })
     } catch (e) {
-      const error =
-        e instanceof ORPCError
-          ? e
-          : new ORPCError({
-              code: 'INTERNAL_SERVER_ERROR',
-              message: 'Internal server error',
-              cause: e,
-            })
+      const error = toORPCError(e)
 
-      const { body, headers } = serializer.serialize(error.toJSON())
+      try {
+        const { body, headers } = serializer.serialize(error.toJSON())
 
-      return new Response(body, {
-        status: error.status,
-        headers: headers,
-      })
+        return new Response(body, {
+          status: error.status,
+          headers: headers,
+        })
+      } catch (e) {
+        const error = toORPCError(e)
+
+        // fallback to OpenAPI serializer (without accept) when expected serializer has failed
+        const { body, headers } = new OpenAPISerializer().serialize(
+          error.toJSON(),
+        )
+
+        return new Response(body, {
+          status: error.status,
+          headers: headers,
+        })
+      }
     }
   }
 }
@@ -226,3 +260,13 @@ export type FetchHandlerOptions<TRouter extends Router<any>> = {
 export interface FetchHandler<TRouter extends Router<any>> {
   (options: FetchHandlerOptions<TRouter>): Promise<Response>
 }
+
+function toORPCError(e: unknown): ORPCError<any, any> {
+  return e instanceof ORPCError
+    ? e
+    : new ORPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: 'Internal server error',
+        cause: e,
+      })
+}

package/src/procedure-builder.test.ts

@@ -8,7 +8,7 @@ import type { Meta } from './types'
 const schema1 = z.object({ id: z.string() })
 const example1 = { id: '1' }
 const schema2 = z.object({ name: z.string() })
-const example2 = { name: 'dinwwwh' }
+const example2 = { name: 'unnoq' }
 
 const builder = new ProcedureBuilder<
   { auth: boolean },
@@ -200,7 +200,7 @@ describe('handler', () => {
         expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
 
         return {
-          name: 'dinwwwh',
+          name: 'unnoq',
         }
       })
 

package/src/procedure-implementer.test.ts

@@ -145,7 +145,7 @@ describe('handler', () => {
       expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
 
       return {
-        name: 'dinwwwh',
+        name: 'unnoq',
       }
     })
 
@@ -166,7 +166,7 @@ describe('handler', () => {
       expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
 
       return {
-        name: 'dinwwwh',
+        name: 'unnoq',
       }
     })
 
@@ -196,7 +196,7 @@ describe('handler', () => {
         expectTypeOf(meta).toEqualTypeOf<Meta<unknown>>()
 
         return {
-          name: 'dinwwwh',
+          name: 'unnoq',
         }
       })
 

package/src/procedure.test.ts

@@ -157,7 +157,7 @@ describe('route method', () => {
 
 test('prefix method', () => {
   const p = os.context<{ auth: boolean }>().handler(() => {
-    return 'dinwwwh'
+    return 'unnoq'
   })
 
   const p2 = p.prefix('/test')
@@ -168,7 +168,7 @@ test('prefix method', () => {
     .context<{ auth: boolean }>()
     .route({ path: '/test1' })
     .handler(() => {
-      return 'dinwwwh'
+      return 'unnoq'
     })
 
   const p4 = p3.prefix('/test')
@@ -183,7 +183,7 @@ describe('use middleware', () => {
         return { context: { postId: 'string' } }
       })
       .handler(() => {
-        return 'dinwwwh'
+        return 'unnoq'
       })
 
     const p2 = p1
@@ -246,7 +246,7 @@ describe('use middleware', () => {
     const mid2 = vi.fn()
     const mid3 = vi.fn()
 
-    const p1 = os.use(mid1).handler(() => 'dinwwwh')
+    const p1 = os.use(mid1).handler(() => 'unnoq')
     const p2 = p1.use(mid2).use(mid3)
 
     expect(p2.zz$p.middlewares).toEqual([mid3, mid2, mid1])

package/src/router-implementer.test.ts

@@ -18,15 +18,15 @@ const cr = oc.router({
 const osw = os.context<{ auth: boolean }>().contract(cr)
 
 const p1 = osw.p1.handler(() => {
-  return 'dinwwwh'
+  return 'unnoq'
 })
 
 const p2 = osw.nested.p2.handler(() => {
-  return 'dinwwwh'
+  return 'unnoq'
 })
 
 const p3 = osw.nested2.p3.handler(() => {
-  return 'dinwwwh'
+  return 'unnoq'
 })
 
 it('required all procedure match', () => {
@@ -76,7 +76,7 @@ it('required all procedure match', () => {
       p1: os
         .input(z.string())
         .output(z.string())
-        .handler(() => 'dinwwwh'),
+        .handler(() => 'unnoq'),
       nested: {
         p2: p2,
       },

package/src/router.test.ts

@@ -12,7 +12,7 @@ it('require procedure match context', () => {
 
     // @ts-expect-error userId is not match
     ping2: osw.context<{ userId: number }>().handler(() => {
-      return { name: 'dinwwwh' }
+      return { name: 'unnoq' }
     }),
 
     nested: {
@@ -22,7 +22,7 @@ it('require procedure match context', () => {
 
       // @ts-expect-error userId is not match
       ping2: osw.context<{ userId: number }>().handler(() => {
-        return { name: 'dinwwwh' }
+        return { name: 'unnoq' }
       }),
     },
   })
@@ -121,18 +121,18 @@ it('toContractRouter', () => {
 
   const router = osw.router({
     p1: osw.p1.handler(() => {
-      return 'dinwwwh'
+      return 'unnoq'
     }),
 
     nested: osw.nested.router({
       p2: osw.nested.p2.handler(() => {
-        return 'dinwwwh'
+        return 'unnoq'
       }),
     }),
 
     nested2: {
       p3: osw.nested2.p3.handler(() => {
-        return 'dinwwwh'
+        return 'unnoq'
       }),
     },
   })