Files
PaperClipAI/server/src/middleware/cloud-tenant-actor.test.ts
T
DottaandClaude Opus 5.5 3659a3a947 fix(auth): stop holding a signed-in user's requests on an unchanged Cloud tenant sync (#21997)
## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - A Cloud instance authenticates each signed-in request from trusted
Cloud headers in `resolveCloudTenantActor`
> - Each such request, static files included, waits for one shared
per-user sync that writes the user, company and membership rows
> - The sync takes row locks even when nothing changes. When another
open transaction holds the same user's rows, the sync waits for the
lock. Every request of that user then waits for the same sync, with no
bound
> - On a hosted instance this hung all requests of one signed-in user
for about 6.5 minutes. Other users, background work and requests without
identity headers stayed fast
> - This pull request makes a request wait for the sync only when the
sync can change the actor's authority
> - The benefit is that a lock held elsewhere no longer takes a
signed-in user's pages down

## Linked Issues or Issue Description

No public issue exists.

**What happened?**
For one signed-in Cloud user, every request hung for about 6.5 minutes
and then all of them finished together. This included API routes, the
HTML page, fonts, plugin UI files and `/api/health`. Requests without
the user's identity headers (hashed `/assets/*.js`) took 6 to 18 ms in
the same minutes. Background workers kept logging normally. The process,
the event loop and the database stayed healthy.

**Expected behavior**
A user whose membership is already in place authenticates from the
membership read. A lock held by another transaction on the user's rows
does not hold the user's requests.

**Steps to reproduce**
1. Resolve a Cloud tenant actor once, so that the user and the
membership exist.
2. In another transaction, take `FOR KEY SHARE` on the user row and `FOR
UPDATE` on the membership row, and keep the transaction open.
3. Resolve the same actor again from a new client (no process-local
write debounce).
4. Before this change, the call does not return until step 2 commits.

**Relevant logs or output**
Request logs showed a p50 of about 10 s (the UI aborts at 10 s) and
tails up to 252 s. Every hung request carried the same Cloud user
header. All of them completed together when the lock cleared.

## What Changed

- `resolveCloudTenantActor` reads the user's memberships first. When the
stored primary membership is active and has the requested role, the
request does not wait for the tenant write sync. The sync finishes in
the background, a failure is logged, and idle and drain checks count it
until it settles.
- A new user, a role change, a status change or a failed membership read
still waits for the sync, as before.
- New PostgreSQL regression test: another transaction holds the user's
rows, and an already-synced user still authenticates in under 3 s with
the same companies and role. The existing grant-repair assertion now
waits for the background repair.

## Verification

- Red before the fix: `npx vitest run
src/middleware/cloud-tenant-sync-postgres.test.ts -t "already-synced
user"` timed out (`expected 'timed_out' not to be 'timed_out'`).
- Green after the fix:
`src/middleware/cloud-tenant-sync-postgres.test.ts` and
`src/middleware/cloud-tenant-actor.test.ts` pass (50 tests).
- Related suites pass: `cloud-tenant-actor-statements`,
`cloud-tenant-company-provisioning`, `auth-session-route`,
`company-cloud-floor` (25 tests).
- `tsc --noEmit -p server/tsconfig.json` passes.

## Risks

- Low. Authority still comes from the database read on each request. The
change only skips waiting for writes that cannot change that authority.
- A missing default grant for an unchanged membership is now repaired
just after the request instead of before it. Until the repair lands, the
gap fails closed (denied access), as it did before the first repair.
- A sync that stays stuck now holds idle work open in the background
instead of holding requests. The instance does not sleep until it
settles.

## Model Used

- Claude Opus 5.5 (`claude-opus-5-5`), Claude Code agent with tool use
(shell, file edits, test runs).

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 07:33:48 -06:00

