Клиент, выведенный из типа роутера: tRPC изнутри

// Сервер: заметки лежат здесь, наружу уходит текст
type Note = { id: number; title: string; body: string };

const notes: Note[] = [{ id: 1, title: "Первая заметка", body: "тело заметки" }];

function byId(input: { id: number }): Note | null {
  return notes.find((note) => note.id === input.id) ?? null;
}

// Провод: по нему едет строка, а не тип
const send = (input: { id: number }): string => JSON.stringify(byId(input));

// Клиент: описание ответа переписано руками — вторая копия того же
interface NoteView {
  id: number;
  title: string;
  text: string;
}

const note = JSON.parse(send({ id: 1 })) as NoteView;
console.log(note.title);
console.log("текст:", note.text);

try {
  console.log("длина текста:", note.text.length);
} catch (error) {
  console.log("а на деле:", error instanceof Error ? error.name : error);
}

// Валидатор границы — в подложке, здесь его типы
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Infer<S> = S extends Schema<infer T> ? T : never;
declare const text: Schema<string>;
declare const int: Schema<number>;
declare function oneOf<T extends string>(...allowed: T[]): Schema<T>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;
declare function parse<T>(schema: Schema<T>, value: unknown, path: string): T;

type Note = { id: number; title: string; status: "draft" | "published" };
const notes: Note[] = [{ id: 1, title: "Первая заметка", status: "published" }];

// Процедура — значение: схема входа лежит рядом с обработчиком
type Procedure<I, O> = { input: Schema<I>; run: (input: I) => O };

function procedure<I, O>(input: Schema<I>, run: (input: I) => O): Procedure<I, O> {
  return { input, run };
}

// Роутер — обычный объект: в ветках ветки, в листьях процедуры
const router = {
  notes: {
    byId: procedure(object({ id: int }), (input) => notes.find((note) => note.id === input.id) ?? null),
    create: procedure(object({ title: text, status: oneOf("draft", "published") }), (input) => ({ id: notes.length + 1, ...input })),
  },
};

// Имя процедуры приезжает по проводу строкой, а вход — чем угодно
function call(router: unknown, path: string, raw: unknown): unknown {
  let node: unknown = router;
  for (const step of path.split(".")) {
    node = typeof node === "object" && node !== null ? (node as Record<string, unknown>)[step] : undefined;
  }
  const found = node as Procedure<unknown, unknown> | undefined;
  if (!found || typeof found.run !== "function") throw new TypeError(`нет процедуры ${path}`);
  return found.run(parse(found.input, raw, "input"));
}

console.log(call(router, "notes.byId", { id: 1 }));
console.log(call(router, "notes.create", { title: "  Вторая  ", status: "draft" }));

const wrong: [string, unknown][] = [
  ["notes.byId", { id: "1" }],
  ["notes.create", { title: "   ", status: "archived" }],
  ["notes.remove", { id: 1 }],
];
for (const [path, raw] of wrong) {
  try {
    call(router, path, raw);
  } catch (error) {
    console.log(error instanceof Error ? error.message : error);
  }
}

// Схемы, procedure и call — в подложке, здесь их типы
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Infer<S> = S extends Schema<infer T> ? T : never;
type Procedure<I, O> = { input: Schema<I>; run: (input: I) => O };
declare const text: Schema<string>;
declare const int: Schema<number>;
declare function oneOf<T extends string>(...allowed: T[]): Schema<T>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;
declare function procedure<I, O>(input: Schema<I>, run: (input: I) => O): Procedure<I, O>;
declare function call(router: unknown, path: string, raw: unknown): unknown;

type Note = { id: number; title: string; status: "draft" | "published" };
const notes: Note[] = [{ id: 1, title: "Первая заметка", status: "published" }];

const router = {
  notes: {
    byId: procedure(object({ id: int }), (input) => notes.find((note) => note.id === input.id) ?? null),
    create: procedure(object({ title: text, status: oneOf("draft", "published") }), (input) => ({ id: notes.length + 1, ...input })),
  },
};

// Оба имени достаются разом: I — вход, O — то, что вернул обработчик
type Input<P> = P extends Procedure<infer I, infer O> ? I : never;
type Output<P> = P extends Procedure<infer I, infer O> ? O : never;

type CreateInput = Input<typeof router.notes.create>;
type CreateOutput = Output<typeof router.notes.create>;

const draft: CreateInput = { title: "черновик", status: "draft" };
const created: CreateOutput = router.notes.create.run(draft);
console.log(created.id, created.status);
console.log(call(router, "notes.byId", { id: 1 }));

// @ts-expect-error статусов в схеме два, и тип пришёл из неё же
const archived: CreateInput = { title: "старое", status: "archived" };

// @ts-expect-error имя из infer не видно внутри той же проверяемой формы
type Wrong<P> = P extends { input: Schema<infer I>; run: (input: I) => infer O } ? O : never;

