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({
  getting: oc
    .input(
      z.object({
        name: z.string(),
      }),
    )
    .output(
      z.object({
        message: z.string(),
      }),
    ),
 
  post: oc.prefix('/posts').router({
    find: oc
      .route({
        path: '/{id}',
        method: 'GET',
      })
      .input(
        z.object({
          id: z.string(),
        }),
      )
      .output(
        z.object({
          id: z.string(),
          title: z.string(),
          description: z.string(),
        }),
      ),
 
    create: 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 /** public access */ = base.contract(contract) // Ensure every implement must be match contract
export const authed /** require authed */ = base
  .use((input, context, meta) => /** put auth logic here */ meta.next({}))
  .contract(contract)
 
export const router = pub.router({
  getting: pub.getting.func((input, context, meta) => {
    return {
      message: `Hello, ${input.name}!`,
    }
  }),
 
  post: {
    find: pub.post.find
      .func((input, context, meta) => {
        return {
          id: 'example',
          title: 'example',
          description: 'example',
        }
      }),
 
    create: authed.post.create.func((input, context, meta) => {
      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 GettingInput = Inputs['getting']
type PostFindOutput = Outputs['post']['find']