Bare-bones TRPC

trpc.ts

#!/usr/bin/env -S npm exec ts-node -- --swc
import axios from "axios";
import { createServer, RequestListener } from "http";

const PORT = 3333;
const BASE_URL = `http://localhost:${PORT}/trpc`;
const ROUTE_NAME_PARAM = "route_name";

type Route<I, O> = {
  fn: (params: I) => O;
};

function procedure<I, O>(fn: (params: I) => O): Route<I, O> {
  return { fn };
}

const router = {
  mul2: procedure((params: { n: number }) => {
    return params.n * 2;
  }),
};

type Router = typeof router;

const requestHandler: RequestListener = (req, res) => {
  const url = new URL(req.url ?? "", "http://localhost");
  const routeName = url.searchParams.get(ROUTE_NAME_PARAM) ?? "";
  if (!(routeName in router)) {
    res.statusCode = 404;
    res.end();
  }
  const route = router[routeName as unknown as keyof typeof router];
  // TODO: validate params
  const params = Object.fromEntries(url.searchParams.entries());
  const ret = route.fn(params as never);
  res.statusCode = 200;
  res.write(JSON.stringify(ret));
  res.end();
};

function createClient<TRouter extends { [routeName: string]: Route<any, any> }>(): {
  [RouteName in keyof TRouter]: {
    request: (
      params: Parameters<TRouter[RouteName]["fn"]>[0]
    ) => Promise<ReturnType<TRouter[RouteName]["fn"]>>;
  };
} {
  const ax = axios.create({ baseURL: BASE_URL });
  return new Proxy(
    {},
    {
      get: (_, prop) => {
        const routeName = prop;
        return {
          request: async (params: Record<string, unknown>) => {
            const resp = await ax.request({
              method: "get",
              params: {
                [ROUTE_NAME_PARAM]: routeName,
                ...params,
              },
            });
            return resp.data as unknown;
          },
        };
      },
    }
  ) as never;
}

async function main() {
  const args = process.argv.slice(2);
  const action = args.at(0);
  if (!action) {
    throw new Error("Call me with 'server' or 'client'");
  }
  if (action === "server") {
    createServer(requestHandler).listen(PORT);
  } else if (action === "client") {
    const client = createClient<Router>();
    // 👀 Type-safety!
    const data = await client.mul2.request({ n: 21 });
    console.info(data);
  }
}

void main().catch(console.error);

Nice! C'est le principe

C'est vrm cool RPC surtout avec trpc, ca rend le query usage tlm simple pour les devs. trpc.domain1.method.query(params)

je googlais et le debat entre les 2, bcp de gens disent:
RPC -> used for endpoints that perform single specific action
REST -> CRUD operations