Client

// server.ts
export const appRouter = s.router({
  users: {
    list: listUsers,
    create: createUser,
  },
})
export type AppRouter = typeof appRouter

import type { AppRouter } from './server'

const client = createClient<AppRouter>(link)

import type { InferClient } from 'silgi'

type Client = InferClient<typeof appRouter>
// Client.users.list: (input: { limit?: number }) => Promise<User[]>
// Client.users.create: (input: { name: string }) => Promise<User>

const link = createLink({
  url: 'http://localhost:3000',
  headers: () => ({
    Authorization: `Bearer ${getToken()}`,
  }),
})

const link = createLink({
  url: 'http://localhost:3000',
  retry: 3, // retry up to 3 times on failure
  retryDelay: 1000, // wait 1 second between retries
  timeout: 10_000, // 10 second timeout per request
})

const link = createLink({
  url: 'http://localhost:3000',
  retry: 3,
  retryDelay: (ctx) => Math.pow(2, ctx.options?.retryCount ?? 0) * 500,
  // 500ms, 1000ms, 2000ms
})

const link = createLink({
  url: 'http://localhost:3000',
  protocol: 'messagepack',
})

const link = createLink({
  url: 'http://localhost:3000',
  onRequest({ request, options }) {
    // Runs before every request is sent
    console.log('Sending:', request)
  },
  onResponse({ response }) {
    // Runs after every successful response
    console.log('Received:', response.status)
  },
  onRequestError({ error }) {
    // Runs when the request fails (network error, DNS failure, etc.)
    console.error('Request failed:', error)
  },
  onResponseError({ response }) {
    // Runs when the server responds with an error status
    console.error('Server error:', response.status)
  },
})

import { createMisina } from 'misina'
import { createClient } from 'silgi/client'
import { createLink } from 'silgi/client/misina'

const link = createLink({
  url: 'http://localhost:3000',
  misina: createMisina({
    retry: 2,
    idempotencyKey: 'auto',
  }),
})

const client = createClient<AppRouter>(link)

import { createMisina } from 'misina'

const link = createLink({
  url: 'http://localhost:3000',
  misina: createMisina({
    retry: {
      limit: 3,
      delay: (attempt) => 0.3 * 2 ** (attempt - 1) * 1000, // 300ms, 600ms, 1200ms
      backoffLimit: 30_000,
      jitter: true,
      statusCodes: [408, 429, 500, 502, 503, 504],
    },
  }),
})

import { createMisina } from 'misina'

const link = createLink({
  url: 'http://localhost:3000',
  misina: createMisina({
    hooks: {
      beforeRequest: (ctx) => {
        const headers = new Headers(ctx.request.headers)
        headers.set('x-trace-id', crypto.randomUUID())
        return new Request(ctx.request, { headers })
      },
      afterResponse: ({ response }) => {
        if (response) console.log('status:', response.status)
      },
      onComplete: ({ request, durationMs, attempt, error }) => {
        metrics.observe('rpc.duration', durationMs, {
          url: request.url,
          attempts: String(attempt + 1),
          ok: error ? 'false' : 'true',
        })
      },
    },
  }),
})

import { createMisina } from 'misina'
import { bearer, refreshOn401 } from 'misina/auth'
import { cache, memoryStore } from 'misina/cache'
import { breaker } from 'misina/breaker'
import { dedupe } from 'misina/dedupe'

const link = createLink({
  url: 'http://localhost:3000',
  misina: createMisina({
    baseURL: 'http://localhost:3000',
    retry: 3,
    idempotencyKey: 'auto',
    use: [
      bearer(() => store.token),
      refreshOn401({ refresh: async () => fetchNewToken() }),
      cache({ store: memoryStore({ max: 500 }), ttl: 60_000 }),
      breaker({ failureThreshold: 5, windowMs: 30_000 }),
      dedupe(),
    ],
  }),
})

const controller = new AbortController()

const users = await client.users.list({ limit: 10 }, { signal: controller.signal })

// Cancel the request at any time
controller.abort()

import { SilgiError } from 'silgi'

try {
  await client.users.delete({ id: 1 })
} catch (error) {
  if (error instanceof SilgiError) {
    console.log(error.code) // "FORBIDDEN"
    console.log(error.status) // 403
    console.log(error.data) // { reason: "Not the owner" }
  }
}

import { safe } from 'silgi/client'

const { error, data, isError, isSuccess } = await safe(client.users.delete({ id: 1 }))

if (isError) {
  console.log(error.code) // "FORBIDDEN"
} else {
  console.log(data) // the deleted user
}

import { createSafeClient } from 'silgi/client'

const client = createSafeClient<AppRouter>(link)

const { error, data, isError, isSuccess } = await client.users.list({ limit: 10 })
// Every call returns SafeResult — no try/catch needed anywhere

import { createServerClient } from 'silgi/client/server'

const client = createServerClient(appRouter, {
  context: () => ({ db: getDB() }),
})

// Same API as the HTTP client — but runs in-process
const users = await client.users.list({ limit: 10 })
const user = await client.users.create({ name: 'Alice' })

import { createClient, DynamicLink } from 'silgi/client'

const link = new DynamicLink((path, input, options) => {
  if (path[0] === 'admin') return adminLink
  return defaultLink
})

const client = createClient<AppRouter>(link)

const link = new DynamicLink(async (path) => {
  if (path[0] === 'analytics') {
    const { createLink } = await import('silgi/client/ofetch')
    return createLink({ url: 'https://analytics.example.com' })
  }
  return defaultLink
})

import { withInterceptors } from 'silgi/client'

const link = withInterceptors(baseLink, {
  onRequest({ path, input }) {
    console.log(`-> ${path.join('/')}`)
  },
  onResponse({ path, durationMs }) {
    console.log(`<- ${path.join('/')} (${durationMs}ms)`)
  },
  onError({ path, error }) {
    reportToSentry(error)
  },
})

import { consumeIterator } from 'silgi/client/consume'

const iterator = await client.events.subscribe()

await consumeIterator(iterator, {
  onEvent: (data) => console.log('Event:', data),
  onError: (err) => console.error('Error:', err),
  onFinish: () => console.log('Stream ended'),
  signal: controller.signal, // optional abort
})

import { consumeWithReconnect } from 'silgi/client/consume'

await consumeWithReconnect({
  connect: (lastEventId) => client.events.subscribe(undefined, { lastEventId }),
  onEvent: (data) => updateUI(data),
  onReconnect: (attempt) => console.log(`Reconnecting (#${attempt})...`),
  maxReconnects: 10,
  reconnectDelay: 2000,
})

import { mapIterator } from 'silgi/client/consume'

const mapped = mapIterator(iterator, (event) => ({
  ...event,
  receivedAt: Date.now(),
}))