// Схемы, procedure и call — в подложке, здесь их типы
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Infer<S> = S extends Schema<infer T> ? T : never;
type Procedure<I, O> = { input: Schema<I>; run: (input: I) => O };
declare const text: Schema<string>;
declare const int: Schema<number>;
declare function oneOf<T extends string>(...allowed: T[]): Schema<T>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;
declare function procedure<I, O>(input: Schema<I>, run: (input: I) => O): Procedure<I, O>;
declare function call(router: unknown, path: string, raw: unknown): unknown;

type Note = { id: number; title: string; status: "draft" | "published" };
const notes: Note[] = [{ id: 1, title: "Первая заметка", status: "published" }];

const router = {
  notes: {
    byId: procedure(object({ id: int }), (input) => notes.find((note) => note.id === input.id) ?? null),
    create: procedure(object({ title: text, status: oneOf("draft", "published") }), (input) => ({ id: notes.length + 1, ...input })),
  },
};

// Обход типа роутера: лист — процедура, ветка — снова клиент
type Client<R> = {
  [K in keyof R]: R[K] extends Procedure<infer I, infer O> ? (input: I) => Promise<O> : Client<R[K]>;
};

// Цель Proxy — функция: иначе вызов api.notes.byId(…) не перехватить
function client<R>(router: R, path: string[] = []): Client<R> {
  const proxy = new Proxy(function () {}, {
    // обращение к полю — ещё один шаг пути; вызова пока не было
    get: (target, key) => client(router, [...path, String(key)]),
    // вызвали — путь дособран: дальше обычный call по имени
    apply: async (target, thisArg, args) => call(router, path.join("."), args[0]),
  });
  // единственное место, где тип не выведен, а объявлен
  return proxy as unknown as Client<R>;
}

const api = client(router);

async function main() {
  console.log(await api.notes.byId({ id: 1 }));
  const note = await api.notes.create({ title: "  Вторая  ", status: "draft" });
  console.log(note.id, note.status);

  try {
    // @ts-expect-error процедура ждёт объект по схеме, а не число
    await api.notes.byId(7);
  } catch (error) {
    console.log(error instanceof Error ? error.message : error);
  }
}

main();

// Схемы, procedure и call — в подложке, здесь их типы
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Infer<S> = S extends Schema<infer T> ? T : never;
type Procedure<I, O> = { input: Schema<I>; run: (input: I) => O };
declare const text: Schema<string>;
declare const int: Schema<number>;
declare function oneOf<T extends string>(...allowed: T[]): Schema<T>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;
declare function procedure<I, O>(input: Schema<I>, run: (input: I) => O): Procedure<I, O>;
declare function call(router: unknown, path: string, raw: unknown): unknown;

type Note = { id: number; title: string; status: "draft" | "published" };
const notes: Note[] = [{ id: 1, title: "Первая заметка", status: "published" }];

const router = {
  notes: {
    byId: procedure(object({ id: int }), (input) => notes.find((note) => note.id === input.id) ?? null),
    create: procedure(object({ title: text, status: oneOf("draft", "published") }), (input) => ({ id: notes.length + 1, ...input })),
  },
  auth: {
    me: procedure(object({}), () => ({ id: 7, name: "Рико" })),
  },
};

// Роутер — значение, поэтому его можно обойти и переписать имена
function describe(node: unknown, path: string[] = []): string[] {
  const leaf = node as Procedure<unknown, unknown>;
  if (leaf && typeof leaf.run === "function") return [path.join(".")];
  return Object.entries(node as Record<string, unknown>).flatMap(([key, value]) => describe(value, [...path, key]));
}

console.log(describe(router).join(", "));
console.log("схема входа:", JSON.stringify(router.notes.create.input));

// А это то, что приезжает по проводу: текст, и ни одного типа с ним
const fromCurl: unknown = JSON.parse('{"id":"1"}');
try {
  call(router, "notes.byId", fromCurl);
} catch (error) {
  console.log(error instanceof Error ? error.message : error);
}

/**
 * AUTO-GENERATED FILE - DO NOT EDIT!
 *
 * This file was automatically generated by nestjs-trpc.
 * Command: `npx nestjs-trpc generate`
 */

import { initTRPC } from "@trpc/server";
import superjson from "superjson";
import { byIdInput, createNoteInput, noteOutput, userOutput } from "@jsp/contracts";

const t = initTRPC.create({ transformer: superjson });
const publicProcedure = t.procedure;

const appRouter = t.router({
  auth: t.router({
    me: publicProcedure
      .output(userOutput)
      .query(async () => "PLACEHOLDER_DO_NOT_REMOVE" as any),
    // … ещё пять процедур входа и профиля
    }),
  notes: t.router({
    byId: publicProcedure
      .input(byIdInput)
      .output(noteOutput)
      .query(async () => "PLACEHOLDER_DO_NOT_REMOVE" as any),
    create: publicProcedure
      .input(createNoteInput)
      .output(noteOutput)
      .mutation(async () => "PLACEHOLDER_DO_NOT_REMOVE" as any),
    // … ещё четыре процедуры заметок
    })
});

export type AppRouter = typeof appRouter;