diff --git a/server/src/__tests__/cloud-tenant-actor-statements.test.ts b/server/src/__tests__/cloud-tenant-actor-statements.test.ts new file mode 100644 index 00000000000..5aaab49c123 --- /dev/null +++ b/server/src/__tests__/cloud-tenant-actor-statements.test.ts @@ -0,0 +1,116 @@ +import { resolveExternalTestDatabaseUrl } from "./helpers/external-test-database.js"; +import { afterAll, beforeAll, describe, expect, it } from "vitest"; +import { and, eq } from "drizzle-orm"; +import { + activityLog, + authUsers, + companies, + companyMemberships, + createDb, + instanceUserRoles, + principalPermissionGrants, +} from "@paperclipai/db"; +import { + getEmbeddedPostgresTestSupport, + startEmbeddedPostgresTestDatabase, +} from "./helpers/embedded-postgres.js"; +import { meterDatabaseStatements } from "./helpers/database-statement-meter.js"; +import { cloudActorHeaderSourceFromHeaders, resolveCloudTenantActor } from "../middleware/auth.js"; + +const external = resolveExternalTestDatabaseUrl("PAPERCLIP_CLOUD_PROVISIONING_TEST_DATABASE_URL"); +const embeddedPostgresSupport = external ? { supported: true, reason: undefined } : await getEmbeddedPostgresTestSupport(); +const describeEmbeddedPostgres = embeddedPostgresSupport.supported ? describe : describe.skip; + +const SERVER_TOKEN = "test-server-token"; + +function tenantHeaders(userId: string, stackRole: string) { + return cloudActorHeaderSourceFromHeaders({ + "x-paperclip-cloud-tenant-token": SERVER_TOKEN, + "x-paperclip-cloud-user-id": userId, + "x-paperclip-cloud-user-email": `${userId}@example.com`, + "x-paperclip-cloud-stack-id": `stack-${userId}`, + "x-paperclip-cloud-stack-role": stackRole, + }); +} + +const writes = (statements: { sql: string }[]) => + statements.filter((entry) => /^\s*(delete|insert|update)\b/i.test(entry.sql)).map((entry) => entry.sql); + +describeEmbeddedPostgres("cloud tenant actor statements per request", () => { + let tempDb: Awaited> | null = null; + let db!: ReturnType; + let meter!: ReturnType; + + beforeAll(async () => { + if (!external) tempDb = await startEmbeddedPostgresTestDatabase("paperclip-tenant-statements-"); + const url = external ?? tempDb!.connectionString; + db = createDb(url); + meter = meterDatabaseStatements(db, url); + process.env.PAPERCLIP_CLOUD_TENANT_SERVER_TOKEN = SERVER_TOKEN; + }, 30_000); + + afterAll(async () => { + delete process.env.PAPERCLIP_CLOUD_TENANT_SERVER_TOKEN; + meter?.uninstall(); + await db?.delete(activityLog); + await db?.delete(principalPermissionGrants); + await db?.delete(companyMemberships); + await db?.delete(companies); + await db?.delete(instanceUserRoles); + await db?.delete(authUsers); + await db?.$client.end({ timeout: 1 }); + await tempDb?.cleanup(); + }); + + async function resolveMetered(userId: string, stackRole: string) { + const before = meter.read(); + meter.startLog(); + const actor = await resolveCloudTenantActor(db, tenantHeaders(userId, stackRole)); + const statements = meter.stopLog(); + return { actor, statements, count: meter.read().statements - before.statements }; + } + + async function staleAdminRows(userId: string) { + return db.select({ id: instanceUserRoles.id }).from(instanceUserRoles) + .where(and(eq(instanceUserRoles.userId, userId), eq(instanceUserRoles.role, "instance_admin"))); + } + + it("sends one read and no write for an unchanged authenticated request", async () => { + await resolveCloudTenantActor(db, tenantHeaders("user-steady", "member")); + const { actor, statements, count } = await resolveMetered("user-steady", "member"); + expect(actor).toMatchObject({ type: "board", userId: "user-steady", isInstanceAdmin: false }); + expect(writes(statements)).toEqual([]); + expect(count).toBe(1); + }); + + it("purges a stale instance_admin row on the very next request", async () => { + await resolveCloudTenantActor(db, tenantHeaders("user-stale", "member")); + await db.insert(instanceUserRoles).values({ userId: "user-stale", role: "instance_admin" }); + expect(await staleAdminRows("user-stale")).toHaveLength(1); + + const { actor, statements } = await resolveMetered("user-stale", "member"); + expect(actor).toMatchObject({ isInstanceAdmin: false }); + expect(writes(statements)).toEqual([expect.stringMatching(/^delete from "instance_user_roles"/)]); + expect(await staleAdminRows("user-stale")).toHaveLength(0); + + const next = await resolveMetered("user-stale", "member"); + expect(writes(next.statements)).toEqual([]); + }); + + it("applies a stack role added or removed in the header on the very next request", async () => { + const member = await resolveMetered("user-roles", "member"); + expect(member.actor?.memberships?.[0]?.membershipRole).toBe("member"); + expect(member.actor?.canManageExperimentalSettings).toBe(false); + + const admin = await resolveMetered("user-roles", "admin"); + expect(admin.actor?.memberships?.[0]?.membershipRole).toBe("owner"); + expect(admin.actor?.canManageExperimentalSettings).toBe(true); + + const demoted = await resolveMetered("user-roles", "member"); + expect(demoted.actor?.memberships?.[0]?.membershipRole).toBe("member"); + expect(demoted.actor?.canManageExperimentalSettings).toBe(false); + const [stored] = await db.select({ membershipRole: companyMemberships.membershipRole }).from(companyMemberships) + .where(and(eq(companyMemberships.principalType, "user"), eq(companyMemberships.principalId, "user-roles"))); + expect(stored?.membershipRole).toBe("member"); + }); +}); diff --git a/server/src/middleware/auth.ts b/server/src/middleware/auth.ts index b8106d6fdb3..0d1c2725ae3 100644 --- a/server/src/middleware/auth.ts +++ b/server/src/middleware/auth.ts @@ -104,6 +104,14 @@ async function loadResponsibleUserMemberships( * locally authenticated session actor carries. Shared by the session path * and the Cloud trusted-header path so both resolve the same access set. */ +function activeUserMembershipFilter(userId: string) { + return and( + eq(companyMemberships.principalType, "user"), + eq(companyMemberships.principalId, userId), + eq(companyMemberships.status, "active"), + ); +} + async function loadActiveUserCompanyMemberships(db: Db, userId: string) { return db .select({ @@ -112,13 +120,20 @@ async function loadActiveUserCompanyMemberships(db: Db, userId: string) { status: companyMemberships.status, }) .from(companyMemberships) - .where( - and( - eq(companyMemberships.principalType, "user"), - eq(companyMemberships.principalId, userId), - eq(companyMemberships.status, "active"), - ), - ); + .where(activeUserMembershipFilter(userId)); +} + +async function loadCloudTenantMembershipsWithStaleAdmin(db: Db, userId: string) { + return db + .select({ + companyId: companyMemberships.companyId, + membershipRole: companyMemberships.membershipRole, + status: companyMemberships.status, + staleInstanceAdmin: sql`exists (select 1 from ${instanceUserRoles} + where ${instanceUserRoles.userId} = ${userId} and ${instanceUserRoles.role} = 'instance_admin')`, + }) + .from(companyMemberships) + .where(activeUserMembershipFilter(userId)); } async function auditAgentJwtRunHeaderMismatch( @@ -612,15 +627,21 @@ async function resolveCloudTenantActorOnce( // service's own instanceUserRoles lookup — so actively purge them on every // trusted-header authentication instead of merely no longer inserting them. // - // Every request runs this path, static files included. The purge and the - // tenant sync stay ordered; the two reads below are independent of them, so - // they run concurrently. A loaded database then costs one round trip per - // request rather than three in a row. - const purgeAndSync = (async () => { + // Every request runs this path, static files included. The membership read + // below reports whether such a row exists, so the purge runs only when one + // does, or when that read cannot tell. A loaded database then costs one + // round trip per request rather than three in a row. + const membershipRowsRead = loadCloudTenantMembershipsWithStaleAdmin(db, userId); + const purgeStaleInstanceAdmin = async () => { await db .delete(instanceUserRoles) .where(and(eq(instanceUserRoles.userId, userId), eq(instanceUserRoles.role, "instance_admin"))); - + }; + const purge = membershipRowsRead.then( + (rows) => rows.length === 0 || rows.some((row) => row.staleInstanceAdmin) ? purgeStaleInstanceAdmin() : undefined, + () => purgeStaleInstanceAdmin(), + ); + const tenantSync = (async () => { await syncCloudTenantWrites(db, userId, syncFingerprint, async () => { const now = new Date(); await db @@ -708,8 +729,10 @@ async function resolveCloudTenantActorOnce( // blocking authentication, mirroring the fail-closed owner-elevation // resolution below. const additionalMembershipsRead: Promise<{ companyId: string; membershipRole: string | null; status: string }[]> = - loadActiveUserCompanyMemberships(db, userId).then( - (rows) => rows.filter((row) => row.companyId !== companyId), + membershipRowsRead.then( + (rows) => rows + .filter((row) => row.companyId !== companyId) + .map((row) => ({ companyId: row.companyId, membershipRole: row.membershipRole, status: row.status })), (err) => { logger.warn( { err, userId, stackId }, @@ -728,11 +751,13 @@ async function resolveCloudTenantActorOnce( // Settle every started statement before an error leaves: the caller stops // counting authentication work for idle and drain checks when this throws, // and the owner-settings read can insert the missing settings row. - const [synced, membershipsRead, ownerRead] = await Promise.allSettled([ - purgeAndSync, + const [purged, synced, membershipsRead, ownerRead] = await Promise.allSettled([ + purge, + tenantSync, additionalMembershipsRead, ownerInstanceAdminRead, ]); + if (purged.status === "rejected") throw purged.reason; if (synced.status === "rejected") throw synced.reason; if (membershipsRead.status === "rejected") throw membershipsRead.reason; if (ownerRead.status === "rejected") throw ownerRead.reason;