go-trpc

go-trpc

End-to-end typesafe APIs with Go + TypeScript

Write Go handlers. Generate TypeScript types. Use @trpc/client. Zero Protobuf.

Try the Live Demo

A real-time chat app with rooms, instant messaging via SSE subscriptions, and built-in dev tools — all powered by go-trpc.

Source code · Report Bug

Architecture

How It Works

Define a Go handler with typed structs:

gotrpc.Query(r, "getUser",
    func(ctx context.Context, input GetUserInput) (User, error) {
        return db.FindUser(input.ID)
    },
)

Generate TypeScript types from your Go code:

gotrpc generate ./api --output ./web/src/generated/router.d.ts

# Preview without writing to disk (useful for CI)
gotrpc generate ./api --output ./web/src/generated/router.d.ts --dry-run

Call it from the frontend with full type-safety:

const user = await trpc.getUser.query({ id: '1' }); // fully typed ✓

That's it. Go structs become TypeScript types. No schemas, no Protobuf, no manual type definitions.

Features

Quick Start

Install

go get github.com/sebasusnik/go-trpc
go install github.com/sebasusnik/go-trpc/cmd/gotrpc@latest

Scaffold a Project

gotrpc init          # creates gotrpc.json, trpc.ts client, generated/ dir
gotrpc init --ws     # same, but with WebSocket (splitLink + wsLink) setup

Server (Go)

package main

import (
    "context"
    "net/http"
    gotrpc "github.com/sebasusnik/go-trpc/pkg/router"
)

type GetUserInput struct {
    ID string `json:"id"`
}

type User struct {
    ID    string `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

func main() {
    r := gotrpc.NewRouter()

    gotrpc.Query(r, "getUser",
        func(ctx context.Context, input GetUserInput) (User, error) {
            return User{ID: input.ID, Name: "John", Email: "john@example.com"}, nil
        },
    )

    http.ListenAndServe(":8080", r.Handler())
}

Client (TypeScript)

import { createTRPCClient, httpLink } from '@trpc/client';
import type { AppRouter } from './generated/router';

const trpc = createTRPCClient<AppRouter>({
  links: [httpLink({ url: 'http://localhost:8080/trpc' })],
});

const user = await trpc.getUser.query({ id: '1' });
//    ^? { id: string; name: string; email: string }

Real-time Subscriptions

Define a subscription once — clients can consume it via SSE or WebSocket:

gotrpc.Subscription(r, "onMessage",
    func(ctx context.Context, input RoomInput) (<-chan Message, error) {
        ch := store.Subscribe(input.RoomID)
        go func() {
            <-ctx.Done()
            store.Unsubscribe(input.RoomID, ch)
        }()
        return ch, nil
    },
)

SSE (simple, works everywhere):

const es = new EventSource('/trpc/onMessage?input={"roomId":"1"}');
es.addEventListener('data', (e) => {
    const msg = JSON.parse(e.data).result.data; // typed Message
});

WebSocket (multiplexed, uses tRPC's wsLink):

import { createTRPCClient, splitLink, httpLink, wsLink } from '@trpc/client';

const trpc = createTRPCClient<AppRouter>({
  links: [
    splitLink({
      condition: (op) => op.type === 'subscription',
      true: wsLink({ url: 'ws://localhost:8080/trpc' }),
      false: httpLink({ url: 'http://localhost:8080/trpc' }),
    }),
  ],
});

// Type-safe subscription with automatic reconnection
trpc.onMessage.subscribe({ roomId: '1' }, {
  onData: (msg) => console.log(msg), // typed Message
});

Nested Routers

Organize procedures into namespaces:

userRouter := gotrpc.NewRouter()
gotrpc.Query(userRouter, "get", getUser)
gotrpc.Mutation(userRouter, "create", createUser)

r := gotrpc.NewRouter()
r.Merge("user", userRouter)  // → user.get, user.create

Middlewares

Global middlewares

Apply to every procedure in the router:

r.Use(gotrpc.RateLimit(100))              // 100 req/s per IP
r.Use(gotrpc.BearerAuth(validateToken))   // JWT/token auth
r.Use(gotrpc.Timeout(5 * time.Second))    // per-request timeout
r.Use(gotrpc.MaxInputSize(4096))          // limit payload size

Per-procedure middlewares

Apply middlewares to individual procedures with WithMiddleware:

// Public — no auth required
gotrpc.Query(r, "listItems", listHandler)

// Requires authentication
gotrpc.Query(r, "getItem", getHandler,
    gotrpc.WithMiddleware(authMiddleware),
)

// Admin-only with stacked middlewares
gotrpc.Mutation(r, "createItem", createHandler,
    gotrpc.WithMiddleware(
        adminAuth,
        gotrpc.MaxInputSize(4096),
        gotrpc.Timeout(2 * time.Second),
    ),
)

Rate limit by key

Rate limit by an arbitrary key (user ID, API key, etc.) instead of IP:

gotrpc.Query(r, "search", searchHandler,
    gotrpc.WithMiddleware(
        gotrpc.RateLimitByKey(10, func(ctx context.Context) string {
            return getUserID(ctx) // rate limit per user
        }),
    ),
)

Deploy Anywhere

// Standard HTTP — Docker, Railway, Fly.io, etc.
http.ListenAndServe(":8080", r.Handler())

// AWS Lambda
trpclambda.Start(r)

// Cloudflare Workers
trpccf.Serve(r)

Documentation

License

MIT