Firebase / Google Cloud Functions Support

[joshjacks]

Describe the feature

Firebase functions (v2) provide an onRequest function which is a thin wrapper around an Express endpoint. Unfortunately, the wrapper appears to consume the request before it hits user space and so it is incompatible with the oRPC Express adapter.

Example of Ideal (an example of what works with tRPC):

export const api = onRequest((req, res) => {
    req.url = req.url.replace("/api", "");
    return createHTTPHandler({
        router: appRouter,
        createContext,
    })(req, res);
});

What the docs currently suggest:

import { RPCHandler } from "@orpc/server/node";
import { onRequest } from "firebase-functions/v2/https";
import { createContext } from "./context.js";
import { router } from "./router.js";

const handler = new RPCHandler(router);

export const api = onRequest(async (req, res) => {
    await handler.handle(req, res, {
        prefix: "/api",
        context: await createContext(req),
    });
});

However, with this suggestion, the input is always undefined, though the route is matched correctly and no error is thrown (except for a validation error on the input if one exists of course).

Additional information

• Would you be willing to help implement this feature?

[dosubot]

Hi @joshjacks! I'm Dosu and I’m helping the orpc team.

The reason input is always undefined when using oRPC's RPCHandler with Firebase Functions v2's onRequest is that Firebase's internal middleware consumes or transforms the request body before oRPC's handler can access it. This prevents oRPC from parsing the input as expected, even though the route is matched and no error is thrown unless input validation fails. This is different from tRPC, which works because its handler is compatible with the way Firebase exposes the request object.

RPCHandler is designed to work with oRPC's generated clients, not direct HTTP calls. If you need to support manual API calls (like from Postman or curl), you should use OpenAPIHandler instead. If you must use RPCHandler, requests must follow the oRPC protocol as described in the advanced documentation, or you need to ensure the request body is available to oRPC's handler, which is not currently possible with Firebase's onRequest wrapper as it stands citation.

There are no existing adapters or ongoing work in the codebase for Firebase Functions v2 support, nor are there documented workarounds for restoring input parsing compatibility in this environment.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[joshjacks]

After a hint from @unnoq - I took a look at the docs for the Hono adapter and arrived at the following workaround. It's not the prettiest and I believe won't work well for streaming (though request streaming appears to be something firebase functions fundamentally do not support).

import { RPCHandler } from "@orpc/server/fetch";
import {
	type Request as FirebaseRequest,
	onRequest,
} from "firebase-functions/v2/https";
import { createContext } from "./context.js";
import { router } from "./router.js";

const handler = new RPCHandler(router);

export function firebaseRequestToFetchRequest(req: FirebaseRequest): Request {
	const url = `${req.protocol}://${req.get("host")}${req.originalUrl}`;

	const headers = new Headers();
	for (const [key, value] of Object.entries(req.headers)) {
		if (Array.isArray(value)) {
			headers.set(key, value.join(", "));
		} else if (value !== undefined) {
			headers.set(key, value);
		}
	}

	return new Request(url, {
		method: req.method,
		headers,
		body: new Uint8Array(req.rawBody),
	});
}

export const api = onRequest(async (req, res) => {
	const fetchRequest = firebaseRequestToFetchRequest(req);

	const { response } = await handler.handle(fetchRequest, {
		prefix: "/api",
		context: await createContext(req),
	});

	if (!response) {
		throw new Error("No response from handler");
	}

	res.status(response.status);

	response.headers.forEach((value, key) => {
		res.setHeader(key, value);
	});

	if (response.body) {
		const buffer = Buffer.from(await response.arrayBuffer());
		res.send(buffer);
	} else {
		res.end();
	}
});

[dinwwwh]

Hey @joshjacks, quick question: can we rely on req.body instead of req.rawBody? Does Firebase Functions provide a .body property?

If so, we could prefer using req.body when available for body: here: https://github.com/unnoq/orpc/blob/main/packages/standard-server-node/src/body.ts#L12

This approach would also help oRPC support the body-parser middleware in Express.js.

[joshjacks]

@unnoq yes the body property is already parsed and always provided. If we want full control it would be possible (I think, not 100% sure) and nicest to be able to do something like

export const api = onOrpcRequest({
   ... default firebase/google config options ...
   prefix: "/api",
   context: await createContext(req),
});

This way you could catch it before Firebase already parsed it for more control if this makes sense? I can have a look into this at some point!

[joshjacks]

Would basically need to reimplement this.

[dinwwwh]

Let's try this PR https://github.com/unnoq/orpc/pull/1001 to see if it can solve this problem?