@silkweave/trpc 1.7.0

package/eslint.config.mjs

@@ -0,0 +1,93 @@
+import eslint from '@eslint/js'
+import stylistic from '@stylistic/eslint-plugin'
+import { defineConfig } from 'eslint/config'
+import tseslint from 'typescript-eslint'
+
+export default defineConfig(eslint.configs.recommended, tseslint.configs.recommendedTypeChecked, tseslint.configs.stylisticTypeChecked, {
+  languageOptions: {
+    parserOptions: {
+      project: 'tsconfig.json',
+      tsconfigRootDir: import.meta.dirname
+    }
+  },
+  plugins: { '@stylistic': stylistic },
+  rules: {
+    '@stylistic/space-in-parens': ['error'],
+    '@stylistic/comma-spacing': ['error'],
+    '@stylistic/no-multi-spaces': ['error'],
+    '@stylistic/no-trailing-spaces': ['error'],
+    '@stylistic/no-whitespace-before-property': ['error'],
+    '@stylistic/array-bracket-newline': ['error', 'consistent'],
+    '@stylistic/array-bracket-spacing': ['error'],
+    '@stylistic/arrow-spacing': ['error'],
+    '@stylistic/arrow-parens': ['error', 'always'],
+    '@stylistic/block-spacing': ['error', 'always'],
+    '@stylistic/brace-style': ['error', '1tbs', { 'allowSingleLine': true }],
+    '@stylistic/comma-dangle': ['error', 'never'],
+    '@stylistic/key-spacing': ['error'],
+    '@stylistic/keyword-spacing': ['error'],
+    '@stylistic/member-delimiter-style': ['error', { 'multiline': { 'delimiter': 'none' } }],
+    '@stylistic/no-extra-semi': ['error'],
+    '@stylistic/indent': ['error', 2],
+    '@stylistic/no-multiple-empty-lines': ['error', { 'max': 1, 'maxEOF': 0, 'maxBOF': 0 }],
+    '@stylistic/object-curly-spacing': ['error', 'always'],
+    '@stylistic/quotes': ['error', 'single'],
+    '@stylistic/semi': ['error', 'never'],
+    '@stylistic/space-before-blocks': ['error', 'always'],
+    '@stylistic/space-before-function-paren': ['error', { 'anonymous': 'always', 'named': 'never', 'asyncArrow': 'always' }],
+    '@typescript-eslint/adjacent-overload-signatures': 'error',
+    '@typescript-eslint/array-type': 'off',
+    '@typescript-eslint/await-thenable': 'error',
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/consistent-type-assertions': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-member-accessibility': 'off',
+    '@typescript-eslint/no-angle-bracket-type-assertion': 'off',
+    '@typescript-eslint/no-empty-function': 'off',
+    '@typescript-eslint/no-empty-interface': 'off',
+    '@typescript-eslint/no-extra-non-null-assertion': 'error',
+    '@typescript-eslint/no-floating-promises': 'off',
+    '@typescript-eslint/no-misused-new': 'error',
+    '@typescript-eslint/no-misused-promises': 'off',
+    '@typescript-eslint/no-namespace': 'off',
+    '@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
+    '@typescript-eslint/no-non-null-assertion': 'off',
+    '@typescript-eslint/no-object-literal-type-assertion': 'off',
+    '@typescript-eslint/no-parameter-properties': 'off',
+    '@typescript-eslint/no-shadow': 'error',
+    '@typescript-eslint/no-triple-slash-reference': 'off',
+    '@typescript-eslint/no-unused-vars': ['error', {
+      'args': 'all',
+      'argsIgnorePattern': '^_',
+      'caughtErrors': 'all',
+      'caughtErrorsIgnorePattern': '^_',
+      'destructuredArrayIgnorePattern': '^_',
+      'varsIgnorePattern': '^_',
+      'ignoreRestSiblings': true
+    }],
+    '@typescript-eslint/no-use-before-define': 'off',
+    '@typescript-eslint/no-var-requires': 'off',
+    '@typescript-eslint/prefer-for-of': 'error',
+    '@typescript-eslint/prefer-interface': 'off',
+    '@typescript-eslint/prefer-nullish-coalescing': 'off',
+    '@typescript-eslint/prefer-optional-chain': 'error',
+    '@typescript-eslint/return-await': 'error',
+    '@typescript-eslint/unified-signatures': 'error',
+    '@typescript-eslint/no-unsafe-return': 'off',
+    '@typescript-eslint/no-redundant-type-constituents': 'off',
+    '@typescript-eslint/no-unsafe-member-access': 'off',
+    '@typescript-eslint/no-unsafe-call': 'off',
+    '@typescript-eslint/no-unsafe-argument': 'off',
+    '@typescript-eslint/dot-notation': 'off',
+    '@typescript-eslint/prefer-regexp-exec': 'off',
+    '@typescript-eslint/require-await': 'off',
+    '@typescript-eslint/only-throw-error': 'error',
+    '@typescript-eslint/no-base-to-string': 'off',
+    '@typescript-eslint/restrict-template-expressions': 'off'
+  }
+}, {
+  files: ['eslint.config.mjs'],
+  extends: [tseslint.configs.disableTypeChecked]
+}, {
+  ignores: ['build', 'tsdown.config.ts', 'scratch']
+})

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@silkweave/trpc",
+  "version": "1.7.0",
+  "description": "Silkweave tRPC Adapter",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/silkweave/silkweave.git",
+    "directory": "packages/trpc"
+  },
+  "type": "module",
+  "main": "build/index.mjs",
+  "dependencies": {
+    "@trpc/server": "^11.7.1",
+    "change-case": "^5.4.4",
+    "cors": "^2.8.5",
+    "zod": "^4.3.6",
+    "@silkweave/auth": "1.7.0",
+    "@silkweave/core": "1.7.0",
+    "@silkweave/logger": "1.7.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@trpc/client": "^11.7.1",
+    "@types/cors": "^2.8.19",
+    "@types/node": "^22.0.0",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.21.8",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1"
+  },
+  "scripts": {
+    "clean": "rimraf build",
+    "build": "tsdown",
+    "watch": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint",
+    "check": "pnpm lint && pnpm typecheck"
+  },
+  "exports": {
+    ".": "./build/index.mjs"
+  },
+  "types": "./build/index.d.ts"
+}

