Skip to content

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

♻️ Migrate space member mutations to server actions (#2733)

Luke Vella321ef734c2b2
diff --git a/apps/web/package.json b/apps/web/package.json
index cc1658fb2..5045e345a 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -83,7 +83,7 @@
"motion": "^12.6.2",
"nanoid": "^5.0.9",
"next": "16.2.6",
- "next-safe-action": "^8.0.7",
+ "next-safe-action": "^8.6.0",
"pg": "^8.17.1",
"php-serialize": "^4.1.1",
"postcss": "^8.5.6",
diff --git a/apps/web/public/locales/en/app.json b/apps/web/public/locales/en/app.json
index 7385d1c89..439dacd3f 100644
--- a/apps/web/public/locales/en/app.json
+++ b/apps/web/public/locales/en/app.json
@@ -3,6 +3,8 @@
"24h": "24-hour",
"acceptInvite": "Accept Invite",
"acceptInviteMetadataTitle": "Join {spaceName}",
+ "acceptInviteNotEnoughSeats": "There are not enough seats available to join this space",
+ "acceptInviteNotFound": "This invite is no longer valid",
"acceptInviteSuccess": "Successfully joined the space!",
"acceptInviteTitle": "{inviterName} invited you to join {spaceName}",
"accessDenied": "Access Denied",
@@ -108,7 +110,6 @@
"canceledEventsEmptyStateTitle": "No Canceled Events",
"cancelEvent": "Cancel Event",
"cancelEventConfirmDescription": "Are you sure you want to cancel this event?",
- "cancelingInvite": "Canceling invite...",
"cancelInvite": "Cancel invite",
"cancelInviteConfirmation": "Are you sure you want to cancel the invite for {email}?",
"captchaFailed": "Verification failed. Please try again.",
@@ -118,7 +119,6 @@
"changePassword": "Change Password",
"changePasswordDescription": "Update your password to keep your account secure",
"changeRole": "Change role",
- "changingRole": "Changing role...",
"checkForConflicts": "Toggle which calendars to check for conflicts",
"cityTime": "{city} Time",
"clockPreferences": "Clock Preferences",
@@ -339,7 +339,6 @@
"invalidSessionDescription": "Sign out and log in again to continue.",
"invalidSessionLabel": "Session",
"invalidSessionTitle": "Your session is no longer valid",
- "inviteCanceledError": "Failed to cancel invite",
"inviteCanceledSuccess": "Invite canceled successfully",
"inviteFailed": "Failed to send invitation",
"inviteLink": "Invite Link",
@@ -347,6 +346,7 @@
"inviteMemberDescription": "Invite a new member to your space",
"inviteMemberFormSubmit": "Send invite",
"inviteMembersUpsellDescription": "Invite members to manage polls and events together in this space.",
+ "inviteNotEnoughSeats": "There are not enough seats available to send this invite",
"inviteParticipantLinkInfo": "Anyone with this link will be able to vote on your poll.",
"inviteParticipantsDescription": "Copy and share the invite link to start gathering responses from your participants.",
"invitePending": "An invitation has already been sent to this email address",
@@ -560,8 +560,6 @@
"removeLicenseDescription": "Are you sure you want to remove this license?",
"removeMember": "Remove member",
"removeMemberConfirmation": "Are you sure you want to remove this member?",
- "removeMemberError": "Failed to remove member",
- "removeMemberLoading": "Removing member...",
"removeMemberSuccess": "Member removed successfully",
"removeSeats": "{count, plural, one {Remove # Seat} other {Remove # Seats}}",
"removeTimeSlot": "Remove time slot",
@@ -591,7 +589,6 @@
"richTextLinkVisit": "Open link in new tab",
"richTextNumberedList": "Numbered list",
"role": "Role",
- "roleChangedError": "Failed to change role",
"roleChangedSuccess": "Role changed successfully",
"rolePlaceholder": "Select role...",
"rsvpCardDescription": "To join this event, please register below.",
diff --git a/apps/web/src/app/[locale]/(space)/settings/billing/page.tsx b/apps/web/src/app/[locale]/(space)/settings/billing/page.tsx
index f4ef0292e..ded2222f4 100644
--- a/apps/web/src/app/[locale]/(space)/settings/billing/page.tsx
+++ b/apps/web/src/app/[locale]/(space)/settings/billing/page.tsx
@@ -25,7 +25,7 @@ import {
SettingsPageTitle,
} from "@/components/settings-layout";
import { getSpaceSubscription } from "@/features/billing/data";
-import { getActiveSpace, getSpaceSeatCount } from "@/features/space/data";
+import { getActiveSpace, getSeatUsage } from "@/features/space/data";
import { defineAbilityForMember } from "@/features/space/member/ability";
import { getCurrentUser } from "@/features/user/data";
import { Trans } from "@/i18n/client";
@@ -83,10 +83,10 @@ export default async function BillingSettingsPage({
);
}
- const [subscription, usedSeats, { seats_updated: didUpdateSeats }] =
+ const [subscription, seatUsage, { seats_updated: didUpdateSeats }] =
await Promise.all([
getSpaceSubscription(space.id),
- getSpaceSeatCount(space.id),
+ getSeatUsage(),
searchParams,
]);
@@ -124,7 +124,7 @@ export default async function BillingSettingsPage({
currency={subscription.currency}
interval={subscription.interval}
seats={subscription.quantity}
- usedSeats={usedSeats}
+ usedSeats={seatUsage.used}
status={subscription.status}
cancelAtPeriodEnd={subscription.cancelAtPeriodEnd}
periodEnd={subscription.periodEnd}
diff --git a/apps/web/src/app/[locale]/(space)/settings/members/components/invite-dropdown-menu.tsx b/apps/web/src/app/[locale]/(space)/settings/members/components/invite-dropdown-menu.tsx
index 807980882..efc1c220d 100644
--- a/apps/web/src/app/[locale]/(space)/settings/members/components/invite-dropdown-menu.tsx
+++ b/apps/web/src/app/[locale]/(space)/settings/members/components/invite-dropdown-menu.tsx
@@ -22,8 +22,9 @@ import { Icon } from "@rallly/ui/icon";
import { toast } from "@rallly/ui/sonner";
import { MoreVerticalIcon, XIcon } from "lucide-react";
import { useSpace } from "@/features/space/client";
+import { cancelInviteAction } from "@/features/space/member/actions";
import { Trans, useTranslation } from "@/i18n/client";
-import { trpc } from "@/trpc/client";
+import { useSafeAction } from "@/lib/safe-action/client";
type SpaceMemberInvite = {
id: string;
@@ -34,8 +35,19 @@ type SpaceMemberInvite = {
export function InviteDropdownMenu({ invite }: { invite: SpaceMemberInvite }) {
const space = useSpace();
const cancelInviteDialog = useDialog();
- const cancelInvite = trpc.spaces.cancelInvite.useMutation();
const { t } = useTranslation();
+ const cancelInvite = useSafeAction(cancelInviteAction, {
+ onSuccess: () => {
+ toast.success(
+ t("inviteCanceledSuccess", {
+ defaultValue: "Invite canceled successfully",
+ }),
+ );
+ },
+ onSettled: () => {
+ cancelInviteDialog.dismiss();
+ },
+ });
const canCancelInvite = space
.getMemberAbility()
@@ -87,24 +99,9 @@ export function InviteDropdownMenu({ invite }: { invite: SpaceMemberInvite }) {
<DialogFooter>
<Button
variant="destructive"
+ loading={cancelInvite.isExecuting}
onClick={() => {
- toast.promise(
- cancelInvite.mutateAsync({
- inviteId: invite.id,
- }),
- {
- loading: t("cancelingInvite", {
- defaultValue: "Canceling invite...",
- }),
- success: t("inviteCanceledSuccess", {
- defaultValue: "Invite canceled successfully",
- }),
- error: t("inviteCanceledError", {
- defaultValue: "Failed to cancel invite",
- }),
- },
- );
- cancelInviteDialog.dismiss();
+ cancelInvite.execute({ inviteId: invite.id });
}}
>
<Trans i18nKey="confirm" defaults="Confirm" />
diff --git a/apps/web/src/app/[locale]/(space)/settings/members/components/invite-member-dialog.tsx b/apps/web/src/app/[locale]/(space)/settings/members/components/invite-member-dialog.tsx
index 6372c0e7b..ed23a97d3 100644
--- a/apps/web/src/app/[locale]/(space)/settings/members/components/invite-member-dialog.tsx
+++ b/apps/web/src/app/[locale]/(space)/settings/members/components/invite-member-dialog.tsx
@@ -34,9 +34,10 @@ import { useMemo } from "react";
import { useForm } from "react-hook-form";
import * as z from "zod";
import { SpaceRole } from "@/features/space/components/space-role";
+import { inviteMemberAction } from "@/features/space/member/actions";
import { memberRoleSchema } from "@/features/space/schema";
import { Trans, useTranslation } from "@/i18n/client";
-import { trpc } from "@/trpc/client";
+import { useSafeAction } from "@/lib/safe-action/client";
function useInviteMemberFormSchema() {
const { t } = useTranslation();
@@ -65,8 +66,12 @@ export function InviteMemberForm({ onSuccess }: { onSuccess?: () => void }) {
resolver: zodResolver(formSchema),
});
- const inviteMember = trpc.spaces.inviteMember.useMutation({
- onSuccess: (data) => {
+ const inviteMember = useSafeAction(inviteMemberAction, {
+ onSuccess: ({ data }) => {
+ if (!data) {
+ return;
+ }
+
if (data.ok) {
switch (data.code) {
case "INVITE_SENT":
@@ -88,7 +93,7 @@ export function InviteMemberForm({ onSuccess }: { onSuccess?: () => void }) {
}
onSuccess?.();
} else {
- switch (data.code) {
+ switch (data.reason) {
case "ALREADY_MEMBER":
form.setError("email", {
type: "manual",
@@ -106,6 +111,15 @@ export function InviteMemberForm({ onSuccess }: { onSuccess?: () => void }) {
}),
});
break;
+ case "NOT_ENOUGH_SEATS":
+ form.setError("root", {
+ type: "manual",
+ message: t("inviteNotEnoughSeats", {
+ defaultValue:
+ "There are not enough seats available to send this invite",
+ }),
+ });
+ break;
case "INVITE_FAILED":
form.setError("root", {
type: "manual",
@@ -120,7 +134,7 @@ export function InviteMemberForm({ onSuccess }: { onSuccess?: () => void }) {
});
return (
<Form {...form}>
- <form onSubmit={form.handleSubmit((data) => inviteMember.mutate(data))}>
+ <form onSubmit={form.handleSubmit((data) => inviteMember.execute(data))}>
<fieldset className="space-y-4">
<FormField
control={form.control}
@@ -221,7 +235,7 @@ export function InviteMemberForm({ onSuccess }: { onSuccess?: () => void }) {
<div className="mt-4 flex">
<Button
variant="primary"
- loading={inviteMember.isPending}
+ loading={inviteMember.isExecuting}
type="submit"
>
<Trans i18nKey="inviteMemberFormSubmit" defaults="Send invite" />
diff --git a/apps/web/src/app/[locale]/(space)/settings/members/components/member-dropdown-menu.tsx b/apps/web/src/app/[locale]/(space)/settings/members/components/member-dropdown-menu.tsx
index 8f3540280..a87db2a65 100644
--- a/apps/web/src/app/[locale]/(space)/settings/members/components/member-dropdown-menu.tsx
+++ b/apps/web/src/app/[locale]/(space)/settings/members/components/member-dropdown-menu.tsx
@@ -23,17 +23,40 @@ import { Icon } from "@rallly/ui/icon";
import { toast } from "@rallly/ui/sonner";
import { MoreVerticalIcon, ShieldIcon, UserIcon, XIcon } from "lucide-react";
import { useSpace } from "@/features/space/client";
+import {
+ changeMemberRoleAction,
+ removeMemberAction,
+} from "@/features/space/member/actions";
import type { MemberDTO } from "@/features/space/member/types";
import type { MemberRole } from "@/features/space/schema";
import { Trans, useTranslation } from "@/i18n/client";
-import { trpc } from "@/trpc/client";
+import { useSafeAction } from "@/lib/safe-action/client";
export function MemberDropdownMenu({ member }: { member: MemberDTO }) {
const space = useSpace();
const removeMemberDialog = useDialog();
- const removeMember = trpc.spaces.removeMember.useMutation();
- const changeMemberRole = trpc.spaces.changeMemberRole.useMutation();
const { t } = useTranslation();
+ const removeMember = useSafeAction(removeMemberAction, {
+ onSuccess: () => {
+ toast.success(
+ t("removeMemberSuccess", {
+ defaultValue: "Member removed successfully",
+ }),
+ );
+ },
+ onSettled: () => {
+ removeMemberDialog.dismiss();
+ },
+ });
+ const changeMemberRole = useSafeAction(changeMemberRoleAction, {
+ onSuccess: () => {
+ toast.success(
+ t("roleChangedSuccess", {
+ defaultValue: "Role changed successfully",
+ }),
+ );
+ },
+ });
const canUpdateMember = space
.getMemberAbility()
@@ -44,23 +67,10 @@ export function MemberDropdownMenu({ member }: { member: MemberDTO }) {
.can("delete", subject("SpaceMember", member));
const handleRoleChange = (newRole: MemberRole) => {
- toast.promise(
- changeMemberRole.mutateAsync({
- memberId: member.id,
- role: newRole,
- }),
- {
- loading: t("changingRole", {
- defaultValue: "Changing role...",
- }),
- success: t("roleChangedSuccess", {
- defaultValue: "Role changed successfully",
- }),
- error: t("roleChangedError", {
- defaultValue: "Failed to change role",
- }),
- },
- );
+ changeMemberRole.execute({
+ memberId: member.id,
+ role: newRole,
+ });
};
return (
@@ -130,24 +140,9 @@ export function MemberDropdownMenu({ member }: { member: MemberDTO }) {
<DialogFooter>
<Button
variant="destructive"
+ loading={removeMember.isExecuting}
onClick={() => {
- toast.promise(
- removeMember.mutateAsync({
- memberId: member.id,
- }),
- {
- loading: t("removeMemberLoading", {
- defaultValue: "Removing member...",
- }),
- success: t("removeMemberSuccess", {
- defaultValue: "Member removed successfully",
- }),
- error: t("removeMemberError", {
- defaultValue: "Failed to remove member",
- }),
- },
- );
- removeMemberDialog.dismiss();
+ removeMember.execute({ memberId: member.id });
}}
>
<Trans i18nKey="confirm" defaults="Confirm" />
diff --git a/apps/web/src/app/[locale]/(space)/settings/members/page.tsx b/apps/web/src/app/[locale]/(space)/settings/members/page.tsx
index 5d1d51b1c..38c2f1350 100644
--- a/apps/web/src/app/[locale]/(space)/settings/members/page.tsx
+++ b/apps/web/src/app/[locale]/(space)/settings/members/page.tsx
@@ -1,20 +1,17 @@
import { dehydrate, HydrationBoundary } from "@tanstack/react-query";
import type { Metadata } from "next";
-import { getActiveSpace, getSpaceSeatCount } from "@/features/space/data";
-import { getTotalSeatsForSpace } from "@/features/space/utils";
+import { getSeatUsage } from "@/features/space/data";
import { getTranslation } from "@/i18n/server";
import { createPrivateSSRHelper } from "@/trpc/server/create-ssr-helper";
import { MembersSettingsPageClient } from "./page-client";
export default async function MembersSettingsPage() {
- const [space, helpers] = await Promise.all([
- getActiveSpace(),
+ const [seatUsage, helpers] = await Promise.all([
+ getSeatUsage(),
createPrivateSSRHelper(),
]);
- const [totalSeats, usedSeats] = await Promise.all([
- getTotalSeatsForSpace(space.id),
- getSpaceSeatCount(space.id),
+ await Promise.all([
helpers.spaces.listMembers.prefetch(),
helpers.spaces.listInvites.prefetch(),
]);
@@ -22,8 +19,8 @@ export default async function MembersSettingsPage() {
return (
<HydrationBoundary state={dehydrate(helpers.queryClient)}>
<MembersSettingsPageClient
- totalSeats={totalSeats}
- usedSeats={usedSeats}
+ totalSeats={seatUsage.total}
+ usedSeats={seatUsage.used}
/>
</HydrationBoundary>
);
diff --git a/apps/web/src/app/[locale]/accept-invite/[inviteId]/components/accept-invite-button.tsx b/apps/web/src/app/[locale]/accept-invite/[inviteId]/components/accept-invite-button.tsx
index e7570bc26..43ae21371 100644
--- a/apps/web/src/app/[locale]/accept-invite/[inviteId]/components/accept-invite-button.tsx
+++ b/apps/web/src/app/[locale]/accept-invite/[inviteId]/components/accept-invite-button.tsx
@@ -3,29 +3,57 @@
import { Button } from "@rallly/ui/button";
import { toast } from "@rallly/ui/sonner";
import { useRouter } from "next/navigation";
+import { acceptInviteAction } from "@/features/space/member/actions";
import { Trans, useTranslation } from "@/i18n/client";
-import { trpc } from "@/trpc/client";
+import { useSafeAction } from "@/lib/safe-action/client";
export const AcceptInviteButton = ({ spaceId }: { spaceId: string }) => {
const { t } = useTranslation();
const router = useRouter();
- const acceptInvite = trpc.spaces.acceptInvite.useMutation({
- onSuccess: () => {
+ const acceptInvite = useSafeAction(acceptInviteAction);
+
+ // The result is handled from the promise rather than the hook's
+ // onSuccess: accepting deletes the invite, so the action response
+ // re-renders this route as a 404 and unmounts the button before
+ // effect-driven callbacks get a chance to run.
+ const handleClick = async () => {
+ const result = await acceptInvite.executeAsync({ spaceId });
+ const data = result?.data;
+
+ if (data?.ok) {
toast.success(
t("acceptInviteSuccess", {
defaultValue: "Successfully joined the space!",
}),
);
router.push("/");
- },
- });
+ return;
+ }
+
+ switch (data?.reason) {
+ case "INVITE_NOT_FOUND":
+ toast.error(
+ t("acceptInviteNotFound", {
+ defaultValue: "This invite is no longer valid",
+ }),
+ );
+ break;
+ case "NOT_ENOUGH_SEATS":
+ toast.error(
+ t("acceptInviteNotEnoughSeats", {
+ defaultValue:
+ "There are not enough seats available to join this space",
+ }),
+ );
+ break;
+ }
+ };
+
return (
<Button
variant="primary"
- onClick={() => {
- acceptInvite.mutate({ spaceId });
- }}
- loading={acceptInvite.isPending}
+ onClick={handleClick}
+ loading={acceptInvite.isExecuting}
>
<Trans i18nKey="acceptInvite" defaults="Accept Invite" />
</Button>
diff --git a/apps/web/src/features/space/data.ts b/apps/web/src/features/space/data.ts
index c27593f5c..8efb4b4e6 100644
--- a/apps/web/src/features/space/data.ts
+++ b/apps/web/src/features/space/data.ts
@@ -5,19 +5,26 @@ import type {
SpaceTier as DBSpaceTier,
} from "@rallly/database";
import { prisma } from "@rallly/database";
+import { createLogger } from "@rallly/logger";
import { redirect } from "next/navigation";
import { cache } from "react";
+import { getSpaceSubscription } from "@/features/billing/data";
+import { cached_getInstanceLicense } from "@/features/licensing/data";
+import type { LicenseType } from "@/features/licensing/schema";
import type { MemberDTO } from "@/features/space/member/types";
import { effectiveSpaceMemberWhere } from "@/features/space/member/utils";
import type { AuthorizedSpaceId, SpaceDTO } from "@/features/space/types";
import { fromDBRole } from "@/features/space/utils";
import { getSessionState } from "@/lib/auth";
import { isSelfHosted } from "@/lib/constants";
+import { AppError } from "@/lib/errors/app-error";
import { InvalidSessionError } from "@/lib/errors/invalid-session-error";
import { getPathname } from "@/lib/pathname";
import { buildSafeRedirectUrl } from "@/lib/utils/redirect";
+const logger = createLogger("space/data");
+
function createMemberDTO(member: {
id: string;
userId: string;
@@ -52,6 +59,95 @@ export async function getSpaceSeatCount(spaceId: string) {
});
}
+/**
+ * Default seat limit for spaces without active subscriptions
+ */
+const DEFAULT_SEAT_LIMIT = 1;
+const MAX_SEAT_LIMIT = 100;
+
+/**
+ * Returns the seat limit for self-hosted instances based on license type
+ */
+function getSelfHostedSeatLimit(licenseType: LicenseType | null): number {
+ if (!licenseType) {
+ return DEFAULT_SEAT_LIMIT;
+ }
+
+ switch (licenseType) {
+ case "PLUS":
+ return 5;
+ case "ORGANIZATION":
+ return 50;
+ case "ENTERPRISE":
+ return MAX_SEAT_LIMIT;
+ default:
+ return DEFAULT_SEAT_LIMIT;
+ }
+}
+
+/**
+ * Gets the total number of seats available for a space
+ * Handles both cloud-hosted (Stripe subscription) and self-hosted (license-based) deployments
+ */
+export async function getTotalSeatsForSpace(spaceId: string): Promise<number> {
+ try {
+ if (isSelfHosted) {
+ // For self-hosted instances, get seat limit from instance license
+ const license = await cached_getInstanceLicense();
+
+ if (!license) {
+ // No license found, return default limit
+ return DEFAULT_SEAT_LIMIT;
+ }
+
+ // If license has explicit seats defined, use that
+ if (license.seats && license.seats > 0) {
+ return Math.min(license.seats, MAX_SEAT_LIMIT);
+ }
+
+ // Otherwise, use the license type to determine seat limit
+ return getSelfHostedSeatLimit(license.type);
+ } else {
+ // For cloud-hosted instances, get seat count from Stripe subscription
+ const subscription = await getSpaceSubscription(spaceId);
+
+ if (!subscription || !subscription.active) {
+ // Return default limit for spaces without active subscriptions
+ return DEFAULT_SEAT_LIMIT;
+ }
+
+ return subscription.quantity || DEFAULT_SEAT_LIMIT;
+ }
+ } catch (error) {
+ logger.error({ error, spaceId }, "Failed to get total seats for space");
+
+ if (error instanceof AppError) {
+ throw error;
+ }
+
+ throw new AppError({
+ code: "INTERNAL_SERVER_ERROR",
+ message: "Failed to retrieve seat information",
+ cause: error,
+ });
+ }
+}
+
+/**
+ * Seat usage for the signed-in user's active space. Session scoped —
+ * server component/page use only, per getActiveSpace.
+ */
+export const getSeatUsage = cache(async () => {
+ const space = await getActiveSpace();
+
+ const [total, used] = await Promise.all([
+ getTotalSeatsForSpace(space.id),
+ getSpaceSeatCount(space.id),
+ ]);
+
+ return { total, used };
+});
+
export function createSpaceDTO(space: {
id: string;
ownerId: string;
diff --git a/apps/web/src/features/space/member/actions.ts b/apps/web/src/features/space/member/actions.ts
new file mode 100644
index 000000000..11da1e719
--- /dev/null
+++ b/apps/web/src/features/space/member/actions.ts
@@ -0,0 +1,217 @@
+"use server";
+
+import { subject } from "@casl/ability";
+import { defineAbilityForSpace } from "@/features/space/ability";
+import { getActiveSpaceForUser, getMember } from "@/features/space/data";
+import { defineAbilityForMember } from "@/features/space/member/ability";
+import { getInvite } from "@/features/space/member/data";
+import {
+ acceptInvite,
+ cancelInvite,
+ changeMemberRole,
+ inviteMember,
+ removeMember,
+} from "@/features/space/member/mutations";
+import {
+ acceptInviteSchema,
+ cancelInviteSchema,
+ changeMemberRoleSchema,
+ inviteMemberSchema,
+ removeMemberSchema,
+} from "@/features/space/member/schema";
+import { AppError } from "@/lib/errors/app-error";
+import { track } from "@/lib/posthog";
+import { authActionClient } from "@/lib/safe-action/server";
+
+async function requireActiveSpace(user: { id: string }) {
+ const space = await getActiveSpaceForUser(user.id);
+
+ if (!space) {
+ throw new AppError({
+ code: "NOT_FOUND",
+ message: "No active space found",
+ });
+ }
+
+ return space;
+}
+
+export const inviteMemberAction = authActionClient
+ .metadata({ actionName: "invite_member" })
+ .inputSchema(inviteMemberSchema)
+ .action(async ({ ctx, parsedInput }) => {
+ const space = await requireActiveSpace(ctx.user);
+
+ if (defineAbilityForSpace(space).cannot("invite", "Member")) {
+ throw new AppError({
+ code: "PAYMENT_REQUIRED",
+ message: "You need a Pro subscription to invite members to this space",
+ });
+ }
+
+ const ability = defineAbilityForMember({ user: ctx.user, space });
+
+ if (ability.cannot("create", "SpaceMemberInvite")) {
+ throw new AppError({
+ code: "FORBIDDEN",
+ message: "You do not have permission to invite members to this space",
+ });
+ }
+
+ const result = await inviteMember({
+ spaceId: space.id,
+ spaceName: space.name,
+ email: parsedInput.email,
+ role: parsedInput.role,
+ inviter: {
+ id: ctx.user.id,
+ name: ctx.user.name,
+ locale: ctx.user.locale,
+ },
+ });
+
+ if (result.ok && result.code === "INVITE_SENT") {
+ track(ctx.user, {
+ event: "space_member_invite",
+ properties: {
+ role: parsedInput.role,
+ },
+ groups: {
+ space: space.id,
+ },
+ });
+ }
+
+ return result;
+ });
+
+export const acceptInviteAction = authActionClient
+ .metadata({ actionName: "accept_invite" })
+ .inputSchema(acceptInviteSchema)
+ .action(async ({ ctx, parsedInput }) => {
+ // Authorized by the invite row matching the signed-in user's email,
+ // not by space membership — resolved inside the mutation.
+ const result = await acceptInvite({
+ spaceId: parsedInput.spaceId,
+ user: { id: ctx.user.id, email: ctx.user.email },
+ });
+
+ if (result.ok) {
+ track(ctx.user, {
+ event: "space_member_join",
+ properties: {
+ member_count: result.memberCount,
+ },
+ groups: {
+ space: parsedInput.spaceId,
+ },
+ });
+ }
+
+ return result;
+ });
+
+export const cancelInviteAction = authActionClient
+ .metadata({ actionName: "cancel_invite" })
+ .inputSchema(cancelInviteSchema)
+ .action(async ({ ctx, parsedInput }) => {
+ const space = await requireActiveSpace(ctx.user);
+
+ const invite = await getInvite(parsedInput.inviteId);
+
+ if (!invite) {
+ throw new AppError({
+ code: "NOT_FOUND",
+ message: "Invite not found",
+ });
+ }
+
+ if (invite.spaceId !== space.id) {
+ throw new AppError({
+ code: "FORBIDDEN",
+ message: "You do not have access to this invite",
+ });
+ }
+
+ const ability = defineAbilityForMember({ user: ctx.user, space });
+
+ if (ability.cannot("delete", "SpaceMemberInvite")) {
+ throw new AppError({
+ code: "FORBIDDEN",
+ message: "You do not have permission to cancel invites",
+ });
+ }
+
+ await cancelInvite({ inviteId: parsedInput.inviteId });
+ });
+
+export const removeMemberAction = authActionClient
+ .metadata({ actionName: "remove_member" })
+ .inputSchema(removeMemberSchema)
+ .action(async ({ ctx, parsedInput }) => {
+ const space = await requireActiveSpace(ctx.user);
+
+ const member = await getMember(parsedInput.memberId);
+
+ if (!member) {
+ throw new AppError({
+ code: "NOT_FOUND",
+ message: "Member not found",
+ });
+ }
+
+ const ability = defineAbilityForMember({ user: ctx.user, space });
+
+ if (ability.cannot("delete", subject("SpaceMember", member))) {
+ throw new AppError({
+ code: "FORBIDDEN",
+ message: "You do not have permission to remove members from this space",
+ });
+ }
+
+ const { removedUserId, memberCount } = await removeMember({
+ memberId: parsedInput.memberId,
+ });
+
+ track(ctx.user, {
+ event: "space_member_remove",
+ properties: {
+ member_count: memberCount,
+ deleted_member_user_id: removedUserId,
+ },
+ groups: {
+ space: member.spaceId,
+ },
+ });
+ });
+
+export const changeMemberRoleAction = authActionClient
+ .metadata({ actionName: "change_member_role" })
+ .inputSchema(changeMemberRoleSchema)
+ .action(async ({ ctx, parsedInput }) => {
+ const space = await requireActiveSpace(ctx.user);
+
+ const member = await getMember(parsedInput.memberId);
+
+ if (!member) {
+ throw new AppError({
+ code: "NOT_FOUND",
+ message: "Member not found",
+ });
+ }
+
+ const ability = defineAbilityForMember({ user: ctx.user, space });
+
+ if (ability.cannot("update", subject("SpaceMember", member))) {
+ throw new AppError({
+ code: "FORBIDDEN",
+ message:
+ "You do not have permission to change member roles in this space",
+ });
+ }
+
+ await changeMemberRole({
+ memberId: parsedInput.memberId,
+ role: parsedInput.role,
+ });
+ });
diff --git a/apps/web/src/features/space/member/data.ts b/apps/web/src/features/space/member/data.ts
new file mode 100644
index 000000000..1a26ac83a
--- /dev/null
+++ b/apps/web/src/features/space/member/data.ts
@@ -0,0 +1,13 @@
+import "server-only";
+
+import { prisma } from "@rallly/database";
+
+export async function getInvite(inviteId: string) {
+ return prisma.spaceMemberInvite.findUnique({
+ where: { id: inviteId },
+ select: {
+ id: true,
+ spaceId: true,
+ },
+ });
+}
diff --git a/apps/web/src/features/space/member/mutations.ts b/apps/web/src/features/space/member/mutations.ts
new file mode 100644
index 000000000..1ce2727e7
--- /dev/null
+++ b/apps/web/src/features/space/member/mutations.ts
@@ -0,0 +1,183 @@
+import "server-only";
+
+import { prisma } from "@rallly/database";
+import { sendSpaceInviteEmail } from "@rallly/emails/templates/space-invite";
+import { createLogger } from "@rallly/logger";
+import { absoluteUrl } from "@rallly/utils/absolute-url";
+import { getInstanceBranding } from "@/emails/branding";
+import { getTotalSeatsForSpace } from "@/features/space/data";
+import type { MemberRole } from "@/features/space/schema";
+import { toDBRole } from "@/features/space/utils";
+import { setActiveSpace } from "@/features/user/mutations";
+
+const logger = createLogger("space/member/mutations");
+
+export async function inviteMember({
+ spaceId,
+ spaceName,
+ email,
+ role,
+ inviter,
+}: {
+ spaceId: string;
+ spaceName: string;
+ email: string;
+ role: MemberRole;
+ inviter: { id: string; name: string; locale?: string };
+}) {
+ const existingUser = await prisma.user.findUnique({
+ where: { email },
+ include: {
+ memberOf: {
+ where: { spaceId },
+ },
+ },
+ });
+
+ if (existingUser?.memberOf && existingUser.memberOf.length > 0) {
+ return { ok: false as const, reason: "ALREADY_MEMBER" as const };
+ }
+
+ const existingInvite = await prisma.spaceMemberInvite.findUnique({
+ where: {
+ spaceId_email: { spaceId, email },
+ },
+ });
+
+ if (existingInvite) {
+ if (existingInvite.role !== toDBRole(role)) {
+ await prisma.spaceMemberInvite.update({
+ where: { id: existingInvite.id },
+ data: { role: toDBRole(role) },
+ });
+
+ return { ok: true as const, code: "INVITE_UPDATED" as const };
+ }
+
+ return { ok: false as const, reason: "INVITE_PENDING" as const };
+ }
+
+ // Seat availability only gates new invites
+ const [usedSeats, totalSeats] = await Promise.all([
+ prisma.spaceMember.count({ where: { spaceId } }),
+ getTotalSeatsForSpace(spaceId),
+ ]);
+
+ if (usedSeats >= totalSeats) {
+ return { ok: false as const, reason: "NOT_ENOUGH_SEATS" as const };
+ }
+
+ const invite = await prisma.spaceMemberInvite.create({
+ data: {
+ spaceId,
+ email,
+ role: toDBRole(role),
+ inviterId: inviter.id,
+ },
+ });
+
+ try {
+ await sendSpaceInviteEmail({
+ to: email,
+ locale: existingUser?.locale ?? inviter.locale,
+ branding: await getInstanceBranding(),
+ props: {
+ spaceName,
+ inviterName: inviter.name,
+ spaceRole: role,
+ inviteUrl: absoluteUrl(`/accept-invite/${invite.id}`),
+ },
+ });
+ } catch {
+ await prisma.spaceMemberInvite.delete({ where: { id: invite.id } });
+ return { ok: false as const, reason: "INVITE_FAILED" as const };
+ }
+
+ return { ok: true as const, code: "INVITE_SENT" as const };
+}
+
+export async function acceptInvite({
+ spaceId,
+ user,
+}: {
+ spaceId: string;
+ user: { id: string; email: string };
+}) {
+ const invite = await prisma.spaceMemberInvite.findUnique({
+ where: {
+ spaceId_email: { spaceId, email: user.email },
+ },
+ });
+
+ if (!invite) {
+ return { ok: false as const, reason: "INVITE_NOT_FOUND" as const };
+ }
+
+ const result = await prisma.$transaction(async (tx) => {
+ const [usedSeats, totalSeats] = await Promise.all([
+ tx.spaceMember.count({ where: { spaceId } }),
+ getTotalSeatsForSpace(spaceId),
+ ]);
+
+ if (usedSeats >= totalSeats) {
+ return { ok: false as const, reason: "NOT_ENOUGH_SEATS" as const };
+ }
+
+ await tx.spaceMember.create({
+ data: {
+ spaceId,
+ userId: user.id,
+ role: invite.role,
+ },
+ });
+
+ await tx.spaceMemberInvite.delete({
+ where: { id: invite.id },
+ });
+
+ return { ok: true as const, memberCount: usedSeats + 1 };
+ });
+
+ if (!result.ok) {
+ return result;
+ }
+
+ try {
+ await setActiveSpace({ userId: user.id, spaceId });
+ } catch (error) {
+ logger.warn({ error }, "Failed to update user's active space");
+ }
+
+ return result;
+}
+
+export async function cancelInvite({ inviteId }: { inviteId: string }) {
+ await prisma.spaceMemberInvite.delete({
+ where: { id: inviteId },
+ });
+}
+
+export async function removeMember({ memberId }: { memberId: string }) {
+ const removedMember = await prisma.spaceMember.delete({
+ where: { id: memberId },
+ });
+
+ const memberCount = await prisma.spaceMember.count({
+ where: { spaceId: removedMember.spaceId },
+ });
+
+ return { removedUserId: removedMember.userId, memberCount };
+}
+
+export async function changeMemberRole({
+ memberId,
+ role,
+}: {
+ memberId: string;
+ role: MemberRole;
+}) {
+ await prisma.spaceMember.update({
+ where: { id: memberId },
+ data: { role: toDBRole(role) },
+ });
+}
diff --git a/apps/web/src/features/space/member/schema.ts b/apps/web/src/features/space/member/schema.ts
new file mode 100644
index 000000000..d02ed6a59
--- /dev/null
+++ b/apps/web/src/features/space/member/schema.ts
@@ -0,0 +1,24 @@
+import * as z from "zod";
+import { memberRoleSchema } from "@/features/space/schema";
+
+export const inviteMemberSchema = z.object({
+ email: z.email(),
+ role: memberRoleSchema,
+});
+
+export const cancelInviteSchema = z.object({
+ inviteId: z.string(),
+});
+
+export const removeMemberSchema = z.object({
+ memberId: z.string(),
+});
+
+export const changeMemberRoleSchema = z.object({
+ memberId: z.string(),
+ role: memberRoleSchema,
+});
+
+export const acceptInviteSchema = z.object({
+ spaceId: z.string(),
+});
diff --git a/apps/web/src/features/space/utils.ts b/apps/web/src/features/space/utils.ts
index d02707e45..dedf3751e 100644
--- a/apps/web/src/features/space/utils.ts
+++ b/apps/web/src/features/space/utils.ts
@@ -1,13 +1,5 @@
import type { SpaceMemberRole as PrismaSpaceMemberRole } from "@rallly/database";
-import { createLogger } from "@rallly/logger";
-import { getSpaceSubscription } from "@/features/billing/data";
-import { cached_getInstanceLicense } from "@/features/licensing/data";
-import type { LicenseType } from "@/features/licensing/schema";
import type { MemberRole } from "@/features/space/schema";
-import { isSelfHosted } from "@/lib/constants";
-import { AppError } from "@/lib/errors/app-error";
-
-const logger = createLogger("space/utils");
export const toDBRole = (role: MemberRole): PrismaSpaceMemberRole => {
switch (role) {
@@ -26,79 +18,3 @@ export const fromDBRole = (role: PrismaSpaceMemberRole): MemberRole => {
return "admin";
}
};
-
-/**
- * Default seat limit for spaces without active subscriptions
- */
-const DEFAULT_SEAT_LIMIT = 1;
-const MAX_SEAT_LIMIT = 100;
-
-/**
- * Returns the seat limit for self-hosted instances based on license type
- */
-export function getSelfHostedSeatLimit(
- licenseType: LicenseType | null,
-): number {
- if (!licenseType) {
- return DEFAULT_SEAT_LIMIT;
- }
-
- switch (licenseType) {
- case "PLUS":
- return 5;
- case "ORGANIZATION":
- return 50;
- case "ENTERPRISE":
- return MAX_SEAT_LIMIT;
- default:
- return DEFAULT_SEAT_LIMIT;
- }
-}
-
-/**
- * Gets the total number of seats available for a space
- * Handles both cloud-hosted (Stripe subscription) and self-hosted (license-based) deployments
- */
-export async function getTotalSeatsForSpace(spaceId: string): Promise<number> {
- try {
- if (isSelfHosted) {
- // For self-hosted instances, get seat limit from instance license
- const license = await cached_getInstanceLicense();
-
- if (!license) {
- // No license found, return default limit
- return DEFAULT_SEAT_LIMIT;
- }
-
- // If license has explicit seats defined, use that
- if (license.seats && license.seats > 0) {
- return Math.min(license.seats, MAX_SEAT_LIMIT);
- }
-
- // Otherwise, use the license type to determine seat limit
- return getSelfHostedSeatLimit(license.type);
- } else {
- // For cloud-hosted instances, get seat count from Stripe subscription
- const subscription = await getSpaceSubscription(spaceId);
-
- if (!subscription || !subscription.active) {
- // Return default limit for spaces without active subscriptions
- return DEFAULT_SEAT_LIMIT;
- }
-
- return subscription.quantity || DEFAULT_SEAT_LIMIT;
- }
- } catch (error) {
- logger.error({ error, spaceId }, "Failed to get total seats for space");
-
- if (error instanceof AppError) {
- throw error;
- }
-
- throw new AppError({
- code: "INTERNAL_SERVER_ERROR",
- message: "Failed to retrieve seat information",
- cause: error,
- });
- }
-}
diff --git a/apps/web/src/trpc/routers/dashboard.ts b/apps/web/src/trpc/routers/dashboard.ts
index 0be6c443f..d1e29a6ab 100644
--- a/apps/web/src/trpc/routers/dashboard.ts
+++ b/apps/web/src/trpc/routers/dashboard.ts
@@ -2,9 +2,9 @@ import type { Prisma } from "@rallly/database";
import { prisma } from "@rallly/database";
import * as z from "zod";
import { upcomingScheduledEventWhere } from "@/features/scheduled-event/utils";
+import { getTotalSeatsForSpace } from "@/features/space/data";
import type { MemberAbilityContext } from "@/features/space/member/ability";
import { defineAbilityForMember } from "@/features/space/member/ability";
-import { getTotalSeatsForSpace } from "@/features/space/utils";
import { timeZoneSchema } from "@/lib/datetime/schema";
import { normalizeTimeZone } from "@/lib/datetime/utils";
import { router, spaceProcedure } from "../trpc";
diff --git a/apps/web/src/trpc/routers/spaces.ts b/apps/web/src/trpc/routers/spaces.ts
index 5868c7b0d..764fea581 100644
--- a/apps/web/src/trpc/routers/spaces.ts
+++ b/apps/web/src/trpc/routers/spaces.ts
@@ -1,28 +1,13 @@
import { subject } from "@casl/ability";
import { prisma } from "@rallly/database";
-import { sendSpaceInviteEmail } from "@rallly/emails/templates/space-invite";
-import { createLogger } from "@rallly/logger";
-import { absoluteUrl } from "@rallly/utils/absolute-url";
import { TRPCError } from "@trpc/server";
import * as z from "zod";
-import { getInstanceBranding } from "@/emails/branding";
-import { defineAbilityForSpace } from "@/features/space/ability";
-import {
- createSpaceDTO,
- getMember,
- getSpaceSeatCount,
-} from "@/features/space/data";
+import { createSpaceDTO } from "@/features/space/data";
import { defineAbilityForMember } from "@/features/space/member/ability";
import { effectiveSpaceMemberWhere } from "@/features/space/member/utils";
import { createSpace } from "@/features/space/mutations";
-import { memberRoleSchema } from "@/features/space/schema";
import type { SpaceDTO } from "@/features/space/types";
-import {
- fromDBRole,
- getTotalSeatsForSpace,
- toDBRole,
-} from "@/features/space/utils";
-import { setActiveSpace } from "@/features/user/mutations";
+import { fromDBRole } from "@/features/space/utils";
import { identifyGroup, track } from "@/lib/posthog";
import {
createRateLimitMiddleware,
@@ -31,8 +16,6 @@ import {
spaceProcedure,
} from "../trpc";
-const logger = createLogger("spaces/router");
-
export const spaces = router({
// ── Queries ──────────────────────────────────────────────────────────
list: privateProcedure.query(async ({ ctx }) => {
@@ -217,319 +200,6 @@ export const spaces = router({
});
}),
- inviteMember: spaceProcedure
- .input(z.object({ email: z.email(), role: memberRoleSchema }))
- .mutation(async ({ ctx, input }) => {
- const spaceAbility = defineAbilityForSpace(ctx.space);
-
- if (spaceAbility.cannot("invite", "Member")) {
- throw new TRPCError({
- code: "PAYMENT_REQUIRED",
- message:
- "You need a Pro subscription to invite members to this space",
- });
- }
-
- const memberAbility = defineAbilityForMember({
- user: ctx.user,
- space: ctx.space,
- });
-
- if (memberAbility.cannot("create", "SpaceMemberInvite")) {
- throw new TRPCError({
- code: "FORBIDDEN",
- message: "You do not have permission to invite members to this space",
- });
- }
-
- // Check if user is already a member
- const existingUser = await prisma.user.findUnique({
- where: { email: input.email },
- include: {
- memberOf: {
- where: { spaceId: ctx.space.id },
- },
- },
- });
-
- if (existingUser?.memberOf && existingUser.memberOf.length > 0) {
- return {
- ok: false as const,
- code: "ALREADY_MEMBER" as const,
- };
- }
-
- // Check if there's already a pending invite
- const existingInvite = await prisma.spaceMemberInvite.findUnique({
- where: {
- spaceId_email: {
- spaceId: ctx.space.id,
- email: input.email,
- },
- },
- });
-
- if (existingInvite) {
- if (existingInvite.role !== toDBRole(input.role)) {
- await prisma.spaceMemberInvite.update({
- where: { id: existingInvite.id },
- data: { role: toDBRole(input.role) },
- });
-
- return {
- ok: true as const,
- code: "INVITE_UPDATED" as const,
- };
- }
-
- return {
- ok: false as const,
- code: "INVITE_PENDING" as const,
- };
- }
-
- // Check seat availability only for new invites
- const [currentSeatCount, totalSeats] = await Promise.all([
- getSpaceSeatCount(ctx.space.id),
- getTotalSeatsForSpace(ctx.space.id),
- ]);
-
- if (currentSeatCount >= totalSeats) {
- throw new TRPCError({
- code: "FORBIDDEN",
- message:
- "There are not enough available seats to perform this action",
- });
- }
-
- const invite = await prisma.spaceMemberInvite.create({
- data: {
- spaceId: ctx.space.id,
- email: input.email,
- role: toDBRole(input.role),
- inviterId: ctx.user.id,
- },
- });
-
- try {
- await sendSpaceInviteEmail({
- to: input.email,
- locale: existingUser?.locale ?? ctx.user.locale,
- branding: await getInstanceBranding(),
- props: {
- spaceName: ctx.space.name,
- inviterName: ctx.user.name,
- spaceRole: input.role,
- inviteUrl: absoluteUrl(`/accept-invite/${invite.id}`),
- },
- });
- } catch {
- // cleanup invite
- if (invite) {
- await prisma.spaceMemberInvite.delete({ where: { id: invite.id } });
- }
- return {
- ok: false as const,
- code: "INVITE_FAILED" as const,
- };
- }
-
- track(ctx.user, {
- event: "space_member_invite",
- properties: {
- role: input.role,
- },
- groups: {
- space: ctx.space.id,
- },
- });
-
- return {
- ok: true as const,
- code: "INVITE_SENT" as const,
- };
- }),
-
- acceptInvite: privateProcedure
- .input(z.object({ spaceId: z.string() }))
- .mutation(async ({ ctx, input }) => {
- const spaceMemberInvite = await prisma.spaceMemberInvite.findUnique({
- where: {
- spaceId_email: {
- spaceId: input.spaceId,
- email: ctx.user.email,
- },
- },
- });
-
- if (!spaceMemberInvite) {
- throw new TRPCError({
- code: "NOT_FOUND",
- message: "No pending invite found for this space",
- });
- }
-
- const { memberCount } = await prisma.$transaction(async (tx) => {
- const [usedSeats, totalSeats] = await Promise.all([
- tx.spaceMember.count({ where: { spaceId: input.spaceId } }),
- getTotalSeatsForSpace(input.spaceId),
- ]);
-
- if (usedSeats >= totalSeats) {
- throw new TRPCError({
- code: "FORBIDDEN",
- message:
- "There are not enough available seats to accept this invitation",
- });
- }
-
- await tx.spaceMember.create({
- data: {
- spaceId: input.spaceId,
- userId: ctx.user.id,
- role: spaceMemberInvite.role,
- },
- });
-
- await tx.spaceMemberInvite.delete({
- where: { id: spaceMemberInvite.id },
- });
-
- return { memberCount: usedSeats + 1 };
- });
-
- try {
- await setActiveSpace({
- userId: ctx.user.id,
- spaceId: input.spaceId,
- });
- } catch (error) {
- logger.warn({ error }, "Failed to update user's active space");
- }
-
- track(ctx.user, {
- event: "space_member_join",
- properties: {
- member_count: memberCount,
- },
- groups: {
- space: input.spaceId,
- },
- });
- }),
-
- removeMember: spaceProcedure
- .input(z.object({ memberId: z.string() }))
- .mutation(async ({ ctx, input }) => {
- const member = await getMember(input.memberId);
- if (!member) {
- throw new TRPCError({
- code: "NOT_FOUND",
- message: "Member not found",
- });
- }
-
- const memberAbility = defineAbilityForMember({
- user: ctx.user,
- space: ctx.space,
- });
-
- if (memberAbility.cannot("delete", subject("SpaceMember", member))) {
- throw new TRPCError({
- code: "FORBIDDEN",
- message:
- "You do not have permission to remove members from this space",
- });
- }
-
- const deletedMember = await prisma.spaceMember.delete({
- where: { id: input.memberId },
- });
-
- const memberCount = await prisma.spaceMember.count({
- where: { spaceId: member.spaceId },
- });
-
- track(ctx.user, {
- event: "space_member_remove",
- properties: {
- member_count: memberCount,
- deleted_member_user_id: deletedMember.userId,
- },
- groups: {
- space: member.spaceId,
- },
- });
- }),
-
- changeMemberRole: spaceProcedure
- .input(z.object({ memberId: z.string(), role: memberRoleSchema }))
- .mutation(async ({ ctx, input }) => {
- const member = await getMember(input.memberId);
- if (!member) {
- throw new TRPCError({
- code: "NOT_FOUND",
- message: "Member not found",
- });
- }
-
- const memberAbility = defineAbilityForMember({
- user: ctx.user,
- space: ctx.space,
- });
-
- if (memberAbility.cannot("update", subject("SpaceMember", member))) {
- throw new TRPCError({
- code: "FORBIDDEN",
- message:
- "You do not have permission to change member roles in this space",
- });
- }
-
- await prisma.spaceMember.update({
- where: { id: input.memberId },
- data: { role: toDBRole(input.role) },
- });
- }),
-
- cancelInvite: spaceProcedure
- .input(z.object({ inviteId: z.string() }))
- .mutation(async ({ ctx, input }) => {
- const invite = await prisma.spaceMemberInvite.findUnique({
- where: { id: input.inviteId },
- });
-
- if (!invite) {
- throw new TRPCError({
- code: "NOT_FOUND",
- message: "Invite not found",
- });
- }
-
- if (invite.spaceId !== ctx.space.id) {
- throw new TRPCError({
- code: "FORBIDDEN",
- message: "You do not have access to this invite",
- });
- }
-
- const memberAbility = defineAbilityForMember({
- user: ctx.user,
- space: ctx.space,
- });
-
- if (memberAbility.cannot("delete", "SpaceMemberInvite")) {
- throw new TRPCError({
- code: "FORBIDDEN",
- message: "You do not have permission to cancel invites",
- });
- }
-
- await prisma.spaceMemberInvite.delete({
- where: { id: input.inviteId },
- });
- }),
-
leave: spaceProcedure.mutation(async ({ ctx }) => {
if (ctx.space.ownerId === ctx.user.id) {
throw new TRPCError({
diff --git a/apps/web/tests/space-members.spec.ts b/apps/web/tests/space-members.spec.ts
index b376721cf..679ddd033 100644
--- a/apps/web/tests/space-members.spec.ts
+++ b/apps/web/tests/space-members.spec.ts
@@ -190,9 +190,6 @@ test.describe("Space members", () => {
await expect(page.getByText("Member removed successfully")).toBeVisible();
await expect(row).toBeHidden();
- // Seat usage is rendered from the server and doesn't update in place
- // yet — assert the persisted state after a reload.
- await page.reload();
await expect(page.getByText("1 of 3 seats used")).toBeVisible();
});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b4fac8556..b4c267c7a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -382,8 +382,8 @@ importers:
specifier: 16.2.6
next-safe-action:
- specifier: ^8.0.7
+ specifier: ^8.6.0
pg:
specifier: ^8.17.1
version: 8.18.0
@@ -9224,8 +9224,8 @@ packages:
peerDependencies:
react: '>=16'
- resolution: {integrity: sha512-gqJLmnQLAoFCq1kRBopN46New+vx1n9J9Y/qDQLXpv/VqU40AWxDakvshwwnWAt8R0kLvlakNYNLX5PqlXWSMg==}
+ resolution: {integrity: sha512-aS6e5XhLEmHIJp4wtfLOTSapcnjGZdVMmQIEOq8YCQ95Ej5WbZc+qfn9fP7zyLu33H/cigMZeWTP5NItirJYfg==}
engines: {node: '>=18.17'}
peerDependencies:
next: '>= 14.0.0'
@@ -21804,7 +21804,7 @@ snapshots:
- '@types/react'
- supports-color
dependencies:
react: 19.2.6