Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
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.tsnew file mode 100644index 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.tsindex 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 Viewertype 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({