Contract

import { oc } from '@orpc/contract'
import { oz } from '@orpc/zod'
import { z } from 'zod'
 
// Define your contract first
// This contract can replace server router in most-case
 
export const contract = oc.router({
  getUser: oc
    .input(
      z.object({
        id: z.string(),
      }),
    )
    .output(
      z.object({
        username: z.string(),
        avatar: z.string(),
      }),
    ),
 
  posts: oc.prefix('/posts').router({
    getPost: oc
      .route({
        path: '/{id}',
        method: 'GET',
      })
      .input(
        z.object({
          id: z.string(),
        }),
      )
      .output(
        z.object({
          id: z.string(),
          title: z.string(),
          description: z.string(),
        }),
      ),
 
    createPost: oc
      .input(
        z.object({
          title: z.string(),
          description: z.string(),
          thumb: oz.file().type('image/*'),
        }),
      )
      .output(
        z.object({
          id: z.string(),
          title: z.string(),
          description: z.string(),
        }),
      ),
  }),
})

import { os } from '@orpc/server'
import { contract } from 'examples/contract'
 
export type Context = { user?: { id: string } }
export const base = os.context<Context>()
export const pub = base.contract(contract) // Ensure every implement must be match contract
export const authed = base
  .use(({ context, path, next }, input) => {
    /** put auth logic here */
    return next({})
  })
  .contract(contract)
 
export const router = pub.router({
  getUser: pub.getUser.handler(({ input, context }) => {
    return {
      username: 'example',
      avatar: 'example',
    }
  }),
 
  posts: {
    getPost: pub.posts.getPost
      .handler(({ input, context }) => {
        return {
          id: 'example',
          title: 'example',
          description: 'example',
        }
      }),
 
    createPost: authed.posts.createPost.handler(({ input, context }) => {
      return {
        id: 'example',
        title: input.title,
        description: input.description,
      }
    }),
  },
})

import { type InferContractRouterInputs, type InferContractRouterOutputs } from '@orpc/contract'
import { contract } from 'examples/contract'
 
type Inputs = InferContractRouterInputs<typeof contract>
type Outputs = InferContractRouterOutputs<typeof contract>
 
type GetUserInput = Inputs['getUser']
type GetPostOutput = Outputs['posts']['getPost']