End-to-End Typesafe API Builder for Developers

import type { InferRouterInputs, InferRouterOutputs } from '@orpc/server'
import { ORPCError, os } from '@orpc/server'
import { oz } from '@orpc/zod'
import { z } from 'zod'
 
export type Context = { user?: { id: string } }
 
// global pub, authed completely optional
export const pub /** public access */ = os.context<Context>()
export const authed /** require authed */ = pub.use((input, context, meta) => /** put auth logic here */ meta.next({}))
 
export const router = pub.router({
  getting: os
    .input(
      z.object({
        name: z.string(),
      }),
    )
    .func(async (input, context, meta) => {
      return {
        message: `Hello, ${input.name}!`,
      }
    }),
 
  post: pub.prefix('/posts').router({
    find: pub
      .route({
        path: '/{id}', // custom your OpenAPI
        method: 'GET',
      })
      .input(
        z.object({
          id: z.string({}),
        }),
      )
      .output(
        z.object({
          id: z.string(),
          title: z.string(),
          description: z.string(),
        }),
      )
      .use(async (input, context, meta) => {
        if (!context.user) {
          throw new ORPCError({
            code: 'UNAUTHORIZED',
          })
        }
 
        const result = await meta.next({
          context: {
            user: context.user, // from now user not undefined-able
          },
        })
 
        const _output = result.output // do something on success
 
        return result
      })
      .func((input, context, meta) => {
        return {
          id: 'example',
          title: 'example',
          description: 'example',
        }
      }),
 
    create: authed
      .input(
        z.object({
          title: z.string(),
          description: z.string(),
          thumb: oz.file().type('image/*'),
        }),
      )
      .func(async (input, context, meta) => {
        const _thumb = input.thumb // file upload out of the box
 
        return {
          id: 'example',
          title: input.title,
          description: input.description,
        }
      }),
  }),
})
 
export type Inputs = InferRouterInputs<typeof router>
export type Outputs = InferRouterOutputs<typeof router>
 
// Expose apis to the internet with fetch handler
import { createOpenAPIServerlessHandler } from '@orpc/openapi/fetch'
import { createORPCHandler, handleFetchRequest } from '@orpc/server/fetch'
// Modern runtime that support fetch api like deno, bun, cloudflare workers, even node can used
import { createServer } from 'node:http'
import { createServerAdapter } from '@whatwg-node/server'
 
const server = createServer(
  createServerAdapter((request: Request) => {
    const url = new URL(request.url)
 
    if (url.pathname.startsWith('/api')) {
      return handleFetchRequest({
        router,
        request,
        prefix: '/api',
        context: {},
        handlers: [
          createORPCHandler(),
          createOpenAPIServerlessHandler(),
        ],
      })
    }
 
    return new Response('Not found', { status: 404 })
  }),
)
 
server.listen(3000, () => {
  // eslint-disable-next-line no-console
  console.log('Server is available at http://localhost:3000')
})
 
//
//
 
export default router

import { createORPCClient, ORPCError } from '@orpc/client'
import type { router } from 'examples/server'
 
const client = createORPCClient<typeof router /* or contract router */>({
  baseURL: 'http://localhost:3000/api',
  // fetch: optional override for the default fetch function
  // headers: provide additional headers
})
 
//  File upload out of the box
const output = await client.post.create({
  title: 'My Amazing Title',
  description: 'This is a detailed description of my content',
  thumb: (document.getElementById('thumb') as HTMLInputElement).files[0]!,
})
 
client.post.
create
find
 
 
 
 
// typesafe and completion out of box
 
 
try {
  const post = await client.post.find({ id: 'example' })
} catch (error) {
  if (error instanceof ORPCError) {
    // handle error
  }
}