TRPC Integration for Adonis

routes.ts

import Route from '@ioc:Adonis/Core/Route';
import { handleHttpRequest } from 'App/TRPC';

Route.any('/trpc/*', handleHttpRequest);

TRPC.ts

import { initTRPC } from '@trpc/server';
import { resolveHTTPResponse } from '@trpc/server/http';
import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';

const t = initTRPC.create();

export const appRouter = t.router({
	hello: t.procedure.query(() => {
		return { message: 'World' };
	}),
});

export const handleHttpRequest = async (ctx: HttpContextContract) => {
	const { request, response } = ctx;
	const url = new URL(request.completeUrl(true));
	const path = url.pathname.slice('/trpc'.length + 1);

	const { body, status, headers } = await resolveHTTPResponse({
		createContext: async () => ctx,
		router: appRouter,
		path,
		req: {
			query: url.searchParams,
			method: request.method(),
			headers: request.headers(),
			body: request.body(),
		},
	});
	if (headers) {
		Object.keys(headers).forEach((key) => {
			const value = headers[key];
			if (value) response.header(key, value);
		});
	}
	response.status(status);
	response.send(body);
}

export type AppRouter = typeof appRouter;

Thanks for sharing!

I would modify the t initialization for type inference of HttpContextContract.

const t = initTRPC.context<HttpContextContract>().create();

@ThBM oh this is nice thanks !

for tRPC ^11.0.0-rc.593 / Adonis.js v5

import { fetchRequestHandler } from '@trpc/server/adapters/fetch'
import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'

export const handleHttpRequest = async (ctx: HttpContextContract) => {
  const { request, response } = ctx

  const result = await fetchRequestHandler({
    endpoint: '/trpc',
    req: new Request(request.completeUrl(true), {
      headers: request.headers(),
      body: request.method() !== 'GET' ? JSON.stringify(request.body()) : undefined,
      method: request.method()
    }),
    router: createRouter(),
    createContext: async () => ctx
  })

  const responseText = await new Response(result.body).text()

  return response.status(result.status).header('content-type', 'application/json').send(responseText)
}

I just got a working version for adonisjs 6.17.2 and trpc 11.0.0:

import { HttpContext } from '@adonisjs/core/http'
import { initTRPC } from '@trpc/server'
import { resolveResponse } from '@trpc/server/http'

const t = initTRPC.context<HttpContext>().create()

export const appRouter = t.router({
  hello: t.procedure.query(() => {
    return { message: 'World' }
  }),
})

export const endpoint = '/trpc' as const

export const trpcHTTPRequestHandler = async (ctx: HttpContext) => {
  const { request, response } = ctx

  const url = new URL(request.completeUrl(true))
  const path = url.pathname.slice(endpoint.length).replace(/^[/]+|[/]+$/g, '')

  const trpcRequest = new Request(url, {
    headers: request.headers() as Record<string, string | ReadonlyArray<string>>,
    body: request.raw(),
    method: request.method(),
  })

  const trpcResponse = await resolveResponse({
    createContext: async () => ctx,
    router: appRouter,
    path,
    req: trpcRequest,
    error: null,
  })

  const trpcResponseText = await trpcResponse.text()

  trpcResponse.headers.forEach((value, key) => {
    response.header(key, value)
  })

  response.status(trpcResponse.status)
  response.send(trpcResponseText)
}

export type AppRouter = typeof appRouter

and my route declaration:

router.any(`${trpcEndpoint}/*`, trpcHTTPRequestHandler)