package/src/adapter/fetch.ts

@@ -0,0 +1,112 @@
+import { AuthConfig } from '@silkweave/auth'
+import { Adapter, AdapterGenerator, SilkweaveOptions } from '@silkweave/core'
+import { fetchRequestHandler } from '@trpc/server/adapters/fetch'
+import { buildRouter, TrpcHandlerContext } from '../lib/buildRouter.js'
+import { createActionLogger, resolveAuth } from '../lib/createContext.js'
+
+export interface TrpcFetchAdapterOptions {
+  /** URL prefix stripped from incoming requests before tRPC routing. Default `/trpc`. */
+  endpoint?: string
+  auth?: AuthConfig
+}
+
+export type FetchHandler = (request: Request) => Promise<Response>
+
+export interface TrpcFetchAdapter {
+  adapter: AdapterGenerator
+  handler: FetchHandler
+  GET: FetchHandler
+  POST: FetchHandler
+}
+
+/**
+ * Creates a tRPC adapter that exposes a fetch-compatible handler instead of
+ * binding its own HTTP server. Use in Astro API routes, Vercel serverless
+ * functions, Cloudflare Workers, or any Web Standard runtime.
+ *
+ * The returned `handler` waits for `server.start()` to complete (via an internal
+ * `_ready` promise) before dispatching requests, so it's safe to call from a
+ * cold-started serverless invocation.
+ *
+ * CORS is intentionally not configured here - handle it in your host framework
+ * (Astro middleware, `vercel.json` headers, Worker response headers, etc).
+ */
+export function trpcFetch(options: TrpcFetchAdapterOptions = {}): TrpcFetchAdapter {
+  const endpoint = (options.endpoint ?? '/trpc').replace(/\/$/, '')
+
+  let resolveReady!: () => void
+  const ready = new Promise<void>((resolve) => { resolveReady = resolve })
+
+  let handler: FetchHandler = async () => new Response(
+    JSON.stringify({ error: 'not_ready', message: 'tRPC adapter has not started yet' }),
+    { status: 503, headers: { 'Content-Type': 'application/json' } }
+  )
+
+  const adapter: AdapterGenerator = (_silkweaveOptions: SilkweaveOptions, baseContext): Adapter => {
+    const context = baseContext.fork({ adapter: 'trpc' })
+    return {
+      context,
+      start: async (actions) => {
+        const router = buildRouter(actions)
+        const logger = createActionLogger()
+
+        const createContext = async (
+          opts: { req: Request }
+        ): Promise<TrpcHandlerContext> => {
+          const resolved = await resolveAuth(
+            options.auth,
+            opts.req.headers.get('authorization'),
+            context.fork({ request: opts.req })
+          )
+          if (resolved.kind === 'error') {
+            const err = new Error('Unauthorized') as Error & { silkweaveAuthError?: typeof resolved.error }
+            err.silkweaveAuthError = resolved.error
+            throw err
+          }
+          return {
+            silkweaveContext: context.fork({
+              logger,
+              request: opts.req,
+              ...(resolved.authInfo ? { auth: resolved.authInfo } : {})
+            })
+          }
+        }
+
+        handler = async (request: Request): Promise<Response> => {
+          try {
+            return await fetchRequestHandler({
+              endpoint,
+              req: request,
+              router,
+              createContext
+            })
+          } catch (error) {
+            const authError = (error as { silkweaveAuthError?: { statusCode: number; headers: Record<string, string>; body: object } }).silkweaveAuthError
+            if (authError) {
+              return new Response(JSON.stringify(authError.body), {
+                status: authError.statusCode,
+                headers: { 'Content-Type': 'application/json', ...authError.headers }
+              })
+            }
+            throw error
+          }
+        }
+
+        resolveReady()
+      },
+      stop: async () => { /* no-op for fetch adapter */ }
+    }
+  }
+
+  const dispatch: FetchHandler = async (request) => {
+    await ready
+    return handler(request)
+  }
+
+  return {
+    adapter,
+    handler: dispatch,
+    GET: dispatch,
+    POST: dispatch
+  }
+}

