Event Iterator

import { createORPCClient } from '@orpc/client'
import { RPCLink } from '@orpc/client/fetch'
import { eventIterator, os, withEventMeta } from '@orpc/server'
import { z } from 'zod'
import type { RouterClient } from '@orpc/server'
 
// Define a streaming endpoint using the event iterator
const streaming = os
  // Validate the input with Zod
  .input(z.object({ prompt: z.string() }))
  // Use eventIterator to specify the streaming output (optional, but recommended)
  .output(eventIterator(z.object({ message: z.string() })))
  .handler(async function* ({ input, lastEventId }) {
    // The lastEventId (if provided) can be used to resume streaming on reconnects
    while (true) {
      // withEventMeta attaches metadata (e.g., event id, retry interval) to each event
      yield withEventMeta(
        { message: 'Hello, world!' },
        { id: 'some-id', retry: 1000 }
      )
      // Wait for 1 second before sending the next event
      await new Promise(resolve => setTimeout(resolve, 1000))
    }
  })
 
// Create a router with the streaming endpoint
const router = { streaming }
 
// Create an ORPC client and configure the SSE behavior
const client: RouterClient<typeof router> = createORPCClient(
  new RPCLink({
    url: 'http://localhost:3000/rpc',
    eventSourceMaxNumberOfRetries: 0, // Set to 0 to disable automatic retries on connection failure,
    // Optionally, you can configure:
    // - eventSourceRetryDelay: Delay between retry attempts
    // - eventSourceRetry: Custom retry behavior
  })
)
 
// Invoke the streaming endpoint with an initial prompt and optional lastEventId
const result = await client.streaming(
  { prompt: 'Hello' },
  { lastEventId: 'you also can pass initial last event id here' }
)
 
// Process the incoming stream of events using async iteration
for await (const event of result) {
  console.log(event)
}
 
// To close the connection manually, call result.return()