597 lines
28 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import express, { type Request } from "express";
import request from "supertest";
import { and, eq } from "drizzle-orm";
import type { Db } from "@paperclipai/db";
import {
authUsers,
companies,
companyMemberships,
instanceSettings,
instanceUserRoles,
principalPermissionGrants,
} from "@paperclipai/db";
import { actorMiddleware, cloudActorHeaderSourceFromHeaders, resolveCloudTenantActor } from "./auth.js";
import { idleAdmissionMiddleware, trackIdleRequestHandlers } from "./idle-admission.js";
import { idleWorkSnapshot, startTaskDrain, stopTaskDrain } from "../services/task-admission.js";
import { readIdleSleepSafety } from "../services/idle-sleep-safety.js";
// Minimal fake Drizzle Db: records every table passed to .insert() / .delete() and
// supports the chained call shapes used by resolveCloudTenantActor (values /
// onConflictDo* / returning().then() / delete().where()), plus the
// select().from(table).where() reads: instanceSettings for the owner-elevation
// flag resolution through instanceSettingsService, and companyMemberships for
// the user's own membership rows (rows configurable via membershipQueryRows,
// where-conditions captured in selectWheres). The chain is awaitable so
// directly-awaited statements resolve.
function createFakeDb(options: {
membershipRow?: { companyId: string; membershipRole: string; status: string };
membershipQueryRows?: Array<{ companyId: string; membershipRole: string | null; status: string }>;
settingsRow?: Record<string, unknown> | null;
selectThrows?: boolean;
beforeWrite?: (table: unknown) => Promise<void>;
beforeRead?: (table: unknown) => Promise<void>;
unchangedMembership?: boolean;
} = {}) {
const settingsRow =
options.settingsRow === undefined
? {
id: "00000000-0000-0000-0000-000000000001",
singletonKey: "default",
defaultEnvironmentId: null,
general: {},
experimental: {},
createdAt: new Date(),
updatedAt: new Date(),
}
: options.settingsRow;
const insertedTables: unknown[] = [];
const deletedTables: unknown[] = [];
const selectWheres: Array<{ table: unknown; condition: unknown; locked?: boolean }> = [];
function writeChain(table: unknown) {
let values: unknown;
const chain: Record<string, unknown> = {};
chain.values = (value: unknown) => { values = value; return chain; };
chain.onConflictDoUpdate = () => chain;
chain.onConflictDoNothing = () => chain;
chain.where = () => chain;
chain.returning = async () => {
await options.beforeWrite?.(table);
return options.unchangedMembership && table === companyMemberships ? [] : [options.membershipRow ?? values];
};
chain.then = (resolve: (v: unknown) => unknown, reject?: (error: unknown) => unknown) =>
Promise.resolve().then(() => options.beforeWrite?.(table)).then(resolve, reject);
return chain;
}
const db = {
transaction: async (work: (tx: Db) => Promise<unknown>) => work(db),
// Session settings such as the grant repair's lock timeout.
execute: async () => [],
insert: (table: unknown) => {
insertedTables.push(table);
return writeChain(table);
},
delete: (table: unknown) => {
deletedTables.push(table);
return writeChain(table);
},
select: () => {
return {
from: (table: unknown) => ({
// Pending Muse bindings use a joined read; this fixture has none.
innerJoin() { return this; },
where: (condition: unknown) => {
// Only settings lookup is degradable. Membership locking and
// permission seeding must still work in the fail-closed flag test.
if (options.selectThrows && table === instanceSettings) {
throw new Error("select unavailable");
}
const selected: (typeof selectWheres)[number] = { table, condition };
selectWheres.push(selected);
const rows =
table === instanceSettings && settingsRow
? [settingsRow]
: table === companyMemberships
? (options.membershipQueryRows ?? [])
: [];
let locked = false;
const result = {
orderBy: () => ({ limit: () => result }),
for: () => { locked = true; selected.locked = true; return result; },
then: (resolve: (v: unknown) => unknown, reject?: (error: unknown) => unknown) => {
// The optional cross-company read can fail independently of
// the primary membership transaction, which must succeed.
const query = options.selectThrows && table === companyMemberships && !locked
? Promise.reject(new Error("select unavailable"))
: Promise.resolve(rows);
return Promise.resolve().then(() => options.beforeRead?.(table)).then(() => query).then(resolve, reject);
},
};
return result;
},
}),
};
},
} as unknown as Db;
return { db, insertedTables, deletedTables, selectWheres };
}
function settingsRowWith(experimental: Record<string, unknown>) {
return {
id: "00000000-0000-0000-0000-000000000001",
singletonKey: "default",
defaultEnvironmentId: null,
general: {},
experimental,
createdAt: new Date(),
updatedAt: new Date(),
};
}
function fakeReq(headers: Record<string, string>): Request {
const lower: Record<string, string> = {};
for (const [k, v] of Object.entries(headers)) lower[k.toLowerCase()] = v;
return { header: (name: string) => lower[name.toLowerCase()] } as unknown as Request;
}
const VALID_HEADERS = {
"x-paperclip-cloud-tenant-token": "test-server-token",
"x-paperclip-cloud-user-id": "user-123",
"x-paperclip-cloud-user-email": "Owner@Example.com",
"x-paperclip-cloud-stack-id": "stack-abc",
"x-paperclip-cloud-stack-role": "owner",
};
const MANAGED_CONFIG_FLAG_ON = JSON.stringify({
v: 1,
mode: "cloud",
catalogVersion: "test",
features: { enableOwnerInstanceAdmin: true },
plugins: { autoInstall: [] },
});
const MANAGED_CONFIG_FLAG_OFF = JSON.stringify({
v: 1,
mode: "cloud",
catalogVersion: "test",
features: { enableOwnerInstanceAdmin: false },
plugins: { autoInstall: [] },
});
describe("resolveCloudTenantActor (shared-pool hardening)", () => {
beforeEach(() => {
process.env.PAPERCLIP_CLOUD_TENANT_SERVER_TOKEN = "test-server-token";
});
afterEach(() => {
stopTaskDrain();
delete process.env.PAPERCLIP_CLOUD_TENANT_SERVER_TOKEN;
delete process.env.PAPERCLIP_MANAGED_CONFIG;
});
it("does not grant instance admin by default (flag off)", async () => {
const { db, insertedTables } = createFakeDb();
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor).not.toBeNull();
expect(actor!.isInstanceAdmin).toBe(false);
expect(insertedTables).not.toContain(instanceUserRoles);
});
it("stays scoped to exactly the stack's company when the user has no other membership rows", async () => {
const { db } = createFakeDb();
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor!.companyIds).toHaveLength(1);
expect(actor!.memberships).toHaveLength(1);
expect(actor?.memberships?.[0]?.companyId).toBe(actor?.companyIds?.[0]);
expect(actor?.memberships?.[0]?.membershipRole).toBe("owner");
expect(actor!.source).toBe("cloud_tenant");
});
it("settles its concurrent reads before a failed purge leaves authentication", async () => {
let settingsReadStarted = false;
let settingsReadSettled = false;
const { db } = createFakeDb({
beforeWrite: async (table) => {
if (table === instanceUserRoles) throw new Error("purge failed");
},
beforeRead: async (table) => {
if (table !== instanceSettings) return;
settingsReadStarted = true;
await new Promise((resolve) => setTimeout(resolve, 50));
settingsReadSettled = true;
},
});
await expect(resolveCloudTenantActor(db, fakeReq(VALID_HEADERS))).rejects.toThrow("purge failed");
// No started read may still be running once the error surfaces.
expect(settingsReadStarted).toBe(true);
expect(settingsReadSettled).toBe(true);
});
it("purges stale instance_admin rows left by pre-hardening deployments", async () => {
const { db, deletedTables } = createFakeDb();
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor).not.toBeNull();
expect(deletedTables).toContain(instanceUserRoles);
});
it("still upserts the user, company, and membership", async () => {
const { db, insertedTables } = createFakeDb();
await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(insertedTables).toContain(authUsers);
expect(insertedTables).toContain(companies);
expect(insertedTables).toContain(companyMemberships);
});
it.each(["/api/health", "/api/instance/task-drain", "/api/instance/task-drain/status"])("counts unfinished authentication on exempt %s requests", async (path) => {
let enterWrite!: () => void, finishWrite!: () => void;
const entered = new Promise<void>(resolve => { enterWrite = resolve; });
const pending = new Promise<void>(resolve => { finishWrite = resolve; });
const { db, insertedTables } = createFakeDb({ beforeWrite: async () => { enterWrite(); await pending; } });
const server = express();
server.use(idleAdmissionMiddleware);
server.use(actorMiddleware(db, { deploymentMode: "authenticated", resolveSession: async () => null }));
const hold = startTaskDrain({ purpose: "idle", ttlMs: 60_000 });
const emptyDb = { transaction: async (run: (tx: unknown) => Promise<unknown>) =>
run({ select: () => ({ from: () => ({ where: async () => [] }) }), execute: async () => [{ blocked: false }] }) } as unknown as Db;
server.get("/api/health", (_req, res) => res.sendStatus(204));
server.get("/api/instance/task-drain", async (_req, res) => {
res.json(await readIdleSleepSafety(emptyDb, () => ({ ...hold, draining: true, activeRuns: 0, pendingWakes: 0 }),
Date.now, hold.ownerId, async () => "none"));
});
server.post("/api/instance/task-drain/status", (_req, res) => res.sendStatus(204));
trackIdleRequestHandlers(server);
const accepted = (path.endsWith("/status") ? request(server).post(path) : request(server).get(path)).set(VALID_HEADERS).then(response => response);
try {
await entered;
expect(idleWorkSnapshot().active).toBeGreaterThan(0);
const during = await request(server).get("/api/instance/task-drain").expect(200);
expect(during.body.backgroundWork).toBe("unknown");
} finally {
finishWrite();
await accepted;
}
expect(insertedTables).toEqual(expect.arrayContaining([authUsers, companies, companyMemberships]));
expect(idleWorkSnapshot().active).toBe(0);
const after = await request(server).get("/api/instance/task-drain").expect(200);
expect(after.body.backgroundWork).toBe("none");
});
it("releases failed control authentication and preserves Express error handling", async () => {
const { db } = createFakeDb({ beforeWrite: async () => { throw new Error("fixture write failed"); } });
const server = express();
server.use(idleAdmissionMiddleware);
server.use(actorMiddleware(db, { deploymentMode: "authenticated", resolveSession: async () => null }));
server.get("/api/health", (_req, res) => res.sendStatus(204));
server.use((_err: Error, _req: express.Request, res: express.Response, _next: express.NextFunction) => res.sendStatus(500));
trackIdleRequestHandlers(server);
await request(server).get("/api/health").set(VALID_HEADERS).expect(500);
expect(idleWorkSnapshot().active).toBe(0);
await request(server).get("/api/health").expect(204);
});
it("resyncs an A to B to A context transition inside the debounce window", async () => {
const { db, insertedTables } = createFakeDb();
const contextA = VALID_HEADERS;
const contextB = { ...VALID_HEADERS, "x-paperclip-cloud-stack-role": "member" };
await resolveCloudTenantActor(db, fakeReq(contextA));
await resolveCloudTenantActor(db, fakeReq(contextB));
await resolveCloudTenantActor(db, fakeReq(contextA));
expect(insertedTables.filter((table) => table === authUsers)).toHaveLength(3);
expect(insertedTables.filter((table) => table === companyMemberships)).toHaveLength(3);
});
it("coalesces concurrent identical syncs and settings reads while keeping membership reads and stale-admin purges per request", async () => {
let release!: () => void;
let entered!: () => void;
const blocked = new Promise<void>(resolve => { release = resolve; });
const started = new Promise<void>(resolve => { entered = resolve; });
const { db, insertedTables, deletedTables, selectWheres } = createFakeDb({
beforeWrite: async table => { if (table === authUsers) { entered(); await blocked; } },
});
const requests = Array.from({ length: 20 }, () => resolveCloudTenantActor(db, fakeReq(VALID_HEADERS)));
await started;
expect(insertedTables.filter(table => table === authUsers)).toHaveLength(1);
release();
const actors = await Promise.all(requests);
expect(insertedTables.filter(table => table === companyMemberships)).toHaveLength(1);
expect(deletedTables.filter(table => table === instanceUserRoles)).toHaveLength(20);
expect(selectWheres.filter(entry => entry.table === instanceSettings)).toHaveLength(1);
expect(selectWheres.filter(entry => entry.table === companyMemberships && !entry.locked)).toHaveLength(20);
expect(selectWheres.filter(entry => entry.table === companyMemberships && entry.locked)).toHaveLength(1);
expect(actors.every(actor => actor?.memberships?.[0]?.membershipRole === "owner")).toBe(true);
});
it("serializes concurrent A to B to A without sharing the wrong role", async () => {
let release!: () => void;
let entered!: () => void;
const blocked = new Promise<void>(resolve => { release = resolve; });
const started = new Promise<void>(resolve => { entered = resolve; });
let writes = 0;
const { db, insertedTables } = createFakeDb({ beforeWrite: async table => {
if (table === authUsers && ++writes === 1) { entered(); await blocked; }
} });
const first = resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
await started;
const second = resolveCloudTenantActor(db, fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-stack-role": "member" }));
const third = resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
release();
const actors = await Promise.all([first, second, third]);
expect(actors.map(actor => actor?.memberships?.[0]?.membershipRole)).toEqual(["owner", "member", "owner"]);
expect(insertedTables.filter(table => table === companyMemberships)).toHaveLength(3);
});
it("does not block another user behind a slow user's synchronization", async () => {
let release!: () => void;
let entered!: () => void;
const blocked = new Promise<void>(resolve => { release = resolve; });
const started = new Promise<void>(resolve => { entered = resolve; });
let firstWrite = true;
const { db } = createFakeDb({ beforeWrite: async table => {
if (table === authUsers && firstWrite) { firstWrite = false; entered(); await blocked; }
} });
const slow = resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
await started;
try {
const other = await resolveCloudTenantActor(db, fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-user-id": "other-user" }));
expect(other?.userId).toBe("other-user");
} finally {
release();
await slow;
}
});
it("does not debounce a failed partial context transition or its repair", async () => {
let fail = false;
const { db, insertedTables } = createFakeDb({ beforeWrite: async table => {
if (fail && table === companyMemberships) throw new Error("partial sync failed");
} });
await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
fail = true;
await expect(resolveCloudTenantActor(db, fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-stack-role": "member" })))
.rejects.toThrow("partial sync failed");
fail = false;
const repaired = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(repaired?.memberships?.[0]?.membershipRole).toBe("owner");
expect(insertedTables.filter(table => table === companyMemberships)).toHaveLength(3);
});
it("retries a shared transient failure and completes default grants once", async () => {
let failed = false;
const { db, insertedTables } = createFakeDb({ beforeWrite: async table => {
if (!failed && table === companyMemberships) {
failed = true;
throw Object.assign(new Error("synthetic connection loss"), { code: "CONNECTION_CLOSED" });
}
} });
const actors = await Promise.all(Array.from({ length: 10 }, () => resolveCloudTenantActor(db, fakeReq(VALID_HEADERS))));
expect(actors.every(actor => actor?.memberships?.[0]?.membershipRole === "owner")).toBe(true);
expect(insertedTables.filter(table => table === companyMemberships)).toHaveLength(2);
expect(insertedTables.filter(table => table === principalPermissionGrants)).toHaveLength(1);
});
it("keeps default-grant repair and the input role when a guarded upsert returns no row", async () => {
const { db, insertedTables } = createFakeDb({ unchangedMembership: true });
const actor = await resolveCloudTenantActor(db, fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-stack-role": "member" }));
expect(actor?.memberships?.[0]?.membershipRole).toBe("member");
expect(insertedTables).toContain(principalPermissionGrants);
});
it("does not share completed syncs across databases or companies", async () => {
const first = createFakeDb();
const second = createFakeDb();
await Promise.all([resolveCloudTenantActor(first.db, fakeReq(VALID_HEADERS)), resolveCloudTenantActor(second.db, fakeReq(VALID_HEADERS))]);
await resolveCloudTenantActor(first.db, fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-stack-id": "stack-other" }));
expect(first.insertedTables.filter(table => table === companyMemberships)).toHaveLength(2);
expect(second.insertedTables.filter(table => table === companyMemberships)).toHaveLength(1);
});
it("resyncs when the requested company name changes", async () => {
const { db, insertedTables } = createFakeDb();
await resolveCloudTenantActor(db, fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-paperclip-company-name": "First" }));
await resolveCloudTenantActor(db, fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-paperclip-company-name": "Second" }));
expect(insertedTables.filter(table => table === companyMemberships)).toHaveLength(2);
});
it("resumes membership and grant repair after the existing five-second debounce expires", async () => {
const now = Date.now();
const clock = vi.spyOn(Date, "now").mockReturnValue(now);
try {
const { db, insertedTables } = createFakeDb();
await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(insertedTables.filter(table => table === companyMemberships)).toHaveLength(1);
clock.mockReturnValue(now + 5_001);
await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(insertedTables.filter(table => table === companyMemberships)).toHaveLength(2);
expect(insertedTables.filter(table => table === principalPermissionGrants)).toHaveLength(2);
} finally { clock.mockRestore(); }
});
it("returns null when the server token is unset", async () => {
delete process.env.PAPERCLIP_CLOUD_TENANT_SERVER_TOKEN;
const { db } = createFakeDb();
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor).toBeNull();
});
it("resolves identically from a raw upgrade-request header map via the shim", async () => {
// Websocket upgrades hand us IncomingMessage.headers (lowercased keys,
// possibly string[] values), not an Express Request. The shim must feed
// resolveCloudTenantActor the same way Express header() does.
const { db } = createFakeDb();
const rawHeaders: Record<string, string | string[] | undefined> = {};
for (const [k, v] of Object.entries(VALID_HEADERS)) rawHeaders[k.toLowerCase()] = v;
rawHeaders["x-paperclip-cloud-user-name"] = ["Cloud Owner", "ignored-duplicate"];
const actor = await resolveCloudTenantActor(db, cloudActorHeaderSourceFromHeaders(rawHeaders));
expect(actor).not.toBeNull();
expect(actor!.userId).toBe("user-123");
expect(actor!.userName).toBe("Cloud Owner");
expect(actor!.companyIds).toHaveLength(1);
});
it("maps a non-owner stack role through to the membership without elevating", async () => {
const { db } = createFakeDb({
membershipRow: { companyId: "company-y", membershipRole: "member", status: "active" },
});
const actor = await resolveCloudTenantActor(
db,
fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-stack-role": "member" }),
);
expect(actor!.isInstanceAdmin).toBe(false);
expect(actor?.memberships?.[0]?.membershipRole).toBe("member");
});
it.each(["admin", "member", "support"])(
"grants experimental settings access only to the admin stack role (%s)",
async (stackRole) => {
const { db, insertedTables } = createFakeDb();
const actor = await resolveCloudTenantActor(
db,
fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-stack-role": stackRole }),
);
expect(actor?.canManageExperimentalSettings).toBe(stackRole === "admin");
expect(actor?.isInstanceAdmin).toBe(false);
expect(insertedTables).not.toContain(instanceUserRoles);
},
);
it("removes experimental settings access on the next request after a stack admin is demoted", async () => {
const { db } = createFakeDb();
const admin = await resolveCloudTenantActor(
db,
fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-stack-role": "admin" }),
);
const member = await resolveCloudTenantActor(
db,
fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-stack-role": "member" }),
);
expect(admin?.canManageExperimentalSettings).toBe(true);
expect(member?.canManageExperimentalSettings).toBe(false);
});
describe("company membership union", () => {
// The primary company id is derived from the stack id; resolve it once
// through the same code path instead of duplicating the hash here.
async function resolvePrimaryCompanyId() {
const { db } = createFakeDb();
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
return actor!.companyIds![0]!;
}
it("unions the pinned primary with the user's own active membership rows, primary first and deduped", async () => {
const primaryCompanyId = await resolvePrimaryCompanyId();
const { db } = createFakeDb({
membershipQueryRows: [
// The user's own row for the primary company comes back from the
// query too — it must not appear twice.
{ companyId: primaryCompanyId, membershipRole: "owner", status: "active" },
{ companyId: "company-imported", membershipRole: "member", status: "active" },
],
});
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor!.companyIds).toEqual([primaryCompanyId, "company-imported"]);
expect(actor!.memberships).toEqual([
{ companyId: primaryCompanyId, membershipRole: "owner", status: "active" },
{ companyId: "company-imported", membershipRole: "member", status: "active" },
]);
});
it("loads memberships with the session path's exact own-user active-status filter", async () => {
const { db, selectWheres } = createFakeDb();
await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
const membershipSelects = selectWheres.filter((entry) => entry.table === companyMemberships);
expect(membershipSelects).toHaveLength(2);
// One read locks the primary membership before its upsert; the other,
// which runs concurrently, loads the user's active memberships for
// request authorization. Rows for other users and rows in any
// non-active status are excluded by the query itself: the filter binds
// exactly this user id and the "active" status — the same condition
// the session path applies.
const authorizationReads = membershipSelects.filter((entry) => !entry.locked);
expect(authorizationReads).toHaveLength(1);
expect(authorizationReads[0]!.condition).toEqual(
and(
eq(companyMemberships.principalType, "user"),
eq(companyMemberships.principalId, "user-123"),
eq(companyMemberships.status, "active"),
),
);
});
it("degrades to the primary company when the membership read fails", async () => {
const { db } = createFakeDb({ selectThrows: true });
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor).not.toBeNull();
expect(actor!.companyIds).toHaveLength(1);
expect(actor!.memberships).toHaveLength(1);
});
});
describe("owner instance-admin elevation (enableOwnerInstanceAdmin)", () => {
it("elevates the owner while the flag is enabled, still without any role row", async () => {
const { db, insertedTables, deletedTables } = createFakeDb({
settingsRow: settingsRowWith({ enableOwnerInstanceAdmin: true }),
});
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor!.isInstanceAdmin).toBe(true);
expect(actor!.source).toBe("cloud_tenant");
// Elevation is computed, never persisted: no instance_user_roles insert,
// and the stale-row purge still runs on every authentication.
expect(insertedTables).not.toContain(instanceUserRoles);
expect(deletedTables).toContain(instanceUserRoles);
});
it("does not elevate the owner while the flag is disabled", async () => {
const { db } = createFakeDb({
settingsRow: settingsRowWith({ enableOwnerInstanceAdmin: false }),
});
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor!.isInstanceAdmin).toBe(false);
});
it.each(["member", "admin", "support"] as const)(
"never elevates the %s stack role even with the flag enabled",
async (stackRole) => {
const { db } = createFakeDb({
membershipRow: { companyId: "company-y", membershipRole: "member", status: "active" },
settingsRow: settingsRowWith({ enableOwnerInstanceAdmin: true }),
});
const actor = await resolveCloudTenantActor(
db,
fakeReq({ ...VALID_HEADERS, "x-paperclip-cloud-stack-role": stackRole }),
);
expect(actor).not.toBeNull();
expect(actor!.isInstanceAdmin).toBe(false);
},
);
it("resolves the flag through the managed overlay: overlay on elevates over a DB value of off", async () => {
process.env.PAPERCLIP_MANAGED_CONFIG = MANAGED_CONFIG_FLAG_ON;
const { db } = createFakeDb({
settingsRow: settingsRowWith({ enableOwnerInstanceAdmin: false }),
});
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor!.isInstanceAdmin).toBe(true);
});
it("resolves the flag through the managed overlay: overlay off wins over a DB value of on", async () => {
process.env.PAPERCLIP_MANAGED_CONFIG = MANAGED_CONFIG_FLAG_OFF;
const { db } = createFakeDb({
settingsRow: settingsRowWith({ enableOwnerInstanceAdmin: true }),
});
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor!.isInstanceAdmin).toBe(false);
});
it("fails closed when the settings read errors: actor resolves without elevation", async () => {
const { db, deletedTables } = createFakeDb({ selectThrows: true });
const actor = await resolveCloudTenantActor(db, fakeReq(VALID_HEADERS));
expect(actor).not.toBeNull();
expect(actor!.isInstanceAdmin).toBe(false);
expect(deletedTables).toContain(instanceUserRoles);
});
});
});