package/src/adapter/trpc.ts

@@ -0,0 +1,105 @@
+import { AuthConfig } from '@silkweave/auth'
+import { AdapterFactory } from '@silkweave/core'
+import { createHTTPHandler } from '@trpc/server/adapters/standalone'
+import cors, { CorsOptions } from 'cors'
+import http, { IncomingMessage, ServerResponse } from 'http'
+import { buildRouter, TrpcHandlerContext } from '../lib/buildRouter.js'
+import { createActionLogger, resolveAuth } from '../lib/createContext.js'
+
+export interface TrpcAdapterOptions {
+  host?: string
+  port?: number
+  /** URL prefix stripped from incoming requests before tRPC routing. Default `/trpc/`. */
+  endpoint?: string
+  /** CORS configuration. `false` to disable, `true`/`undefined` for permissive defaults, or a CorsOptions object. */
+  cors?: CorsOptions | boolean
+  auth?: AuthConfig
+}
+
+type CorsMiddleware = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => void
+
+function resolveCors(corsConfig: CorsOptions | boolean | undefined): CorsMiddleware | null {
+  if (corsConfig === false) { return null }
+  const userConfig = corsConfig === true || corsConfig === undefined ? {} : corsConfig
+  return cors({ origin: '*', ...userConfig }) as CorsMiddleware
+}
+
+export const trpc: AdapterFactory<TrpcAdapterOptions> = (options) => {
+  return (_silkweaveOptions, baseContext) => {
+    const context = baseContext.fork({ adapter: 'trpc' })
+    const host = options.host ?? '0.0.0.0'
+    const port = options.port ?? 8080
+    const endpoint = (options.endpoint ?? '/trpc/').replace(/\/?$/, '/')
+    let server: http.Server | undefined
+
+    return {
+      context,
+      start: async (actions) => {
+        const router = buildRouter(actions)
+        const corsMiddleware = resolveCors(options.cors)
+        const logger = createActionLogger()
+
+        const createContext = async (
+          opts: { req: IncomingMessage; res: ServerResponse }
+        ): Promise<TrpcHandlerContext> => {
+          const resolved = await resolveAuth(
+            options.auth,
+            opts.req.headers.authorization,
+            context.fork({ request: opts.req })
+          )
+          if (resolved.kind === 'error') {
+            for (const [key, value] of Object.entries(resolved.error.headers)) {
+              opts.res.setHeader(key, value)
+            }
+            opts.res.statusCode = resolved.error.statusCode
+            opts.res.setHeader('Content-Type', 'application/json')
+            opts.res.end(JSON.stringify(resolved.error.body))
+            throw new Error('Unauthorized')
+          }
+          return {
+            silkweaveContext: context.fork({
+              logger,
+              request: opts.req,
+              ...(resolved.authInfo ? { auth: resolved.authInfo } : {})
+            })
+          }
+        }
+
+        const trpcHandler = createHTTPHandler({ router, basePath: endpoint, createContext })
+
+        const handler = (req: IncomingMessage, res: ServerResponse) => {
+          if (!req.url?.startsWith(endpoint)) {
+            res.statusCode = 404
+            res.setHeader('Content-Type', 'application/json')
+            res.end(JSON.stringify({ error: 'not_found', message: `No route for ${req.url}` }))
+            return
+          }
+          trpcHandler(req, res)
+        }
+
+        server = http.createServer((req, res) => {
+          if (corsMiddleware) {
+            corsMiddleware(req, res, () => {
+              if (req.method === 'OPTIONS') { res.statusCode = 204; res.end(); return }
+              handler(req, res)
+            })
+          } else {
+            handler(req, res)
+          }
+        })
+
+        await new Promise<void>((resolve) => {
+          server!.listen(port, host, () => { resolve() })
+        })
+      },
+      stop: async () => {
+        if (!server) { return }
+        await new Promise<void>((resolve, reject) => {
+          server!.close((err) => {
+            if (err) { reject(err) } else { resolve() }
+          })
+        })
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './adapter/fetch.js'
+export * from './adapter/trpc.js'
+export { buildRouter } from './lib/buildRouter.js'
+export type { TrpcHandlerContext } from './lib/buildRouter.js'
+export { mapError } from './lib/errors.js'
+export type { InferTrpcRouter } from './lib/inferRouter.js'

package/src/lib/buildRouter.ts

@@ -0,0 +1,27 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Action, SilkweaveContext } from '@silkweave/core'
+import { initTRPC } from '@trpc/server'
+import { camelCase } from 'change-case'
+import { mapError } from './errors.js'
+
+export interface TrpcHandlerContext {
+  silkweaveContext: SilkweaveContext
+}
+
+export function buildRouter(actions: Action[]) {
+  const t = initTRPC.context<TrpcHandlerContext>().create()
+  const record: Record<string, any> = {}
+  for (const action of actions) {
+    const key = camelCase(action.name)
+    const base = t.procedure.input(action.input)
+    const handler = async ({ input, ctx }: { input: object; ctx: TrpcHandlerContext }) => {
+      try {
+        return await action.run(input, ctx.silkweaveContext)
+      } catch (error) {
+        throw mapError(error)
+      }
+    }
+    record[key] = action.kind === 'query' ? base.query(handler) : base.mutation(handler)
+  }
+  return t.router(record)
+}

package/src/lib/createContext.ts

@@ -0,0 +1,44 @@
+import { AuthConfig, AuthInfo, validateToken } from '@silkweave/auth'
+import { SilkweaveContext } from '@silkweave/core'
+import { buildLogLevels, Logger, LogLevel } from '@silkweave/logger'
+
+const CONSOLE_LEVEL_MAP: Record<LogLevel, 'log' | 'info' | 'warn' | 'error'> = {
+  emergency: 'error',
+  alert: 'error',
+  critical: 'error',
+  error: 'error',
+  warning: 'warn',
+  notice: 'info',
+  info: 'info',
+  debug: 'log'
+}
+
+export function createActionLogger(): Logger {
+  return {
+    ...buildLogLevels((level, data) => {
+      console[CONSOLE_LEVEL_MAP[level]](data)
+    }),
+    progress: () => { /* progress notifications not supported on tRPC HTTP */ }
+  }
+}
+
+export interface AuthErrorPayload {
+  statusCode: number
+  headers: Record<string, string>
+  body: { error: string; error_description: string }
+}
+
+export type ResolvedAuth =
+  | { kind: 'ok'; authInfo?: AuthInfo }
+  | { kind: 'error'; error: AuthErrorPayload }
+
+export async function resolveAuth(
+  auth: AuthConfig | undefined,
+  authHeader: string | null | undefined,
+  context: SilkweaveContext
+): Promise<ResolvedAuth> {
+  if (!auth) { return { kind: 'ok' } }
+  const result = await validateToken(authHeader, auth, context)
+  if (result.error) { return { kind: 'error', error: result.error } }
+  return { kind: 'ok', authInfo: result.auth }
+}

package/src/lib/errors.ts

@@ -0,0 +1,42 @@
+import { SilkweaveError } from '@silkweave/core'
+import { TRPCError } from '@trpc/server'
+import { z } from 'zod'
+
+type TRPCErrorCode = TRPCError['code']
+
+const CODE_MAP: Record<number, TRPCErrorCode> = {
+  400: 'BAD_REQUEST',
+  401: 'UNAUTHORIZED',
+  403: 'FORBIDDEN',
+  404: 'NOT_FOUND',
+  408: 'TIMEOUT',
+  409: 'CONFLICT',
+  412: 'PRECONDITION_FAILED',
+  413: 'PAYLOAD_TOO_LARGE',
+  429: 'TOO_MANY_REQUESTS',
+  499: 'CLIENT_CLOSED_REQUEST',
+  500: 'INTERNAL_SERVER_ERROR',
+  501: 'NOT_IMPLEMENTED',
+  502: 'BAD_GATEWAY',
+  503: 'SERVICE_UNAVAILABLE',
+  504: 'GATEWAY_TIMEOUT'
+}
+
+export function mapError(error: unknown): TRPCError {
+  if (error instanceof TRPCError) { return error }
+  if (error instanceof z.ZodError) {
+    return new TRPCError({ code: 'BAD_REQUEST', message: error.message, cause: error })
+  }
+  if (error instanceof SilkweaveError) {
+    return new TRPCError({
+      code: CODE_MAP[error.statusCode] ?? 'INTERNAL_SERVER_ERROR',
+      message: error.message,
+      cause: error
+    })
+  }
+  return new TRPCError({
+    code: 'INTERNAL_SERVER_ERROR',
+    message: error instanceof Error ? error.message : 'Internal error',
+    cause: error instanceof Error ? error : undefined
+  })
+}

package/src/lib/inferRouter.ts

@@ -0,0 +1,50 @@
+import { Action, Silkweave } from '@silkweave/core'
+import type {
+  AnyTRPCRootTypes,
+  TRPCBuiltRouter,
+  TRPCMutationProcedure,
+  TRPCQueryProcedure
+} from '@trpc/server'
+import type { z } from 'zod'
+
+type CamelCase<S extends string> = S extends `${infer A}-${infer B}`
+  ? `${A}${Capitalize<CamelCase<B>>}`
+  : S extends `${infer A}_${infer B}`
+    ? `${A}${Capitalize<CamelCase<B>>}`
+    : S
+
+type ActionToProcedure<A extends Action> = 'query' extends NonNullable<A['kind']>
+  ? TRPCQueryProcedure<{
+    meta: object
+    input: z.infer<A['input']>
+    output: Awaited<ReturnType<A['run']>>
+  }>
+  : TRPCMutationProcedure<{
+    meta: object
+    input: z.infer<A['input']>
+    output: Awaited<ReturnType<A['run']>>
+  }>
+
+type ActionsToRouterRecord<Actions extends Record<string, Action>> = {
+  [K in keyof Actions & string as CamelCase<Actions[K]['name']>]: ActionToProcedure<Actions[K]>
+}
+
+type TrpcRootTypes = {
+  ctx: object
+  meta: object
+  errorShape: unknown
+  transformer: false
+} & AnyTRPCRootTypes
+
+/**
+ * Extracts a fully-typed tRPC router from a Silkweave builder instance.
+ *
+ * Usage:
+ * ```ts
+ * const server = silkweave(opts).adapter(trpc({ port: 8080 })).action(HelloAction)
+ * export type AppRouter = InferTrpcRouter<typeof server>
+ * ```
+ */
+export type InferTrpcRouter<S> = S extends Silkweave<infer Actions>
+  ? TRPCBuiltRouter<TrpcRootTypes, ActionsToRouterRecord<Actions>>
+  : never

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "build",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "composite": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "build"]
+}