Procedures

Introduction

In oRPC, a procedure consists of two main parts:

Contract: Defines the route, input, and output specifications
Implementation: Contains middleware and business logic handler

The contract part can be separated using the Contract-First approach, allowing for better code organization and team collaboration.

Anatomy of a Procedure

Here's a comprehensive example of an oRPC procedure:

import { z } from 'zod'
import { os, ORPCError } from '@orpc/server'
 
// Define context type for full type inference
const pub /* public access */ = os.context<{user?: {id: string}}>()
 
const findUser = pub
    .route({ method: 'GET', path: '/{id}' }) // Optional: if you want custom api under OpenAPI Specifications
    .input(z.object({ id: z.string() })) // Optional
    .output(z.object({ id: z.string(), name: z.string() })) // Optional
    .use(async (input, context, meta) => { // Optional
        // Middleware runs before the handler
        // input, context, and meta are fully typed
        
        // Example: Authentication check
        if (!context.user) {
            throw new ORPCError({
                code: 'UNAUTHORIZED',
                message: 'Authentication required'
            })
        }
 
        // Modify context for next middleware/handler
        const result = await meta.next({
            context: {
                user: context.user // TypeScript will infer user as NonNullable
            }
        })
 
        // do something on success
        const _output_is_typed = result.output
 
        return result
    })
    
    // Define handler with business logic
    .func(async (input, context, meta) => {
        // Implement your business logic here
        
        return {
            id: input.id,
            name: 'Sample User'
        }
    })

Introduction

Anatomy of a Procedure

On this page