Monorepo backend/frontend has issue with types inference on router

[oorestisime]

I have a structure like:

• monorepo/apps/backend
• monorepo/apps/frontend

In backend i do

import {os} from "@orpc/server"
import {adminRouter} from "./rpc/admin"
import {pulseRouter} from "./rpc/pulse"

export const router = os.router({
	admin: adminRouter,
	pulse: pulseRouter
	// ...other routers
})

and in the client side i am trying to create a router using

import { router } from "../../../backend/server/orpc";

import { createORPCClient } from "@orpc/client";
import { RouterClient } from '@orpc/server'
import { RPCLink } from "@orpc/client/fetch";

const link = new RPCLink({
  url: `${process.env.NEXT_PUBLIC_BACKEND_URL}/rpc`,
  headers: async () => {
    if (typeof window !== "undefined") {
      return {};
    }

    const { headers } = await import("next/headers");
    return Object.fromEntries(await headers());
  },
});

const client: RouterClient<typeof router> = createORPCClient(link)
client.pulse.

I get autocomplete on .pulse on the client but then nothing on the procedure. Actually the router comes as

pulse: ProcedureClient<...> | {
        [x: string]: ProcedureClient<Record<never, never>, any, any, any> | ...;
    };

On the client side i have the tsconfig with "references": [{"path": "../backend/"}] (nextjs project)
and on backend side i have composite and declaration true.

The odd thing is that when i create a client from within the backend everything works good.

Any ideas ?

[dosubot[bot]]

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

The type inference issue you’re seeing on the frontend is almost certainly due to TypeScript not being able to fully resolve the types from your backend router across the monorepo boundary. Even though you have "composite": true and "declaration": true in the backend, and a project reference in the frontend, this alone isn’t always enough for robust type sharing—especially in Next.js monorepos.

The orpc types rely on deep, recursive type inference, and if TypeScript can’t follow the types all the way through (for example, if it’s only seeing .d.ts output or if module resolution isn’t set up to point directly at the backend’s source or output), you’ll get generic types like ProcedureClient<Record<never, never>, any, any, any> instead of full autocomplete for your procedures. This is a common pitfall in monorepo setups where project references or path mappings aren’t fully wired up between frontend and backend apps [source].

To fix this, double-check that:

• Your frontend’s tsconfig.json includes a project reference to the backend and that the reference path is correct and points to the backend’s tsconfig (not just the folder).
• The backend emits its .d.ts files to a location that the frontend can resolve (often via an outDir like dist).
• The frontend’s tsconfig has a paths entry or baseUrl that allows TypeScript to resolve imports from the backend’s output or source directory.
• Both frontend and backend are using compatible TypeScript versions and module resolution strategies.

The orpc codebase itself doesn’t show a full monorepo example with cross-app type sharing, but the lack of project references and path mappings in their Next.js playground matches the symptoms you’re seeing [source].

If you set up project references and paths so that the frontend can “see” the backend’s types directly, you should get full type inference and autocomplete for all router procedures. If you’re still stuck, sharing your tsconfig files and the exact import paths might help pinpoint the issue.

To reply, just mention @dosu.

---

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

[oorestisime]

hmmmm i think i tried that but maybe missing something.
my backend tsconfig:

	{
		"compileOnSave": false,
		"compilerOptions": {
			"lib": ["es2022"],
			"target": "es2022",
			"module": "es2022",
			"esModuleInterop": true,
			"moduleResolution": "bundler",
			"outDir": "dist",
			"typeRoots": ["node_modules/@types"],
			"resolveJsonModule": true,
			"allowJs": true,
			"experimentalDecorators": true,
			"sourceMap": true,
			"verbatimModuleSyntax": true,
			"useDefineForClassFields": false,
			"declaration": true,
    		"declarationMap": true,
			"composite": true,
			"skipLibCheck": true
		},
		"include": ["typings.d.ts","scripts/**/*.ts", "server/**/*.ts", "server/**/*.html", "server/**/*.json" ],
		"exclude": ["node_modules"]
	}

the orpc.d.ts in the dist is emmited as

