Name: TypeWire
Author: Taha Nabavi

Installation

bash

npm install @tahanabavi/typewire-nestjs @tahanabavi/typefetch zod

Peer dependencies: @nestjs/common + @nestjs/core (v10 or v11), rxjs, reflect-metadata, zod@^4.

Every non-HTTP wire ships behind its own entry point, so an HTTP-only app installs nothing extra. Each one's peer is a package the contract already needed — see Every wire the client speaks:

Entry point	Optional peer
`@tahanabavi/typewire-nestjs/grpc`	`@tahanabavi/typefetch-grpc`
`@tahanabavi/typewire-nestjs/graphql`	`@tahanabavi/typefetch-graphql`
`@tahanabavi/typewire-nestjs/socket`	`@nestjs/websockets` + `@tahanabavi/typesocket`

Quick start

The shared contract (imported by both frontend and backend):

// contracts/user.contracts.ts
import { z } from "zod";
import type { Contracts } from "@tahanabavi/typefetch";

export const contracts = {
  user: {
    getUser: {
      method: "GET",
      path: "/users/:id",
      request: z.object({
        path: z.object({ id: z.string() }),
        query: z.object({ verbose: z.boolean().optional() }).optional(),
      }),
      response: z.object({ id: z.string(), name: z.string() }),
    },
    createUser: {
      method: "POST",
      path: "/users",
      auth: true,
      request: z.object({
        body: z.object({ name: z.string().min(2), age: z.number().int() }),
      }),
      response: z.object({ id: z.string(), name: z.string() }),
    },
  },
} as const satisfies Contracts;

The controller:

import { Controller } from "@nestjs/common";
import {
  TypeFetchEndpoint,
  ContractInput,
  InferRequest,
  InferResponse,
} from "@tahanabavi/typewire-nestjs";
import { contracts } from "./contracts/user.contracts";

type GetUser = typeof contracts.user.getUser;
type CreateUser = typeof contracts.user.createUser;

@Controller()
export class UserController {
  // GET /users/:id — method + path come from the contract. No @Get, no drift.
  @TypeFetchEndpoint(contracts.user.getUser)
  async getUser(
    @ContractInput() input: InferRequest<GetUser>,
  ): Promise<InferResponse<GetUser>> {
    return { id: input.path.id, name: "Taha" };
  }

  @TypeFetchEndpoint(contracts.user.createUser, { httpCode: 200 })
  async createUser(
    @ContractInput() input: InferRequest<CreateUser>,
  ): Promise<InferResponse<CreateUser>> {
    return { id: "u-1", name: input.body.name };
  }
}

That's it. For every bound endpoint:

Route — HTTP method and path are taken from the contract (/users/:id is the same param syntax NestJS uses). Use a prefix-less @Controller(), since contract paths are absolute.
Request validation — params, query, body, and declared headers are validated against endpoint.request. Failures return a 400 whose body the typefetch client surfaces as a first-class RichError (see below).
Response validation — the handler's return value is validated against endpoint.response and stripped of undeclared fields, so entities never leak extra data. A mismatch logs the issues and returns 500 — backend drift from the contract can't ship silently.