From 51c4e1b332d71a709512d4a2dd35ea3a27c7f0dc Mon Sep 17 00:00:00 2001 From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com> Date: Tue, 17 Nov 2026 01:41:47 +0000 Subject: [PATCH 1/2] fix(web): require org membership for space creator access Space creator access in SpacesPolicy now also requires current membership (or ownership) of the space's live organization, so removing someone from an organization revokes the access they had through spaces they created. --- .github/workflows/infra-database.yml | 8 +- .../space-creator-membership-database.test.ts | 258 ++++++++++++++++++ .../spaces-policy-creator-membership.test.ts | 166 +++++++++++ .../web-backend/src/Spaces/SpacesPolicy.ts | 13 +- packages/web-backend/src/Spaces/SpacesRepo.ts | 35 ++- 5 files changed, 470 insertions(+), 10 deletions(-) create mode 100644 apps/web/__tests__/integration/space-creator-membership-database.test.ts create mode 100644 apps/web/__tests__/unit/spaces-policy-creator-membership.test.ts diff --git a/.github/workflows/infra-database.yml b/.github/workflows/infra-database.yml index c94546baa8c..2dca7ebbbfb 100644 --- a/.github/workflows/infra-database.yml +++ b/.github/workflows/infra-database.yml @@ -13,6 +13,9 @@ on: - "apps/web/app/api/cron/developer-storage/**" - "apps/web/lib/user-preferences-sql.ts" - "apps/web/lib/media-input-policy-strikes.ts" + - "apps/web/lib/organization-member-removal.ts" + - "packages/web-backend/src/Spaces/**" + - "packages/web-backend/src/Folders/FoldersPolicy.ts" - "apps/web/actions/notifications/**" - "apps/web/actions/analytics/**" - "packages/database/schema.ts" @@ -30,6 +33,9 @@ on: - "apps/web/app/api/cron/developer-storage/**" - "apps/web/lib/user-preferences-sql.ts" - "apps/web/lib/media-input-policy-strikes.ts" + - "apps/web/lib/organization-member-removal.ts" + - "packages/web-backend/src/Spaces/**" + - "packages/web-backend/src/Folders/FoldersPolicy.ts" - "apps/web/actions/notifications/**" - "apps/web/actions/analytics/**" - "packages/database/schema.ts" @@ -84,4 +90,4 @@ jobs: env: CAP_INFRA_TEST_DATABASE_URL: mysql://root@127.0.0.1:3306/cap_infra_tests CAP_INFRA_ROUND_TRIPS_DATABASE_URL: mysql://root@127.0.0.1:3306/cap_infra_tests - run: bun run vitest run __tests__/integration/infra-*-database.test.ts __tests__/integration/user-preferences-database.test.ts + run: bun run vitest run __tests__/integration/infra-*-database.test.ts __tests__/integration/user-preferences-database.test.ts __tests__/integration/space-creator-membership-database.test.ts diff --git a/apps/web/__tests__/integration/space-creator-membership-database.test.ts b/apps/web/__tests__/integration/space-creator-membership-database.test.ts new file mode 100644 index 00000000000..c7cc9cccad2 --- /dev/null +++ b/apps/web/__tests__/integration/space-creator-membership-database.test.ts @@ -0,0 +1,258 @@ +import { randomUUID } from "node:crypto"; +import * as Db from "@cap/database/schema"; +import { + CurrentUser, + type Organisation, + type Space, + type User, +} from "@cap/web-domain"; +import { eq } from "drizzle-orm"; +import { drizzle, type MySql2Database } from "drizzle-orm/mysql2"; +import { Cause, Effect, Exit, Option } from "effect"; +import { createPool, type Pool } from "mysql2/promise"; +import { afterAll, beforeAll, describe, expect, it, vi } from "vitest"; +import { deleteOrganizationMembership } from "@/lib/organization-member-removal"; +import { FoldersPolicy } from "../../../../packages/web-backend/src/Folders/FoldersPolicy"; +import { Spaces } from "../../../../packages/web-backend/src/Spaces"; + +// Space access through the real Spaces and Folders policies against a real +// migrated MySQL database, covering creators who leave the organization. + +const fixture = vi.hoisted(() => ({ database: undefined as unknown })); + +vi.mock("server-only", () => ({})); +vi.mock("@cap/database", async (importOriginal) => ({ + ...(await importOriginal()), + db: () => { + if (!fixture.database) throw new Error("Test database is not connected."); + return fixture.database; + }, +})); + +const databaseUrl = process.env.CAP_INFRA_TEST_DATABASE_URL; +const id = () => randomUUID().replaceAll("-", "").slice(0, 15); +const database = () => fixture.database as MySql2Database; + +type Org = { orgId: Organisation.OrganisationId; ownerId: User.UserId }; + +const createOrganization = async (options?: { tombstoned?: boolean }) => { + const orgId = id() as Organisation.OrganisationId; + const ownerId = id() as User.UserId; + await database() + .insert(Db.organizations) + .values({ + id: orgId, + name: "Acme", + ownerId, + tombstoneAt: options?.tombstoned ? new Date() : null, + }); + return { orgId, ownerId } satisfies Org; +}; + +const addOrganizationMember = async ( + org: Org, + role: "admin" | "member", + userId = id() as User.UserId, +) => { + const memberId = id(); + await database().insert(Db.organizationMembers).values({ + id: memberId, + organizationId: org.orgId, + userId, + role, + }); + return { memberId, userId }; +}; + +const createSpace = async ( + org: Org, + createdById: User.UserId, + members: Array<{ userId: User.UserId; role: "admin" | "member" }> = [], +) => { + const spaceId = id() as Space.SpaceIdOrOrganisationId; + await database().insert(Db.spaces).values({ + id: spaceId, + name: "Launch", + organizationId: org.orgId, + createdById, + }); + if (members.length > 0) { + await database() + .insert(Db.spaceMembers) + .values( + members.map((member) => ({ + id: id(), + spaceId, + userId: member.userId, + role: member.role, + })), + ); + } + return spaceId; +}; + +const asUser = ( + userId: User.UserId, + effect: Effect.Effect, +) => + effect.pipe( + Effect.provide(Spaces.Default), + Effect.provide(FoldersPolicy.Default), + Effect.provideService(CurrentUser, { + id: userId, + email: `${userId}@example.com`, + activeOrganizationId: id() as Organisation.OrganisationId, + iconUrlOrKey: Option.none(), + }), + Effect.runPromiseExit, + ); + +const openSpace = ( + userId: User.UserId, + spaceId: Space.SpaceIdOrOrganisationId, +) => + asUser( + userId, + Effect.flatMap(Spaces, (spaces) => spaces.getSpaceOrOrg(spaceId)), + ); + +const createFolderIn = ( + userId: User.UserId, + spaceId: Space.SpaceIdOrOrganisationId, +) => + asUser( + userId, + Effect.flatMap(FoldersPolicy, (policy) => policy.canCreateIn(spaceId)), + ); + +const opened = (exit: Exit.Exit, spaceId: string) => + Exit.isSuccess(exit) && + (exit.value as { variant: string; space?: { id: string } }).variant === + "space" && + (exit.value as { space: { id: string } }).space.id === spaceId; + +const denied = (exit: Exit.Exit) => + Exit.isFailure(exit) && + Option.exists( + Cause.failureOption(exit.cause), + (error) => (error as { _tag?: string })._tag === "PolicyDenied", + ); + +describe.runIf(Boolean(databaseUrl))( + "space creator access against a real database", + () => { + let pool: Pool; + + beforeAll(async () => { + if (!databaseUrl) throw new Error("Missing isolated test database URL."); + const url = new URL(databaseUrl); + if ( + url.protocol !== "mysql:" || + !["127.0.0.1", "localhost", "[::1]"].includes(url.hostname) || + !/^\/cap_infra_[a-z0-9_]+$/.test(url.pathname) + ) + throw new Error("These tests require a session-scoped local database."); + pool = createPool({ uri: databaseUrl, connectionLimit: 4 }); + fixture.database = drizzle(pool); + }); + + afterAll(async () => { + await pool?.end(); + }); + + it("keeps access for a creator who is still a member", async () => { + const org = await createOrganization(); + const creator = await addOrganizationMember(org, "member"); + const spaceId = await createSpace(org, creator.userId); + + expect(opened(await openSpace(creator.userId, spaceId), spaceId)).toBe( + true, + ); + expect( + Exit.isSuccess(await createFolderIn(creator.userId, spaceId)), + ).toBe(true); + }); + + it("revokes access once the creator is removed from the organization", async () => { + const org = await createOrganization(); + const creator = await addOrganizationMember(org, "member"); + const spaceId = await createSpace(org, creator.userId, [ + { userId: creator.userId, role: "admin" }, + ]); + + expect(opened(await openSpace(creator.userId, spaceId), spaceId)).toBe( + true, + ); + + await database().transaction((tx) => + deleteOrganizationMembership(tx, org.orgId, { + id: creator.memberId, + userId: creator.userId, + hasProSeat: false, + email: `${creator.userId}@example.com`, + }), + ); + + const [space] = await database() + .select({ createdById: Db.spaces.createdById }) + .from(Db.spaces) + .where(eq(Db.spaces.id, spaceId)); + expect(space?.createdById).toBe(creator.userId); + expect(denied(await openSpace(creator.userId, spaceId))).toBe(true); + expect(denied(await createFolderIn(creator.userId, spaceId))).toBe(true); + }); + + it("denies a creator with no membership row at all", async () => { + const org = await createOrganization(); + const formerMember = id() as User.UserId; + const spaceId = await createSpace(org, formerMember); + + expect(denied(await openSpace(formerMember, spaceId))).toBe(true); + expect(denied(await createFolderIn(formerMember, spaceId))).toBe(true); + }); + + it("keeps access for the organization owner who created the space", async () => { + const org = await createOrganization(); + const spaceId = await createSpace(org, org.ownerId); + + expect(opened(await openSpace(org.ownerId, spaceId), spaceId)).toBe(true); + expect(Exit.isSuccess(await createFolderIn(org.ownerId, spaceId))).toBe( + true, + ); + }); + + it("keeps access for organization admins and space members", async () => { + const org = await createOrganization(); + const creator = await addOrganizationMember(org, "member"); + const admin = await addOrganizationMember(org, "admin"); + const spaceMember = await addOrganizationMember(org, "member"); + const outsider = await addOrganizationMember(org, "member"); + const spaceId = await createSpace(org, creator.userId, [ + { userId: creator.userId, role: "admin" }, + { userId: spaceMember.userId, role: "member" }, + ]); + + expect(opened(await openSpace(admin.userId, spaceId), spaceId)).toBe( + true, + ); + expect(Exit.isSuccess(await createFolderIn(admin.userId, spaceId))).toBe( + true, + ); + expect( + opened(await openSpace(spaceMember.userId, spaceId), spaceId), + ).toBe(true); + expect(denied(await createFolderIn(spaceMember.userId, spaceId))).toBe( + true, + ); + expect(denied(await openSpace(outsider.userId, spaceId))).toBe(true); + }); + + it("does not grant creator access inside a deleted organization", async () => { + const org = await createOrganization({ tombstoned: true }); + const creator = await addOrganizationMember(org, "member"); + const spaceId = await createSpace(org, creator.userId); + + expect(denied(await openSpace(creator.userId, spaceId))).toBe(true); + }); + }, +); diff --git a/apps/web/__tests__/unit/spaces-policy-creator-membership.test.ts b/apps/web/__tests__/unit/spaces-policy-creator-membership.test.ts new file mode 100644 index 00000000000..7ba5c178c30 --- /dev/null +++ b/apps/web/__tests__/unit/spaces-policy-creator-membership.test.ts @@ -0,0 +1,166 @@ +import { + CurrentUser, + Organisation, + Policy, + Space, + User, +} from "@cap/web-domain"; +import { drizzle } from "drizzle-orm/mysql-proxy"; +import { Cause, Effect, Exit, Layer, Option } from "effect"; +import { beforeEach, describe, expect, it, vi } from "vitest"; +import { + Database as BackendDatabase, + type DbClient, +} from "../../../../packages/web-backend/src/Database"; +import { SpacesPolicy } from "../../../../packages/web-backend/src/Spaces/SpacesPolicy"; +import { SpacesRepo } from "../../../../packages/web-backend/src/Spaces/SpacesRepo"; + +vi.mock("server-only", () => ({})); +vi.mock("@cap/database", () => ({ + db: () => { + throw new Error("Use the injected test database."); + }, +})); + +const SPACE_ID = Space.SpaceId.make("space-1") as Space.SpaceIdOrOrganisationId; +const USER_ID = User.UserId.make("user-1"); + +type Fixture = { + creatorWithOrganizationAccess: boolean; + spaceRole: "admin" | "member" | null; +}; + +const calls: Array<{ userId: string; spaceId: string }> = []; + +const fakeRepo = (fixture: Fixture) => + SpacesRepo.make({ + creatorWithOrganizationAccess: (userId: string, spaceId: string) => { + calls.push({ userId, spaceId }); + return Effect.succeed( + fixture.creatorWithOrganizationAccess + ? Option.some({ id: spaceId }) + : Option.none(), + ); + }, + membership: () => + Effect.succeed( + fixture.spaceRole + ? Option.some({ membershipId: "m-1", role: fixture.spaceRole }) + : Option.none(), + ), + } as unknown as Parameters[0]); + +const run = ( + fixture: Fixture, + check: (policy: SpacesPolicy) => Effect.Effect, +) => + Effect.flatMap(SpacesPolicy, check).pipe( + Effect.provide(SpacesPolicy.DefaultWithoutDependencies), + Effect.provide(Layer.succeed(SpacesRepo, fakeRepo(fixture))), + Effect.provideService(CurrentUser, { + id: USER_ID, + email: "user@example.com", + activeOrganizationId: Organisation.OrganisationId.make("org-1"), + iconUrlOrKey: Option.none(), + }), + Effect.runPromiseExit, + ); + +const denied = (exit: Exit.Exit) => + Exit.isFailure(exit) && + Option.exists( + Cause.failureOption(exit.cause), + (error) => error instanceof Policy.PolicyDeniedError, + ); + +describe("SpacesPolicy creator access", () => { + beforeEach(() => { + calls.length = 0; + }); + + it("denies a creator who no longer belongs to the organization", async () => { + const fixture: Fixture = { + creatorWithOrganizationAccess: false, + spaceRole: null, + }; + + expect(denied(await run(fixture, (p) => p.isOwner(SPACE_ID)))).toBe(true); + expect(denied(await run(fixture, (p) => p.isMember(SPACE_ID)))).toBe(true); + expect(denied(await run(fixture, (p) => p.isAdmin(SPACE_ID)))).toBe(true); + expect(calls).toContainEqual({ userId: USER_ID, spaceId: SPACE_ID }); + }); + + it("keeps owner, member and admin access for a creator still in the organization", async () => { + const fixture: Fixture = { + creatorWithOrganizationAccess: true, + spaceRole: null, + }; + + expect(Exit.isSuccess(await run(fixture, (p) => p.isOwner(SPACE_ID)))).toBe( + true, + ); + expect( + Exit.isSuccess(await run(fixture, (p) => p.isMember(SPACE_ID))), + ).toBe(true); + expect(Exit.isSuccess(await run(fixture, (p) => p.isAdmin(SPACE_ID)))).toBe( + true, + ); + }); + + it("keeps space membership access unchanged for non-creators", async () => { + const member: Fixture = { + creatorWithOrganizationAccess: false, + spaceRole: "member", + }; + const admin: Fixture = { + creatorWithOrganizationAccess: false, + spaceRole: "admin", + }; + + expect(Exit.isSuccess(await run(member, (p) => p.isMember(SPACE_ID)))).toBe( + true, + ); + expect(denied(await run(member, (p) => p.isAdmin(SPACE_ID)))).toBe(true); + expect(Exit.isSuccess(await run(admin, (p) => p.isAdmin(SPACE_ID)))).toBe( + true, + ); + }); +}); + +describe("SpacesRepo.creatorWithOrganizationAccess", () => { + it("matches only the creator of a live organization they still belong to", async () => { + const statements: Array<{ sql: string; params: unknown[] }> = []; + const client = drizzle(async (sql, params) => { + statements.push({ sql, params }); + return { rows: [] }; + }) as unknown as DbClient; + + const result = await Effect.flatMap(SpacesRepo, (repo) => + repo.creatorWithOrganizationAccess(USER_ID, SPACE_ID), + ).pipe( + Effect.provide(SpacesRepo.DefaultWithoutDependencies), + Effect.provideService( + BackendDatabase, + BackendDatabase.make({ + use: (callback) => Effect.promise(() => callback(client)), + }), + ), + Effect.runPromise, + ); + + expect(Option.isNone(result)).toBe(true); + expect(statements).toHaveLength(1); + const sql = statements[0]?.sql ?? ""; + const params = statements[0]?.params; + expect(sql).toContain("inner join `organizations`"); + expect(sql).toContain( + "left join `organization_members` on (`organization_members`.`organizationId` = `spaces`.`organizationId` and `organization_members`.`userId` = ?)", + ); + expect(sql).toContain("`spaces`.`createdById` = ?"); + expect(sql).toContain("`organizations`.`tombstoneAt` is null"); + expect(sql).toContain( + "(`organizations`.`ownerId` = ? or `organization_members`.`id` is not null)", + ); + expect(params).toEqual([USER_ID, SPACE_ID, USER_ID, USER_ID, 1]); + }); +}); diff --git a/packages/web-backend/src/Spaces/SpacesPolicy.ts b/packages/web-backend/src/Spaces/SpacesPolicy.ts index 4be58240da8..4c5db7802b5 100644 --- a/packages/web-backend/src/Spaces/SpacesPolicy.ts +++ b/packages/web-backend/src/Spaces/SpacesPolicy.ts @@ -16,14 +16,13 @@ export class SpacesPolicy extends Effect.Service()( repo.membership(user.id, spaceId).pipe(Effect.map(Option.isSome)), ); + // spaces.createdById survives the creator's removal from the + // organization, so creator access also needs current membership. const isOwner = (spaceId: Space.SpaceIdOrOrganisationId) => - Policy.policy( - Effect.fn(function* (user) { - const space = yield* repo.getById(spaceId); - if (Option.isNone(space)) return false; - - return space.value.createdById === user.id; - }), + Policy.policy((user) => + repo + .creatorWithOrganizationAccess(user.id, spaceId) + .pipe(Effect.map(Option.isSome)), ); const isMember = (spaceId: Space.SpaceIdOrOrganisationId) => diff --git a/packages/web-backend/src/Spaces/SpacesRepo.ts b/packages/web-backend/src/Spaces/SpacesRepo.ts index 6db9386211b..c8811ea5262 100644 --- a/packages/web-backend/src/Spaces/SpacesRepo.ts +++ b/packages/web-backend/src/Spaces/SpacesRepo.ts @@ -96,10 +96,41 @@ export class SpacesRepo extends Effect.Service()("SpacesRepo", { ) .pipe(Effect.map(Array.get(0))), - getById: (spaceId: Space.SpaceIdOrOrganisationId) => + creatorWithOrganizationAccess: ( + userId: User.UserId, + spaceId: Space.SpaceIdOrOrganisationId, + ) => db .use((db) => - db.select().from(Db.spaces).where(Dz.eq(Db.spaces.id, spaceId)), + db + .select({ id: Db.spaces.id }) + .from(Db.spaces) + .innerJoin( + Db.organizations, + Dz.eq(Db.organizations.id, Db.spaces.organizationId), + ) + .leftJoin( + Db.organizationMembers, + Dz.and( + Dz.eq( + Db.organizationMembers.organizationId, + Db.spaces.organizationId, + ), + Dz.eq(Db.organizationMembers.userId, userId), + ), + ) + .where( + Dz.and( + Dz.eq(Db.spaces.id, spaceId), + Dz.eq(Db.spaces.createdById, userId), + Dz.isNull(Db.organizations.tombstoneAt), + Dz.or( + Dz.eq(Db.organizations.ownerId, userId), + Dz.isNotNull(Db.organizationMembers.id), + ), + ), + ) + .limit(1), ) .pipe(Effect.map(Array.get(0))), }; From 60be456e6ed5f42b5aa49ddf619351d2caaa7ea9 Mon Sep 17 00:00:00 2001 From: Richie McIlroy <33632126+richiemcilroy@users.noreply.github.com> Date: Tue, 17 Nov 2026 01:50:48 +0000 Subject: [PATCH 2/2] test(web): drop narrating comment in space creator suite --- .../integration/space-creator-membership-database.test.ts | 3 --- 1 file changed, 3 deletions(-) diff --git a/apps/web/__tests__/integration/space-creator-membership-database.test.ts b/apps/web/__tests__/integration/space-creator-membership-database.test.ts index c7cc9cccad2..2c3baf6f427 100644 --- a/apps/web/__tests__/integration/space-creator-membership-database.test.ts +++ b/apps/web/__tests__/integration/space-creator-membership-database.test.ts @@ -15,9 +15,6 @@ import { deleteOrganizationMembership } from "@/lib/organization-member-removal" import { FoldersPolicy } from "../../../../packages/web-backend/src/Folders/FoldersPolicy"; import { Spaces } from "../../../../packages/web-backend/src/Spaces"; -// Space access through the real Spaces and Folders policies against a real -// migrated MySQL database, covering creators who leave the organization. - const fixture = vi.hoisted(() => ({ database: undefined as unknown })); vi.mock("server-only", () => ({}));