Skip to content

Open-source status page, incident response and uptime monitoring

perf: resolve active workspace once per request instead of per procedure (#2470)

Maximilian Kaskeaedde07ce7a6
diff --git a/packages/api/src/trpc.test.ts b/packages/api/src/trpc.test.ts
new file mode 100644
index 000000000..82887bec2
--- /dev/null
+++ b/packages/api/src/trpc.test.ts
@@ -0,0 +1,118 @@
+import { expect } from "@std/expect";
+import { test } from "@std/testing/bdd";
+import { NextRequest } from "next/server.js";
+
+import type { ResolveActiveWorkspaceResult } from "./auth/resolve-active-workspace";
+import {
+ createInnerTRPCContext,
+ createTRPCContext,
+ createTRPCRouter,
+ protectedProcedure,
+} from "./trpc";
+
+const testRouter = createTRPCRouter({
+ whoami: protectedProcedure.query(({ ctx }) => ({
+ userId: ctx.user.id,
+ workspaceSlug: ctx.workspace.slug,
+ })),
+});
+
+function makeRequest(cookie?: string) {
+ return new NextRequest("http://localhost:3000/api/trpc/lambda", {
+ headers: cookie ? { cookie } : undefined,
+ });
+}
+
+test("protected procedure rejects without a session", async () => {
+ const ctx = createInnerTRPCContext({ session: null });
+ const caller = testRouter.createCaller(ctx);
+
+ await expect(caller.whoami()).rejects.toThrow("UNAUTHORIZED");
+});
+
+test("protected procedure resolves seeded user and workspace", async () => {
+ const ctx = await createTRPCContext({
+ req: makeRequest("workspace-slug=love-openstatus"),
+ auth: async () => ({ user: { id: "1" } }),
+ });
+ const caller = testRouter.createCaller(ctx);
+
+ const result = await caller.whoami();
+
+ expect(result).toEqual({ userId: 1, workspaceSlug: "love-openstatus" });
+});
+
+test("falls back to the first workspace when the cookie slug is stale", async () => {
+ const ctx = await createTRPCContext({
+ req: makeRequest("workspace-slug=does-not-exist"),
+ auth: async () => ({ user: { id: "1" } }),
+ });
+ const caller = testRouter.createCaller(ctx);
+
+ const result = await caller.whoami();
+
+ expect(result).toEqual({ userId: 1, workspaceSlug: "love-openstatus" });
+});
+
+test("resolveWorkspace memoizes the resolution within one request context", async () => {
+ const ctx = await createTRPCContext({
+ req: makeRequest(),
+ auth: async () => ({ user: { id: "1" } }),
+ });
+
+ const first = ctx.resolveWorkspace?.();
+ const second = ctx.resolveWorkspace?.();
+
+ expect(second).toBe(first);
+
+ const resolved = await first;
+ expect(resolved?.ok).toBe(true);
+});
+
+test("resolveWorkspace is not shared across request contexts", async () => {
+ const auth = async () => ({ user: { id: "1" } });
+ const a = await createTRPCContext({ req: makeRequest(), auth });
+ const b = await createTRPCContext({ req: makeRequest(), auth });
+
+ const resolvedA = a.resolveWorkspace?.();
+ const resolvedB = b.resolveWorkspace?.();
+
+ expect(resolvedB).not.toBe(resolvedA);
+ await Promise.all([resolvedA, resolvedB]);
+});
+
+test("middleware uses the context resolver instead of querying directly", async () => {
+ let calls = 0;
+ const resolveWorkspace = (): Promise<ResolveActiveWorkspaceResult> => {
+ calls++;
+ // safe because the middleware only reads user.id and workspace.slug
+ return Promise.resolve({
+ ok: true,
+ value: { user: { id: 42 }, workspace: { slug: "stubbed-workspace" } },
+ } as unknown as ResolveActiveWorkspaceResult);
+ };
+
+ const ctx = createInnerTRPCContext({
+ session: { user: { id: "42" } },
+ resolveWorkspace,
+ });
+ const caller = testRouter.createCaller(ctx);
+
+ const result = await caller.whoami();
+
+ expect(result).toEqual({ userId: 42, workspaceSlug: "stubbed-workspace" });
+ expect(calls).toBe(1);
+});
+
+test("middleware surfaces workspace_not_found as UNAUTHORIZED", async () => {
+ const resolveWorkspace = (): Promise<ResolveActiveWorkspaceResult> =>
+ Promise.resolve({ ok: false, error: { kind: "workspace_not_found" } });
+
+ const ctx = createInnerTRPCContext({
+ session: { user: { id: "42" } },
+ resolveWorkspace,
+ });
+ const caller = testRouter.createCaller(ctx);
+
+ await expect(caller.whoami()).rejects.toThrow("Workspace Not Found");
+});
diff --git a/packages/api/src/trpc.ts b/packages/api/src/trpc.ts
index d82259216..cbfa29092 100644
--- a/packages/api/src/trpc.ts
+++ b/packages/api/src/trpc.ts
@@ -11,7 +11,10 @@ import { type NextRequest, after } from "next/server.js";
import superjson from "superjson";
import { ZodError, treeifyError } from "zod";
-import { resolveActiveWorkspace } from "./auth/resolve-active-workspace";
+import {
+ type ResolveActiveWorkspaceResult,
+ resolveActiveWorkspace,
+} from "./auth/resolve-active-workspace";
// Generic session type that works with both User and Viewer
type Session = {
@@ -39,6 +42,7 @@ type CreateContextOptions = {
userAgent?: string;
location?: string;
};
+ resolveWorkspace?: () => Promise<ResolveActiveWorkspaceResult>;
};
type Meta = {
@@ -77,10 +81,22 @@ export const createTRPCContext = async (opts: {
const workspace = null;
const user = null;
+ // Context is per HTTP request while middleware runs per procedure — a
+ // batched request would otherwise re-run the same user×workspaces query
+ // once per procedure. Zero-arg by design: userId/slug are bound here so
+ // the first call's promise is safe to share across the whole batch.
+ let resolution: Promise<ResolveActiveWorkspaceResult> | undefined;
+ const resolveWorkspace = () =>
+ (resolution ??= resolveActiveWorkspace({
+ userId: Number(session?.user?.id),
+ workspaceSlug: opts.req.cookies.get("workspace-slug")?.value,
+ }));
+
return createInnerTRPCContext({
session,
workspace,
user,
+ resolveWorkspace,
req: opts.req,
metadata: {
userAgent: opts.req.headers.get("user-agent") ?? undefined,
@@ -174,10 +190,12 @@ const enforceUserIsAuthed = t.middleware(async (opts) => {
*/
const workspaceSlug = ctx.req?.cookies.get("workspace-slug")?.value;
- const resolved = await resolveActiveWorkspace({
- userId: Number(ctx.session.user.id),
- workspaceSlug,
- });
+ const resolved = await (ctx.resolveWorkspace
+ ? ctx.resolveWorkspace()
+ : resolveActiveWorkspace({
+ userId: Number(ctx.session.user.id),
+ workspaceSlug,
+ }));
if (!resolved.ok) {
throw new TRPCError({