Server

import { silgi } from 'silgi'
import { z } from 'zod'

const s = silgi({
  context: (req) => ({ db: getDB() }),
})

const appRouter = s.router({
  health: s.$resolve(() => ({ status: 'ok' })),
})

s.serve(appRouter, {
  port: 3000,
})

const server = await s.serve(appRouter, { port: 3000 })

// Later — gracefully shut down
await server.close()

s.serve(appRouter, {
  port: 3000, // auto-finds next available if busy
  hostname: '0.0.0.0', // bind to all interfaces
  basePath: '/api', // mount under /api prefix
  scalar: true, // API docs at /api/reference
  // ws is auto-enabled when the router contains a subscription.
  // Pass ws: false to disable, or ws: { compress, keepalive, ... } to configure crossws.
  http2: {
    // HTTP/2 with TLS
    cert: './certs/cert.pem',
    key: './certs/key.pem',
  },
  gracefulShutdown: true, // default — shuts down cleanly on SIGINT/SIGTERM
})

const handle = s.handler(appRouter)
// handle is: (request: Request) => Promise<Response>

export default {
  fetch: s.handler(appRouter),
}

const handle = s.handler(appRouter, {
  basePath: '/api', // only handle /api/* requests, strip prefix before routing
  scalar: true, // serves /api/openapi.json and /api/reference
})

s.serve(appRouter, {
  port: 3000,
  scalar: true,
})

s.serve(appRouter, {
  scalar: {
    title: 'My API',
    description: 'Built with Silgi',
    version: '2.0.0',
    servers: [{ url: 'https://api.example.com' }],
    contact: { email: '[email protected]' },
    security: { type: 'http', scheme: 'bearer', bearerFormat: 'JWT' },
  },
})

s.serve(appRouter, {
  scalar: {
    title: 'My API',
    cdn: 'local', // serve from node_modules (offline)
  },
})

const listUsers = s
  .$input(z.object({ limit: z.number().optional() }))
  .$route({
    summary: 'List all users',
    description: 'Returns a paginated list of users, ordered by creation date.',
    tags: ['users'],
  })
  .$resolve(({ input, ctx }) => ctx.db.users.findMany({ take: input.limit }))

// Shorthand: cache for 60 seconds
const listUsers = s.$route({ cache: 60 }).$resolve(({ ctx }) => ctx.db.users.findMany())

// Full control: custom Cache-Control value
const getConfig = s.$route({ cache: 'public, max-age=300, stale-while-revalidate=60' }).$resolve(() => loadConfig())

s.serve(appRouter, {
  port: 443,
  http2: {
    cert: './certs/cert.pem',
    key: './certs/key.pem',
  },
})

s.serve(appRouter, { port: 3000 })

s.serve(appRouter, {
  port: 3000,
  ws: {
    compress: true, // enable per-message-deflate compression
    maxPayload: 1_048_576, // 1 MB max message size (default)
    keepalive: 30_000, // ping every 30s, terminate unresponsive peers
  },
})

import { attachWebSocket } from 'silgi/ws'

attachWebSocket(httpServer, appRouter, {
  compress: true,
  keepalive: 60_000,
  maxPayload: 5 * 1024 * 1024, // 5 MB
})

const server = await s.serve(appRouter, {
  port: 3000,
  gracefulShutdown: true, // default
})

const server = await s.serve(appRouter, { port: 3000 })

// Graceful — waits for in-flight requests
await server.close()

// Force — immediately terminates all connections
await server.close(true)

s.serve(appRouter, {
  gracefulShutdown: {
    timeout: 10_000, // wait up to 10s for in-flight requests
    forceTimeout: 15_000, // force-kill after 15s
  },
})

const s = silgi({
  context: (req) => ({ db: getDB() }),
  hooks: {
    'serve:stop': async ({ url }) => {
      await db.end()
      console.log(`Server at ${url} stopped`)
    },
  },
})

const s = silgi({
  context: (req) => ({ db: getDB() }),
  hooks: {
    request: ({ path, input }) => {
      console.log(`--> ${path}`)
    },
    response: ({ path, output, durationMs }) => {
      console.log(`<-- ${path} (${durationMs.toFixed(1)}ms)`)
    },
    error: ({ path, error }) => {
      console.error(`ERR ${path}:`, error)
    },
    'serve:start': ({ url, port, hostname }) => {
      console.log(`Server ready at ${url}`)
    },
  },
})

// Add a hook
s.hook('error', ({ error }) => reportToSentry(error))

// Remove a hook
s.removeHook('error', myHookFn)

const downloadPdf = s.$input(z.object({ id: z.string() })).$resolve(async ({ input, ctx }) => {
  const pdf = await ctx.storage.getFile(input.id)
  return new Response(pdf, {
    headers: {
      'content-type': 'application/pdf',
      'content-disposition': `attachment; filename="${input.id}.pdf"`,
    },
  })
})

const exportCsv = s.$resolve(async ({ ctx }) => {
  return new ReadableStream({
    async start(controller) {
      controller.enqueue(new TextEncoder().encode('id,name\n'))
      for await (const user of ctx.db.users.cursor()) {
        controller.enqueue(new TextEncoder().encode(`${user.id},${user.name}\n`))
      }
      controller.close()
    },
  })
})

import { callable } from 'silgi'

const getUsers = s
  .$input(z.object({ limit: z.number().optional() }))
  .$resolve(({ input, ctx }) => ctx.db.users.findMany({ take: input.limit }))

const getUsersFn = callable(getUsers, {
  context: () => ({ db: getDB() }),
  timeout: 5000, // optional — default 30s, null to disable
})

// Direct call — compiled pipeline, no HTTP
const users = await getUsersFn({ limit: 10 })