Skip to content

Rallly is an open-source scheduling and collaboration tool designed to make organizing events and meetings easier.

🔒️ 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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);
+ });
+});