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..2c3baf6f427 --- /dev/null +++ b/apps/web/__tests__/integration/space-creator-membership-database.test.ts @@ -0,0 +1,255 @@ +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"; + +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))), };