export declare const router: {
    admin: {
        listUsers: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }>, Record<never, never>>, Record<never, never>>, import("@orpc/server").MergedCurrentContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>>, import("zod").ZodObject<{
            limit: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
            offset: import("zod").ZodOptional<import("zod").ZodNumber>;
        }, "strip", import("zod").ZodTypeAny, {
            limit?: number;
            offset?: number;
        }, {
            limit?: number;
            offset?: number;
        }>, import("@orpc/contract").Schema<{
            users: never[] | import("better-auth/plugins").UserWithRole[];
            total: number;
        }, {
            users: never[] | import("better-auth/plugins").UserWithRole[];
            total: number;
        }>, import("@orpc/contract").MergedErrorMap<Record<never, never>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>>, Record<never, never>>;
        changeUserRole: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }>, Record<never, never>>, Record<never, never>>, import("@orpc/server").MergedCurrentContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>>, import("zod").ZodObject<{
            userId: import("zod").ZodString;
            role: import("zod").ZodString;
        }, "strip", import("zod").ZodTypeAny, {
            role?: string;
            userId?: string;
        }, {
            role?: string;
            userId?: string;
        }>, import("zod").ZodObject<{
            success: import("zod").ZodBoolean;
        }, "strip", import("zod").ZodTypeAny, {
            success?: boolean;
        }, {
            success?: boolean;
        }>, import("@orpc/contract").MergedErrorMap<Record<never, never>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>>, Record<never, never>>;
        deleteUser: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }>, Record<never, never>>, Record<never, never>>, import("@orpc/server").MergedCurrentContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>>, import("zod").ZodObject<{
            userId: import("zod").ZodString;
        }, "strip", import("zod").ZodTypeAny, {
            userId?: string;
        }, {
            userId?: string;
        }>, import("zod").ZodObject<{
            success: import("zod").ZodBoolean;
        }, "strip", import("zod").ZodTypeAny, {
            success?: boolean;
        }, {
            success?: boolean;
        }>, import("@orpc/contract").MergedErrorMap<Record<never, never>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>>, Record<never, never>>;
    };
    pulse: {
        listWidgets: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }>, Record<never, never>>, Record<never, never>>, import("@orpc/server").MergedCurrentContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>>, import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodArray<import("zod").ZodObject<{
            id: import("zod").ZodString;
            title: import("zod").ZodString;
            category: import("zod").ZodString;
            refreshWindow: import("zod").ZodNumber;
            lookbackDays: import("zod").ZodNumber;
        }, "strip", import("zod").ZodTypeAny, {
            category?: string;
            id?: string;
            title?: string;
            refreshWindow?: number;
            lookbackDays?: number;
        }, {
            category?: string;
            id?: string;
            title?: string;
            refreshWindow?: number;
            lookbackDays?: number;
        }>, "many">, import("@orpc/contract").MergedErrorMap<Record<never, never>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>>, Record<never, never>>;
        listDashboards: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }>, Record<never, never>>, Record<never, never>>, import("@orpc/server").MergedCurrentContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<{
            name: string;
            id: string;
            createdAt: Date;
            updatedAt: Date;
            ownerId: string;
            widgets: string | number | boolean | import("./db/types").JsonArray | import("./db/types").JsonObject;
        }[], {
            name: string;
            id: string;
            createdAt: Date;
            updatedAt: Date;
            ownerId: string;
            widgets: string | number | boolean | import("./db/types").JsonArray | import("./db/types").JsonObject;
        }[]>, import("@orpc/contract").MergedErrorMap<Record<never, never>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>>, Record<never, never>>;
        getDashboard: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<Record<never, never>, import("@orpc/server").MergedInitialContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }>, Record<never, never>>, Record<never, never>>, import("@orpc/server").MergedCurrentContext<{
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        }, {
            session: import("./rpc/middlewares").AuthSession;
            headers: import("http").IncomingHttpHeaders;
        } & Record<never, never>>, import("zod").ZodObject<{
            dashboardId: import("zod").ZodString;
        }, "strip", import("zod").ZodTypeAny, {
            dashboardId?: string;
        }, {
            dashboardId?: string;
        }>, import("@orpc/contract").Schema<{
            name: string;
            id: string;
            createdAt: Date;
            updatedAt: Date;
            ownerId: string;
            widgets: string | number | boolean | import("./db/types").JsonArray | import("./db/types").JsonObject;
        }, {
            name: string;
            id: string;
            createdAt: Date;
            updatedAt: Date;
            ownerId: string;
            widgets: string | number | boolean | import("./db/types").JsonArray | import("./db/types").JsonObject;
        }>, import("@orpc/contract").MergedErrorMap<Record<never, never>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>>, Record<never, never>>;
    };
};
export type AppRouter = typeof router;
//# sourceMappingURL=orpc.d.ts.map

my frontend tsconfig is

{
  "extends": "tsconfig/nextjs.json",
  "compilerOptions": {
    "moduleResolution": "bundler",
    "baseUrl": ".",
    "jsx": "preserve",
    "paths": {
      "@/*": ["./src/*"],
      "react": ["./node_modules/@types/react"],
      "@backend/orpc": ["../backend/dist/server/orpc.d.ts"]
    },
    "allowJs": true,
    "noImplicitAny": false,
    "strictNullChecks": true,
    "types": ["vitest/globals", "@testing-library/jest-dom", "next"],
    "plugins": [
      {
        "name": "next"
      }
    ]
  },
  "include": [
    "next-env.d.ts",
    "global.d.ts",
    "**/*.ts",
    "**/*.tsx",
    "**/*.js",
    ".next/types/**/*.ts",
    "test/vitest.setup.ts"
  ],
  "exclude": ["node_modules", "next.config.js"],
  "references": [{
    "path": "../backend"
  }]
}

and i am building a client using

import { type AppRouter } from "@backend/orpc";

import { createORPCClient } from "@orpc/client";
import { RouterClient } from '@orpc/server'
import { RPCLink } from "@orpc/client/fetch";



const link = new RPCLink({
  url: `${process.env.NEXT_PUBLIC_BACKEND_URL}/rpc`,
  headers: async () => {
    if (typeof window !== "undefined") {
      return {};
    }

    const { headers } = await import("next/headers");
    return Object.fromEntries(await headers());
  },
});

const client: RouterClient<AppRouter> = createORPCClient(link)

[oorestisime]

I think i made it work. i removed the project reference and tried installing everything again and worked. not sure how this will be in vercel pipeline, i probably need to build the backend types first but will figure that part out

[unnoq]

@oorestisime here my recommendation for monorepo: #205 (comment)