isDefinedError doesn't work when using globalThis.$client for SSR optimization in nextjs

[roErlend]

Environment

Nextjs 15.3.1
"@orpc/react": "^1.8.5",
"@orpc/server": "^1.8.5",

Reproduction

Can provide if it is deemed a bug, and not just a misunderstanding

Describe the bug

I'm following the documentation for setting up orpc in nextjs, and have also looked the example playground for nextjs.

orpc.ts:

const link = new RPCLink({
  url: `${env.NEXT_PUBLIC_APP_URL}/api/rpc`,
});

/**
 * Fallback to client-side client if server-side client is not available.
 */
export const orpcClient: RouterClient<typeof appRouter> = globalThis.$client ?? createORPCClient(link);

orpc.server.ts:

/**
 * This is part of the Optimize SSR setup.
 *
 * @see {@link https://orpc.unnoq.com/docs/adapters/next#optimize-ssr}
 */
globalThis.$client = createRouterClient(appRouter, {
  /**
   * Provide initial context if needed.
   *
   * Because this client instance is shared across all requests,
   * only include context that's safe to reuse globally.
   * For per-request context, use middleware context or pass a function as the initial context.
   */
  context: async () => ({
    headers: await headers(), // provide headers if initial context required
  }),
});

const { error, data, isDefined } = await safe(orpcClient.orderModule.powerPriceSummary());
  console.log("🚀 ~ TestPage ~ isDefined:", isDefined);
  console.log("🚀 ~ TestPage ~ data:", data);
  console.log("🚀 ~ TestPage ~ error:", error);
  if (isDefinedError(error) && error.code === "UNAUTHORIZED") {
    // Never reaches here
  }

I have defined UNAUTHORIZED as a base error that my middleware throws like this:

    if (!session?.accessToken) {
      throw errors.UNAUTHORIZED({ message: "You must be logged in to access this resource." });
    }

When looking at the logged error, it looks correct, and defined is true.
The problem is that isDefinedError returns false, along with isDefined from the safe function. The procedure is called in a server component, and so the globalThis.$client seems to be used. If I remove that part of the code so that the orpcClient is always the createORPCClient(link) variant, then it works, but I'm not willing to give up the SSR optimization in order to get type safe errors here.
Is this expected behavior? Is there another apporach I am expected to use? I couldn't find anything in the documentation regarding this, and everywhere I read about it, it seems like it's just expected to work

Additional context

No response

Logs

Logs from the example code

Server  🚀 ~ session: null authMiddleware.ts:13:13
Server  🚀 ~ TestPage ~ isDefined: false page.tsx:12:11
Server  🚀 ~ TestPage ~ data: undefined page.tsx:13:11
Server  🚀 ~ TestPage ~ error: Object { defined: true, code: "UNAUTHORIZED", status: 401, message: "You must be logged in to access this resource." }

[dinwwwh]

The problem may be related to multiple definitions for the ORPCError class. Let's try to deduplicate dependencies to see if the problem is resolved.

Server  🚀 ~ TestPage ~ error: Object { defined: true, code: "UNAUTHORIZED", status: 401, message: "You must be logged in to access this resource." }

Isn't the error an instanceof ORPCError?

isDefinedError is a very simple check. You can look at it here, maybe it can help you debug why it doesn't return true:
https://github.com/unnoq/orpc/blob/main/packages/client/src/error.ts#L138

---

Another problem may be related to Next.js turborepo. Let's try webpack instead.

[roErlend]

I am defining an error base like this

const baseErrors = os.errors({
  UNAUTHORIZED: {},
});

Both the middleware that throws the error and the procedure I am calling is based on this object. I would think that it is an ORPCError object since it is thrown by using the errors object in the middleware:

const authMiddleware = baseErrors
  .$context<{ session?: Session }>()
  .middleware(async ({ context, next, errors }) => {
    // Lazy-load to avoid side-effects at import time
    const { getServerSession } = await import("@elmeragroup/auth");
    const session: Session | null = context.session ?? (await getServerSession());

    if (!session?.accessToken) {
      throw errors.UNAUTHORIZED({ message: "You must be logged in to access this resource." });
    }

    return next({
      context: {
        session,
      },
    });
  });

It looks to be the correct type when hovering over it:

I did try to disable turbopack, and it seems to work then. Unfortunately, other parts of my app breaks when I do this, so it's not really feasible for me.

[dinwwwh]

I did try to disable turbopack, and it seems to work then.

So, I believe this is a Turbopack problem rather than an oRPC one.

Or, you could try a custom isDefinedError to not rely on instanceof:

export function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>> {
  return (
    error != null &&
    typeof error === 'object' &&
    Object.getPrototypeOf(error)?.constructor?.name === 'ORPCError' &&
    'defined' in error &&
    error.defined
  );
}

[roErlend]

That worked! Thank you very much

[dinwwwh]

This PR will support this drawback from nextjs: https://github.com/unnoq/orpc/pull/972