Rallly is an open-source scheduling and collaboration tool designed to make organizing events and meetings easier.
TypeScript i18nextnext-authnextjspostgresqlprismareact-emailt3-stacktailwindcsstrpcturborepotypescriptzod
🔒️ Require space membership to manage or be notified about a space's polls (#3382)
Luke Vella191c51c66fb1
diff --git a/apps/web/src/features/notifications/data.ts b/apps/web/src/features/notifications/data.tsindex 01888aa0a..c0e8a9ef8 100644--- a/apps/web/src/features/notifications/data.ts+++ b/apps/web/src/features/notifications/data.ts@@ -1,6 +1,7 @@import "server-only";import { prisma } from "@rallly/database";+import { effectiveSpaceMemberWhere } from "@/features/space/member/utils";import { defaultNotificationPreferences } from "./constants";import type { ActivityEventType, NotificationPreferences } from "./schema";@@ -47,7 +48,7 @@ export async function getNotificationRecipient({}): Promise<NotificationRecipient | null> {const poll = await prisma.poll.findUnique({where: { id: pollId },- select: { userId: true, muted: true, deleted: true },+ select: { userId: true, spaceId: true, muted: true, deleted: true },});if (@@ -60,7 +61,21 @@ export async function getNotificationRecipient({}const creator = await prisma.user.findUnique({- where: { id: poll.userId, isAnonymous: false },+ where: {+ id: poll.userId,+ isAnonymous: false,+ // A poll in a space notifies its creator only while they remain an+ // effective member of it. Once they have left, the poll is the+ // space's and its responses are none of their business.+ ...(poll.spaceId && {+ memberOf: {+ some: {+ spaceId: poll.spaceId,+ ...effectiveSpaceMemberWhere({ userId: poll.userId }),+ },+ },+ }),+ },select: {id: true,email: true,diff --git a/apps/web/src/features/poll/data.ts b/apps/web/src/features/poll/data.tsindex 1ce63b7e7..c0175d2a7 100644--- a/apps/web/src/features/poll/data.ts+++ b/apps/web/src/features/poll/data.ts@@ -478,52 +478,64 @@ export async function canUserManagePoll(return false;}- if (poll.userId && poll.userId === user.id) {- // user is owner- return true;+ const isCreator = Boolean(poll.userId) && poll.userId === user.id;++ if (!poll.spaceId) {+ // A poll outside any space (legacy, guest) is its creator's.+ return isCreator;}- if (poll.spaceId) {- const membership = await prisma.spaceMember.findFirst({- where: {- spaceId: poll.spaceId,- ...effectiveSpaceMemberWhere({ userId: user.id }),- },- select: {- space: { select: { shared: true } },- },- });+ // A poll in a space is the space's: only effective members manage it. The+ // creator is no exception, so they lose it with their membership, whether+ // removed or locked out by a downgrade.+ const membership = await prisma.spaceMember.findFirst({+ where: {+ spaceId: poll.spaceId,+ ...effectiveSpaceMemberWhere({ userId: user.id }),+ },+ select: {+ space: { select: { shared: true } },+ },+ });- const { spacesAlwaysShared } = await getInstancePolicy();+ if (!membership) {+ return false;+ }- if (membership && (spacesAlwaysShared || membership.space.shared)) {- // Members manage each other's polls only in a shared space. Uniform- // across roles: admins are members here too.- return true;- }+ if (isCreator) {+ return true;}- return false;+ // Members manage each other's polls only in a shared space. Uniform+ // across roles: admins are members here too.+ const { spacesAlwaysShared } = await getInstancePolicy();++ return spacesAlwaysShared || membership.space.shared;}export const hasPollAdminAccess = async (pollId: string, userId: string) => {const { spacesAlwaysShared } = await getInstancePolicy();+ // Same rule as canUserManagePoll, expressed as a query.const poll = await prisma.poll.findFirst({where: {id: pollId,deleted: false,OR: [- { userId: userId },- // Members reach each other's polls only in a shared space. Uniform- // across roles: admins are members here too.+ // A poll outside any space (legacy, guest) is its creator's.+ { spaceId: null, userId },+ // A poll in a space is the space's: only effective members manage+ // it, the creator included. Members reach each other's polls only+ // in a shared space. Uniform across roles: admins are members here+ // too.{- space: {+ space: { members: { some: effectiveSpaceMemberWhere({ userId }) } },+ OR: [+ { userId },// The row is not coerced the way the DTO is, so the policy has// to override it here- ...(spacesAlwaysShared ? {} : { shared: true }),- members: { some: effectiveSpaceMemberWhere({ userId }) },- },+ { space: spacesAlwaysShared ? {} : { shared: true } },+ ],},],},diff --git a/apps/web/tests/poll-access-after-removal.spec.ts b/apps/web/tests/poll-access-after-removal.spec.tsnew file mode 100644index 000000000..afa17924c--- /dev/null+++ b/apps/web/tests/poll-access-after-removal.spec.ts@@ -0,0 +1,290 @@+import type { Browser, Page } from "@playwright/test";+import { expect, test } from "@playwright/test";+import { prisma } from "@rallly/database";+import {+ captureOne,+ deleteAllMessages,+ getMessages,+} from "@rallly/test-helpers";+import dayjs from "dayjs";+import { InvitePage } from "./invite-page";+import {+ createUserInDb,+ loginWithEmail,+ upgradeSpaceToPro,+} from "./test-utils";++// A poll that belongs to a space is the space's: its creator manages it for+// as long as they are an effective member and not a day longer. These tests+// pin that rule at the two places it is enforced (the admin page loader and+// the tRPC/action gate) and at the notification recipient, which must fall+// silent for a creator who has left.++const runId = Date.now().toString(36);+const createdUserIds: string[] = [];+let pollCounter = 0;++function emailFor(name: string) {+ return `${name.toLowerCase().replace(/\s/g, "-")}-${runId}@example.com`;+}++async function createOwner({+ name,+ shared,+}: {+ name: string;+ shared: boolean;+}) {+ const email = emailFor(name);+ const user = await createUserInDb({ email, name });+ createdUserIds.push(user.id);++ const space = await prisma.space.findFirstOrThrow({+ where: { ownerId: user.id },+ });+ await upgradeSpaceToPro({ spaceId: space.id, userId: user.id, seats: 3 });+ await prisma.space.update({ where: { id: space.id }, data: { shared } });++ return { user, space, email };+}++async function createMember({+ spaceId,+ name,+}: {+ spaceId: string;+ name: string;+}) {+ const email = emailFor(name);+ const user = await createUserInDb({ email, name });+ createdUserIds.push(user.id);++ await prisma.spaceMember.create({+ data: { spaceId, userId: user.id, role: "MEMBER" },+ });++ return { user, email };+}++async function createPoll({+ userId,+ spaceId,+}: {+ userId: string;+ spaceId: string | null;+}) {+ pollCounter += 1;+ return prisma.poll.create({+ data: {+ id: `removal-${runId}-${pollCounter}`,+ title: `Team poll ${pollCounter}`,+ userId,+ spaceId,+ kind: "time",+ options: {+ create: [1, 2, 3].map((day) => ({+ startTime: dayjs().add(day, "day").startOf("hour").toDate(),+ duration: 60,+ })),+ },+ },+ });+}++async function removeMember({+ spaceId,+ userId,+}: {+ spaceId: string;+ userId: string;+}) {+ await prisma.spaceMember.deleteMany({ where: { spaceId, userId } });+}++async function loginAs(browser: Browser, email: string) {+ const page = await (await browser.newContext()).newPage();+ await loginWithEmail(page, { email });+ return page;+}++async function expectAdminPage(page: Page, pollId: string) {+ await page.goto(`/poll/${pollId}`);+ await expect(page).toHaveURL(new RegExp(`/poll/${pollId}$`));+ await expect(page.getByRole("button", { name: "Manage" })).toBeVisible();+}++async function expectInvitePage(page: Page, pollId: string) {+ await page.goto(`/poll/${pollId}`);+ await expect(page).toHaveURL(new RegExp(`/invite/${pollId}$`));+}++// The tRPC gate, exercised without the UI the loader already hides. The+// body shape is the superjson transformer's.+async function closePollViaTrpc(page: Page, pollId: string) {+ return page.request.post("/api/trpc/polls.close", {+ data: { json: { pollId } },+ });+}++async function respondAsGuest(browser: Browser, pollId: string, name: string) {+ const page = await (await browser.newContext()).newPage();+ await page.goto(`/invite/${pollId}`);+ await new InvitePage(page).addParticipant(name);+ await page.context().close();+}++function messagesTo(email: string) {+ return getMessages().then(({ messages }) =>+ messages.filter((message) =>+ message.To.some((recipient) => recipient.Address === email),+ ),+ );+}++test.afterAll(async () => {+ if (createdUserIds.length > 0) {+ await prisma.user.deleteMany({ where: { id: { in: createdUserIds } } });+ createdUserIds.length = 0;+ }+});++test.describe("Poll access after a member is removed", () => {+ test("the removed creator lands on the invite page and cannot close the poll", async ({+ browser,+ }) => {+ const owner = await createOwner({ name: "Shared Owner", shared: true });+ const member = await createMember({+ spaceId: owner.space.id,+ name: "Departing Member",+ });+ const poll = await createPoll({+ userId: member.user.id,+ spaceId: owner.space.id,+ });+ await removeMember({ spaceId: owner.space.id, userId: member.user.id });++ const page = await loginAs(browser, member.email);+ await expectInvitePage(page, poll.id);++ const response = await closePollViaTrpc(page, poll.id);+ expect(response.status()).toBe(403);+ const after = await prisma.poll.findUniqueOrThrow({+ where: { id: poll.id },+ select: { status: true },+ });+ expect(after.status).toBe("open");+ });++ test("a remaining member of a shared space keeps managing the poll", async ({+ browser,+ }) => {+ const owner = await createOwner({ name: "Staying Owner", shared: true });+ const member = await createMember({+ spaceId: owner.space.id,+ name: "Former Colleague",+ });+ const poll = await createPoll({+ userId: member.user.id,+ spaceId: owner.space.id,+ });+ await removeMember({ spaceId: owner.space.id, userId: member.user.id });++ const page = await loginAs(browser, owner.email);+ await expectAdminPage(page, poll.id);+ });++ test("in an independent space the removed creator loses access and the owner does not gain it", async ({+ browser,+ }) => {+ test.setTimeout(90_000);++ const owner = await createOwner({+ name: "Independent Owner",+ shared: false,+ });+ const member = await createMember({+ spaceId: owner.space.id,+ name: "Independent Member",+ });+ const poll = await createPoll({+ userId: member.user.id,+ spaceId: owner.space.id,+ });+ await removeMember({ spaceId: owner.space.id, userId: member.user.id });++ const memberPage = await loginAs(browser, member.email);+ await expectInvitePage(memberPage, poll.id);++ const ownerPage = await loginAs(browser, owner.email);+ await expectInvitePage(ownerPage, poll.id);+ });++ test("a poll outside any space stays with its creator", async ({+ browser,+ }) => {+ const owner = await createOwner({ name: "Spaceless Owner", shared: true });+ const member = await createMember({+ spaceId: owner.space.id,+ name: "Spaceless Member",+ });+ const poll = await createPoll({ userId: member.user.id, spaceId: null });+ await removeMember({ spaceId: owner.space.id, userId: member.user.id });++ const page = await loginAs(browser, member.email);+ await expectAdminPage(page, poll.id);+ });++ test("a member left behind by a downgrade cannot manage the space's polls", async ({+ browser,+ }) => {+ const owner = await createOwner({ name: "Lapsed Owner", shared: true });+ const member = await createMember({+ spaceId: owner.space.id,+ name: "Lapsed Member",+ });+ const poll = await createPoll({+ userId: member.user.id,+ spaceId: owner.space.id,+ });+ // syncSpaceTier leaves membership rows in place when Pro lapses; only+ // the tier decides whether they are effective.+ await prisma.space.update({+ where: { id: owner.space.id },+ data: { tier: "hobby" },+ });++ const page = await loginAs(browser, member.email);+ await expectInvitePage(page, poll.id);+ });++ test("the removed creator no longer receives response notifications", async ({+ browser,+ }) => {+ test.setTimeout(90_000);++ const owner = await createOwner({ name: "Notified Owner", shared: true });+ const member = await createMember({+ spaceId: owner.space.id,+ name: "Notified Member",+ });+ const poll = await createPoll({+ userId: member.user.id,+ spaceId: owner.space.id,+ });++ // Control: while still a member, a response reaches the creator.+ await deleteAllMessages();+ await respondAsGuest(browser, poll.id, "First Voter");+ const { email } = await captureOne(member.email);+ expect(email.Subject).toContain("First Voter");++ await removeMember({ spaceId: owner.space.id, userId: member.user.id });++ await deleteAllMessages();+ await respondAsGuest(browser, poll.id, "Second Voter");+ // The notification is sent inside the action, so by the time the+ // response is saved a mail would already be in the inbox.+ await new Promise((resolve) => setTimeout(resolve, 2000));+ expect(await messagesTo(member.email)).toHaveLength(0);+ });+});