Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

chore: show over-capacity warning when members exceed paid seats (#5708)

Oleg Isonen70a1a5d6be1f
diff --git a/apps/builder/app/dashboard/workspace/manage-members-dialog.test.ts b/apps/builder/app/dashboard/workspace/manage-members-dialog.test.ts
index 0b1278d361..1d96a6945c 100644
--- a/apps/builder/app/dashboard/workspace/manage-members-dialog.test.ts
+++ b/apps/builder/app/dashboard/workspace/manage-members-dialog.test.ts
@@ -179,9 +179,7 @@ describe("computeAvailableSeats", () => {
).toBe(-2);
});
- test("confirmedMaxSeats overrides stale server maxSeats when higher", () => {
- // Scenario: user confirmed paying for 2 extra seats but webhook hasn't fired.
- // Server still returns maxSeats=3, but confirmedMaxSeats=5.
+ test("maxSeatsBoost increases available seats optimistically", () => {
const members = [
{
userId: "u1",
@@ -191,35 +189,33 @@ describe("computeAvailableSeats", () => {
username: "",
},
];
- const pendingInvites = [
+ // 2 maxSeats − 1 member = 1, + 3 boost = 4
+ expect(
+ computeAvailableSeats(makeData({ maxSeats: 2, members }), [], 3)
+ ).toBe(4);
+ });
+
+ test("maxSeatsBoost prevents over-capacity after invite", () => {
+ const members = [
{
- notificationId: "n1",
- recipientId: "r1",
- email: "[email protected]",
+ userId: "u1",
+ email: "[email protected]",
relation: "editors" as const,
createdAt: "",
+ username: "",
},
+ ];
+ const optimistic = [
{
- notificationId: "n2",
- recipientId: "r2",
- email: "[email protected]",
- relation: "editors" as const,
- createdAt: "",
+ notificationId: "opt-1",
+ email: "[email protected]",
+ relation: "viewers" as const,
},
];
- // maxSeats=3 (stale), but 1 member + 2 pending = 3 occupied → would be 0 available.
- // confirmedMaxSeats=5 → effectiveMax=5, available = 5-1-2 = 2.
+ // Without boost: 1 maxSeat − 1 member − 1 optimistic = -1
+ // With boost of 1: 1 + 1 − 1 − 1 = 0
expect(
- computeAvailableSeats(
- makeData({ maxSeats: 3, members, pendingInvites }),
- [],
- 5
- )
- ).toBe(2);
- });
-
- test("confirmedMaxSeats is ignored when server maxSeats is already higher", () => {
- // Webhook fired: server returns maxSeats=5, confirmedMaxSeats=4 (stale override).
- expect(computeAvailableSeats(makeData({ maxSeats: 5 }), [], 4)).toBe(5);
+ computeAvailableSeats(makeData({ maxSeats: 1, members }), optimistic, 1)
+ ).toBe(0);
});
});
diff --git a/apps/builder/app/dashboard/workspace/manage-members-dialog.tsx b/apps/builder/app/dashboard/workspace/manage-members-dialog.tsx
index f1809ca4cf..8b38293d7d 100644
--- a/apps/builder/app/dashboard/workspace/manage-members-dialog.tsx
+++ b/apps/builder/app/dashboard/workspace/manage-members-dialog.tsx
@@ -19,6 +19,7 @@ import {
ScrollAreaNative,
Select,
Tooltip,
+ PanelBanner,
css,
theme,
} from "@webstudio-is/design-system";
@@ -255,17 +256,11 @@ const computeAvailableSeats = (
>["data"]
| undefined,
optimisticPending: OptimisticPendingInvite[],
- // Optimistic upper bound for maxSeats set when extra seats are confirmed,
- // to avoid flickering while the Stripe webhook has not yet updated TransactionLog.
- confirmedMaxSeats?: number
+ maxSeatsBoost = 0
): number | undefined => {
if (membersData === undefined) {
return;
}
- const effectiveMaxSeats =
- confirmedMaxSeats !== undefined
- ? Math.max(membersData.maxSeats, confirmedMaxSeats)
- : membersData.maxSeats;
const knownEmails = new Set([
membersData.owner.email,
...membersData.members.map((m) => m.email ?? ""),
@@ -275,7 +270,8 @@ const computeAvailableSeats = (
(o) => !knownEmails.has(o.email)
).length;
return (
- effectiveMaxSeats -
+ membersData.maxSeats +
+ maxSeatsBoost -
membersData.members.length -
membersData.pendingInvites.length -
extraCount
@@ -435,10 +431,7 @@ export const ManageMembersDialog = ({
relation: Role;
extraSeats: number;
}>();
- // Optimistic maxSeats ceiling: set when the user confirms extra-seat charges so
- // the footer and confirmation gate stay correct while the Stripe webhook is in
- // flight (TransactionLog not yet updated).
- const [confirmedMaxSeats, setConfirmedMaxSeats] = useState<number>();
+ const [maxSeatsBoost, setMaxSeatsBoost] = useState(0);
const formRef = useRef<HTMLFormElement>(null);
const { load, data } = trpcClient.workspace.listMembers.useQuery();
@@ -453,24 +446,33 @@ export const ManageMembersDialog = ({
}
}, [isOpen, isOwner, load, workspace.id]);
- // Clear the optimistic override once the server reflects the paid seats.
- useEffect(() => {
- if (
- membersData !== undefined &&
- confirmedMaxSeats !== undefined &&
- membersData.maxSeats >= confirmedMaxSeats
- ) {
- setConfirmedMaxSeats(undefined);
- }
- }, [membersData, confirmedMaxSeats]);
-
const availableSeats = computeAvailableSeats(
membersData,
optimisticPending,
- confirmedMaxSeats
+ maxSeatsBoost
);
- const performInvite = async (emails: string[], relation: Role) => {
+ const syncSeatsMutation = trpcClient.workspace.syncSeats.useMutation();
+
+ const overCapacity =
+ availableSeats !== undefined && availableSeats < 0 ? -availableSeats : 0;
+
+ const handleSyncSeats = () => {
+ syncSeatsMutation.send({ workspaceId: workspace.id }, (result) => {
+ if (result && "error" in result) {
+ setErrors([result.error]);
+ return;
+ }
+ handleRefresh();
+ revalidator.revalidate();
+ });
+ };
+
+ const performInvite = async (
+ emails: string[],
+ relation: Role,
+ { boughtExtraSeats = false } = {}
+ ) => {
setErrors(undefined);
setInviting(true);
@@ -481,6 +483,13 @@ export const ManageMembersDialog = ({
// non-existent or already-member emails never flicker into the list.
const failedEmails = new Set(failed.map((f) => f.split(":")[0].trim()));
const succeeded = emails.filter((e) => !failedEmails.has(e));
+
+ // Optimistically bump maxSeats so the banner never flashes.
+ // The server's maxSeats will catch up once the Stripe webhook lands,
+ // but we cannot predict when that will happen.
+ if (boughtExtraSeats && succeeded.length > 0) {
+ setMaxSeatsBoost((prev) => prev + succeeded.length);
+ }
if (succeeded.length > 0) {
const optimistic: OptimisticPendingInvite[] = succeeded.map((email) => ({
notificationId: crypto.randomUUID(),
@@ -536,15 +545,9 @@ export const ManageMembersDialog = ({
onConfirm={async () => {
const confirm = pendingConfirm;
setPendingConfirm(undefined);
- // Optimistically raise confirmedMaxSeats so the footer and the
- // confirmation gate reflect the payment before the webhook fires.
- setConfirmedMaxSeats((prev) =>
- Math.max(
- prev ?? 0,
- (membersData?.maxSeats ?? 0) + confirm.extraSeats
- )
- );
- await performInvite(confirm.emails, confirm.relation);
+ await performInvite(confirm.emails, confirm.relation, {
+ boughtExtraSeats: true,
+ });
}}
/>
)}
@@ -554,7 +557,7 @@ export const ManageMembersDialog = ({
onOpenChange(open);
if (open === false) {
setErrors(undefined);
- setConfirmedMaxSeats(undefined);
+ setMaxSeatsBoost(0);
}
}}
>
@@ -599,6 +602,31 @@ export const ManageMembersDialog = ({
</Flex>
</Flex>
)}
+ {isOwner && overCapacity > 0 && (
+ <PanelBanner variant="warning">
+ <Flex direction="column" gap="2">
+ <Text>
+ {`Your workspace has ${overCapacity} more member${overCapacity === 1 ? "" : "s"} than your plan covers. Non-owner members won't be able to access the workspace until this is resolved.`}
+ </Text>
+ <Flex gap="2">
+ <Button
+ color="dark"
+ onClick={handleSyncSeats}
+ state={
+ syncSeatsMutation.state !== "idle"
+ ? "pending"
+ : undefined
+ }
+ >
+ {`Buy ${overCapacity} extra seat${overCapacity === 1 ? "" : "s"}`}
+ </Button>
+ <Text color="subtle" css={{ alignSelf: "center" }}>
+ {`or remove ${overCapacity} member${overCapacity === 1 ? "" : "s"}`}
+ </Text>
+ </Flex>
+ </Flex>
+ </PanelBanner>
+ )}
<ScrollAreaNative
css={{
maxHeight: 300,
diff --git a/apps/builder/app/routes/_ui.dashboard.tsx b/apps/builder/app/routes/_ui.dashboard.tsx
index 62e0260418..a94d71a202 100644
--- a/apps/builder/app/routes/_ui.dashboard.tsx
+++ b/apps/builder/app/routes/_ui.dashboard.tsx
@@ -268,9 +268,7 @@ const DashboardRoute = () => {
}, []);
useEffect(() => {
- if (search !== "") {
- setSetting("lastDashboardSearch", search);
- }
+ setSetting("lastDashboardSearch", search);
}, [search]);
// `useLoaderData` wraps the return in `JsonifyObject` which turns
diff --git a/apps/builder/app/services/workspace-router.server.test.ts b/apps/builder/app/services/workspace-router.server.test.ts
new file mode 100644
index 0000000000..2494681ee3
--- /dev/null
+++ b/apps/builder/app/services/workspace-router.server.test.ts
@@ -0,0 +1,466 @@
+import { describe, test, expect, vi } from "vitest";
+
+// vi.hoisted runs before ESM imports, so env.server.ts sees these values.
+vi.hoisted(() => {
+ process.env.PAYMENT_WORKER_URL = "http://test-payment-worker";
+ process.env.PAYMENT_WORKER_TOKEN = "test-token";
+});
+
+import { http, HttpResponse } from "msw";
+import {
+ createTestServer,
+ db,
+ json,
+ empty,
+ testContext,
+} from "@webstudio-is/postgrest/testing";
+import { createCallerFactory } from "@webstudio-is/trpc-interface/index.server";
+import type { AppContext } from "@webstudio-is/trpc-interface/index.server";
+import { defaultPlanFeatures, type PlanFeatures } from "@webstudio-is/plans";
+import { workspaceRouter } from "./workspace-router.server";
+import env from "~/env/env.server";
+
+const server = createTestServer();
+
+const createCaller = createCallerFactory(workspaceRouter);
+
+const teamPlan: PlanFeatures = {
+ ...defaultPlanFeatures,
+ maxWorkspaces: 5,
+ seatsIncluded: 4,
+ maxSeatsPerWorkspace: 20,
+};
+
+const createContext = (
+ overrides?: Partial<{ planFeatures: PlanFeatures; userId: string }>
+): AppContext =>
+ ({
+ ...testContext,
+ authorization: {
+ type: "user",
+ userId: overrides?.userId ?? "owner-1",
+ },
+ planFeatures: overrides?.planFeatures ?? teamPlan,
+ purchases: [],
+ trpcCache: { setMaxAge: () => {} },
+ getOwnerPlanFeatures: async () => overrides?.planFeatures ?? teamPlan,
+ }) as unknown as AppContext;
+
+// ---------------------------------------------------------------------------
+// Helpers – the addMember flow touches MANY PostgREST tables. The router code
+// makes its own queries (seat-limit HEAD counts, invitee lookup, existing-
+// member check) and then calls workspaceApi.addMember which duplicates some
+// of those queries behind assertOwner / assertUser. We use a single handler
+// per table that inspects the request URL to distinguish the different calls.
+// ---------------------------------------------------------------------------
+
+/**
+ * Set up all MSW handlers needed for a full addMember happy-path.
+ * Individual tests override specific handlers via `server.use(…)` *after*
+ * calling this function.
+ *
+ * The payment worker now owns member counting via /seats/sync, so no
+ * countAllMembers DB mocks are needed here — only the per-workspace
+ * seat-limit HEAD counts.
+ */
+const setupAddMemberMocks = (opts?: {
+ /** Active members in the target workspace (used for HEAD count) */
+ workspaceMemberCount?: number;
+ /** Pending invites for the target workspace (used for HEAD count) */
+ pendingInviteCount?: number;
+ /** Payment worker JSON response, or `null` to return HTTP 500. */
+ paymentWorkerResponse?: object | null;
+}) => {
+ const {
+ workspaceMemberCount = 1,
+ pendingInviteCount = 0,
+ paymentWorkerResponse = { type: "success" as const, seats: 1 },
+ } = opts ?? {};
+
+ server.use(
+ // ---- Workspace (router seat-limit + assertOwner) ----
+ db.get("Workspace", () =>
+ json({ id: "ws-1", userId: "owner-1", isDeleted: false })
+ ),
+
+ // ---- User (router invitee-lookup + workspaceApi.addMember lookup) ----
+ db.get("User", () =>
+ json({ id: "user-2", email: "[email protected]", username: "invitee" })
+ ),
+
+ // ---- WorkspaceMember ----
+ // GET: router existing-member check + workspaceApi.addMember check
+ db.get("WorkspaceMember", () => json(null)),
+ // HEAD: per-workspace seat-limit count
+ db.head("WorkspaceMember", () =>
+ empty({ headers: { "Content-Range": `*/${workspaceMemberCount}` } })
+ ),
+
+ // ---- Notification ----
+ // HEAD: router pending-invite count for seat limit
+ db.head("Notification", () =>
+ empty({ headers: { "Content-Range": `*/${pendingInviteCount}` } })
+ ),
+ // GET: createNotification duplicate check
+ db.get("Notification", () => json(null)),
+ // POST: Notification insert (createNotification)
+ db.post("Notification", () =>
+ json(
+ {
+ id: "notif-1",
+ type: "workspaceInvite",
+ recipientId: "user-2",
+ senderId: "owner-1",
+ status: "pending",
+ payload: { workspaceId: "ws-1", relation: "editors" },
+ },
+ { status: 201 }
+ )
+ ),
+
+ // ---- Payment worker (/seats/sync) ----
+ http.post(`${env.PAYMENT_WORKER_URL}/seats/sync`, () => {
+ if (paymentWorkerResponse === null) {
+ return new HttpResponse(null, { status: 500 });
+ }
+ return HttpResponse.json(paymentWorkerResponse);
+ })
+ );
+};
+
+// ---------------------------------------------------------------------------
+// addMember
+// ---------------------------------------------------------------------------
+
+describe("addMember", () => {
+ test("rejects when maxWorkspaces <= 1 (free/pro plan)", async () => {
+ // No DB mocks needed — the check happens before any queries.
+ const ctx = createContext({ planFeatures: defaultPlanFeatures });
+ const caller = createCaller(ctx);
+
+ const result = await caller.addMember({
+ workspaceId: "ws-1",
+ email: "[email protected]",
+ relation: "editors",
+ });
+
+ expect(result.success).toBe(false);
+ if (!result.success) {
+ expect(result.error).toContain("Upgrade your plan");
+ }
+ });
+
+ test("rejects when workspace seat limit reached", async () => {
+ const plan: PlanFeatures = { ...teamPlan, maxSeatsPerWorkspace: 2 };
+ const ctx = createContext({ planFeatures: plan });
+ const caller = createCaller(ctx);
+
+ // 2 members + 0 pending = 2 >= maxSeatsPerWorkspace(2)
+ setupAddMemberMocks({ workspaceMemberCount: 2, pendingInviteCount: 0 });
+
+ const result = await caller.addMember({
+ workspaceId: "ws-1",
+ email: "[email protected]",
+ relation: "editors",
+ });
+
+ expect(result.success).toBe(false);
+ if (!result.success) {
+ expect(result.error).toContain("seat limit");
+ }
+ });
+
+ test("rejects when members + pending invites >= maxSeatsPerWorkspace", async () => {
+ const plan: PlanFeatures = { ...teamPlan, maxSeatsPerWorkspace: 2 };
+ const ctx = createContext({ planFeatures: plan });
+ const caller = createCaller(ctx);
+
+ // 1 member + 1 pending = 2 >= maxSeatsPerWorkspace(2)
+ setupAddMemberMocks({ workspaceMemberCount: 1, pendingInviteCount: 1 });
+
+ const result = await caller.addMember({
+ workspaceId: "ws-1",
+ email: "[email protected]",
+ relation: "editors",
+ });
+
+ expect(result.success).toBe(false);
+ if (!result.success) {
+ expect(result.error).toContain("seat limit");
+ }
+ });
+
+ test("rejects when payment worker returns error (card declined)", async () => {
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+
+ setupAddMemberMocks({
+ paymentWorkerResponse: {
+ type: "error",
+ error: "Your card was declined.",
+ },
+ });
+
+ const result = await caller.addMember({
+ workspaceId: "ws-1",
+ email: "[email protected]",
+ relation: "editors",
+ });
+
+ expect(result.success).toBe(false);
+ if (!result.success) {
+ expect(result.error).toContain("Unable to update billing");
+ }
+ });
+
+ test("rejects when payment worker HTTP response is not ok", async () => {
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+
+ setupAddMemberMocks({ paymentWorkerResponse: null });
+
+ const result = await caller.addMember({
+ workspaceId: "ws-1",
+ email: "[email protected]",
+ relation: "editors",
+ });
+
+ expect(result.success).toBe(false);
+ if (!result.success) {
+ expect(result.error).toContain("Unable to update billing");
+ }
+ });
+
+ test("pre-charges payment worker with delta=+1", async () => {
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+
+ let capturedBody: { workspaceId: string; delta: number } | undefined;
+
+ setupAddMemberMocks();
+
+ // Override the payment worker handler to capture the request body.
+ server.use(
+ http.post(`${env.PAYMENT_WORKER_URL}/seats/sync`, async ({ request }) => {
+ capturedBody = (await request.json()) as typeof capturedBody;
+ return HttpResponse.json({ type: "success", seats: 1 });
+ })
+ );
+
+ const result = await caller.addMember({
+ workspaceId: "ws-1",
+ email: "[email protected]",
+ relation: "editors",
+ });
+
+ expect(result.success).toBe(true);
+ expect(capturedBody).toBeDefined();
+ expect(capturedBody!.workspaceId).toBe("ws-1");
+ expect(capturedBody!.delta).toBe(1);
+ });
+
+ test("succeeds and creates invite notification when billing passes", async () => {
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+
+ setupAddMemberMocks({ workspaceMemberCount: 2 });
+
+ const result = await caller.addMember({
+ workspaceId: "ws-1",
+ email: "[email protected]",
+ relation: "editors",
+ });
+
+ expect(result.success).toBe(true);
+ if (result.success) {
+ expect(result.notificationId).toBeDefined();
+ }
+ });
+});
+
+// ---------------------------------------------------------------------------
+// removeMember
+// ---------------------------------------------------------------------------
+
+describe("removeMember", () => {
+ test("calls payment worker to sync seats after removal", async () => {
+ let capturedBody: { workspaceId: string; delta?: number } | undefined;
+
+ server.use(
+ // assertOwner
+ db.get("Workspace", () =>
+ json({ id: "ws-1", userId: "owner-1", isDeleted: false })
+ ),
+ // soft-delete via PATCH
+ db.patch("WorkspaceMember", () => json({ userId: "user-2" })),
+ http.post(`${env.PAYMENT_WORKER_URL}/seats/sync`, async ({ request }) => {
+ capturedBody = (await request.json()) as typeof capturedBody;
+ return HttpResponse.json({ type: "success", seats: 0 });
+ })
+ );
+
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+ const result = await caller.removeMember({
+ workspaceId: "ws-1",
+ memberUserId: "user-2",
+ });
+
+ expect(result.success).toBe(true);
+ expect(capturedBody).toBeDefined();
+ expect(capturedBody!.workspaceId).toBe("ws-1");
+ // No delta — member is already removed from DB
+ expect(capturedBody!.delta).toBe(0);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// syncSeats
+// ---------------------------------------------------------------------------
+
+describe("syncSeats", () => {
+ test("rejects when maxWorkspaces <= 1", async () => {
+ const ctx = createContext({ planFeatures: defaultPlanFeatures });
+ const caller = createCaller(ctx);
+
+ const result = await caller.syncSeats({ workspaceId: "ws-1" });
+
+ expect(result.success).toBe(false);
+ if (!result.success) {
+ expect(result.error).toContain("Upgrade your plan");
+ }
+ });
+
+ test("calls payment worker with workspaceId (no delta)", async () => {
+ let capturedBody: { workspaceId: string; delta?: number } | undefined;
+
+ server.use(
+ http.post(`${env.PAYMENT_WORKER_URL}/seats/sync`, async ({ request }) => {
+ capturedBody = (await request.json()) as typeof capturedBody;
+ return HttpResponse.json({ type: "success", seats: 3 });
+ })
+ );
+
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+ const result = await caller.syncSeats({ workspaceId: "ws-1" });
+
+ expect(result.success).toBe(true);
+ expect(capturedBody).toBeDefined();
+ expect(capturedBody!.workspaceId).toBe("ws-1");
+ // No delta for manual sync
+ expect(capturedBody!.delta).toBe(0);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// listMembers
+// ---------------------------------------------------------------------------
+
+describe("listMembers", () => {
+ const setupListMembersMocks = (opts: {
+ memberCount?: number;
+ transactionLog?: object | null;
+ }) => {
+ const { memberCount = 2, transactionLog = null } = opts;
+
+ const members = Array.from({ length: memberCount }, (_, i) => ({
+ userId: `m-${i + 1}`,
+ relation: "editors",
+ createdAt: "2024-01-01T00:00:00.000Z",
+ }));
+
+ server.use(
+ // listMembers: Workspace lookup + owner-or-member check
+ db.get("Workspace", () =>
+ json({ id: "ws-1", userId: "owner-1", isDeleted: false })
+ ),
+ // listMembers: WorkspaceMember SELECT (members list + access check)
+ db.get("WorkspaceMember", () => json(members)),
+ // listMembers: Notification GET (pending invites for this workspace)
+ db.get("Notification", () => json([])),
+ // listMembers: User batch lookup
+ db.get("User", () =>
+ json([
+ { id: "owner-1", email: "[email protected]", username: "owner" },
+ ...members.map((m) => ({
+ id: m.userId,
+ email: `${m.userId}@test.com`,
+ username: m.userId,
+ })),
+ ])
+ ),
+ // getExtraPaidSeats: Product lookup + TransactionLog query
+ db.get("Product", () => json([{ id: "prod-seats" }])),
+ db.get("TransactionLog", () => json(transactionLog))
+ );
+ };
+
+ test("maxSeats = seatsIncluded + extraSeats when subscription exists", async () => {
+ // seatsIncluded=4, quantity=2 → maxSeats=6
+ setupListMembersMocks({
+ transactionLog: {
+ eventData: {
+ data: { object: { items: { data: [{ quantity: 2 }] } } },
+ },
+ },
+ });
+
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+ const result = await caller.listMembers({ workspaceId: "ws-1" });
+
+ expect(result.success).toBe(true);
+ if (result.success) {
+ expect(result.data.maxSeats).toBe(6); // 4 + 2
+ }
+ });
+
+ test("maxSeats = seatsIncluded when no subscription events", async () => {
+ // seatsIncluded=4, no TransactionLog event → paidSeats=null → maxSeats=4
+ setupListMembersMocks({ transactionLog: null });
+
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+ const result = await caller.listMembers({ workspaceId: "ws-1" });
+
+ expect(result.success).toBe(true);
+ if (result.success) {
+ expect(result.data.maxSeats).toBe(4); // 4 + 0
+ }
+ });
+
+ test("maxSeats = seatsIncluded when subscription has quantity=0", async () => {
+ setupListMembersMocks({
+ transactionLog: {
+ eventData: {
+ data: { object: { items: { data: [{ quantity: 0 }] } } },
+ },
+ },
+ });
+
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+ const result = await caller.listMembers({ workspaceId: "ws-1" });
+
+ expect(result.success).toBe(true);
+ if (result.success) {
+ expect(result.data.maxSeats).toBe(4); // 4 + 0
+ }
+ });
+
+ test("returns owner, members, and pendingInvites", async () => {
+ setupListMembersMocks({ memberCount: 2, transactionLog: null });
+
+ const ctx = createContext();
+ const caller = createCaller(ctx);
+ const result = await caller.listMembers({ workspaceId: "ws-1" });
+
+ expect(result.success).toBe(true);
+ if (result.success) {
+ expect(result.data.owner.userId).toBe("owner-1");
+ expect(result.data.members).toHaveLength(2);
+ expect(result.data.pendingInvites).toHaveLength(0);
+ }
+ });
+});
diff --git a/apps/builder/app/services/workspace-router.server.ts b/apps/builder/app/services/workspace-router.server.ts
index 4eb261b68c..1cffa72218 100644
--- a/apps/builder/app/services/workspace-router.server.ts
+++ b/apps/builder/app/services/workspace-router.server.ts
@@ -6,89 +6,48 @@ import {
} from "@webstudio-is/trpc-interface/index.server";
import { workspace as workspaceApi } from "@webstudio-is/project/index.server";
import { roles } from "@webstudio-is/trpc-interface/authorize";
-import { getPaidSeats } from "@webstudio-is/plans/index.server";
+import { getExtraPaidSeats } from "@webstudio-is/plans/index.server";
import env from "~/env/env.server";
const Name = z.string().min(2).max(100);
const Relation = z.enum(roles);
-type UpdateSeatsResult =
- | { type: "success"; seats: number }
- | { type: "error"; error: string };
-
-const updateSeats = async ({
- userId,
- newQuantity,
-}: {
- userId: string;
- newQuantity: number;
-}): Promise<UpdateSeatsResult | null> => {
+/**
+ * Tells the payment worker to count members and adjust Stripe seats.
+ * All member-counting and Stripe logic lives in the worker — the builder
+ * only passes the workspaceId and an optional delta.
+ *
+ * @param delta - adjustment to the current member count.
+ * Pass +1 when a member is about to be added (pre-charge before DB insert).
+ * Defaults to 0 (post-removal or manual sync).
+ */
+const syncSeats = async (workspaceId: string, delta = 0): Promise<void> => {
if (!env.PAYMENT_WORKER_URL || !env.PAYMENT_WORKER_TOKEN) {
- return null;
+ return;
}
- const url = `${env.PAYMENT_WORKER_URL}/seats/update`;
-
- const response = await fetch(url, {
+ const response = await fetch(`${env.PAYMENT_WORKER_URL}/seats/sync`, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: `Bearer ${env.PAYMENT_WORKER_TOKEN}`,
},
- body: JSON.stringify({
- userId,
- newQuantity,
- }),
+ body: JSON.stringify({ workspaceId, delta }),
});
if (!response.ok) {
throw new Error(
- `Payment worker /seats/update responded with ${response.status}`
+ `Payment worker /seats/sync responded with ${response.status}`
);
}
- return (await response.json()) as UpdateSeatsResult;
-};
-
-/**
- * Syncs the Stripe seat quantity for the owner of a given workspace.
- * Called after adding or removing members.
- * Throws on payment worker errors so the caller can decide whether to soft-fail.
- *
- * @param countDelta - adjustment to the current member count before syncing.
- * Pass +1 when a member is about to be added (pre-charge) so that billing
- * is checked before the DB change is committed.
- */
-const syncOwnerSeats = async (
- workspaceId: string,
- ctx: Parameters<typeof workspaceApi.countAllMembers>[1],
- countDelta = 0
-) => {
- const workspaceResult = await ctx.postgrest.client
- .from("Workspace")
- .select("userId")
- .eq("id", workspaceId)
- .eq("isDeleted", false)
- .maybeSingle();
-
- if (workspaceResult.error || workspaceResult.data === null) {
- return;
- }
-
- const ownerId = workspaceResult.data.userId;
- const memberCount = await workspaceApi.countAllMembers(ownerId, ctx);
-
- const result = await updateSeats({
- userId: ownerId,
- newQuantity: memberCount + countDelta,
- });
-
- if (result === null) {
- return;
- }
+ const result = (await response.json()) as {
+ type: string;
+ error?: string;
+ };
if (result.type === "error") {
- throw new Error(`Payment worker rejected seat update: ${result.error}`);
+ throw new Error(`Payment worker rejected seat sync: ${result.error}`);
}
};
@@ -210,7 +169,7 @@ export const workspaceRouter = router({
// triggers a billing change.
// When the payment worker is configured, a billing failure aborts the
// invite so the member is never added. When the worker URL is not set
- // (self-hosted / dev), syncOwnerSeats returns early and this is a no-op.
+ // (self-hosted / dev), syncSeats returns early and this is a no-op.
// Validate the invitee exists and is not already a member before
// touching billing. This mirrors the checks in workspaceApi.addMember
@@ -243,7 +202,7 @@ export const workspaceRouter = router({
}
try {
- await syncOwnerSeats(input.workspaceId, ctx, +1);
+ await syncSeats(input.workspaceId, +1);
} catch (error) {
const technical =
error instanceof Error ? error.message : String(error);
@@ -287,12 +246,22 @@ export const workspaceRouter = router({
.mutation(async ({ input, ctx }) => {
try {
await workspaceApi.removeMember(input, ctx);
+ await syncSeats(input.workspaceId);
- // Do NOT call Stripe — the seat is already paid for this billing
- // period (high water mark). The owner can reuse it for another member
- // without extra charge. Extra-seat quantity is right-sized at renewal
- // by the invoice.created webhook.
+ return { success: true as const };
+ } catch (error) {
+ return createErrorResponse(error);
+ }
+ }),
+ syncSeats: procedure
+ .input(z.object({ workspaceId: z.string() }))
+ .mutation(async ({ input, ctx }) => {
+ try {
+ if (ctx.planFeatures.maxWorkspaces <= 1) {
+ throw new Error("Upgrade your plan to manage workspace seats.");
+ }
+ await syncSeats(input.workspaceId);
return { success: true as const };
} catch (error) {
return createErrorResponse(error);
@@ -304,15 +273,18 @@ export const workspaceRouter = router({
.query(async ({ input, ctx }) => {
try {
const members = await workspaceApi.listMembers(input, ctx);
- const paidSeats = await getPaidSeats(members.owner.userId, ctx);
+ const extraPaidSeats = await getExtraPaidSeats(
+ members.owner.userId,
+ ctx
+ );
return {
success: true as const,
data: {
...members,
// seatsIncluded = seats covered by the Team plan.
- // paidSeats = extra seats from the Seats subscription.
+ // extraPaidSeats = extra seats from the Seats subscription.
// Total capacity = included + extras.
- maxSeats: ctx.planFeatures.seatsIncluded + (paidSeats ?? 0),
+ maxSeats: ctx.planFeatures.seatsIncluded + (extraPaidSeats ?? 0),
},
};
} catch (error) {
diff --git a/apps/builder/package.json b/apps/builder/package.json
index cc83328a32..8ecd9b352c 100644
--- a/apps/builder/package.json
+++ b/apps/builder/package.json
@@ -136,6 +136,7 @@
"@types/react-dom": "^18.2.25",
"@vitest/coverage-v8": "3.1.2",
"@webstudio-is/tsconfig": "workspace:*",
+ "msw": "^2.13.2",
"css.escape": "^1.5.1",
"fast-glob": "^3.3.2",
"html-tags": "^4.0.0",
diff --git a/packages/plans/src/index.server.ts b/packages/plans/src/index.server.ts
index 821442e44d..7d95a04c1d 100644
--- a/packages/plans/src/index.server.ts
+++ b/packages/plans/src/index.server.ts
@@ -1,7 +1,7 @@
export * from "./index";
export {
getPlanInfo,
- getPaidSeats,
+ getExtraPaidSeats,
getAuthorizationOwnerId,
parsePlansEnv,
parseProductMeta,
diff --git a/packages/plans/src/plan-client.server.test.ts b/packages/plans/src/plan-client.server.test.ts
index 2d5e607f23..70051a8e51 100644
--- a/packages/plans/src/plan-client.server.test.ts
+++ b/packages/plans/src/plan-client.server.test.ts
@@ -6,7 +6,11 @@ import {
testContext,
} from "@webstudio-is/postgrest/testing";
import { type PlanFeatures, defaultPlanFeatures } from "./plan-features";
-import { getPlanInfo, __testing__ } from "./plan-client.server";
+import {
+ getPlanInfo,
+ getExtraPaidSeats,
+ __testing__,
+} from "./plan-client.server";
const { parseProductMeta, mergeProductMetas } = __testing__;
@@ -252,3 +256,91 @@ describe("workspaces plan", () => {
expect(result.canDownloadAssets).toBe(true);
});
});
+
+// ---------------------------------------------------------------------------
+// getExtraPaidSeats
+// ---------------------------------------------------------------------------
+
+const seatProduct = { id: "prod-seats" };
+
+const subscriptionEvent = (quantity: number, subscriptionId = "sub-seats") => ({
+ subscriptionId,
+ eventCreated: 1000,
+ eventData: {
+ data: { object: { items: { data: [{ quantity }] } } },
+ },
+});
+
+const setupSeatMocks = ({
+ productRows = [seatProduct],
+ transactionRow = subscriptionEvent(2) as Record<string, unknown> | null,
+ deletedRow = null as Record<string, unknown> | null,
+}: {
+ productRows?: Array<{ id: string }>;
+ transactionRow?: Record<string, unknown> | null;
+ deletedRow?: Record<string, unknown> | null;
+} = {}) => {
+ server.use(
+ db.get("Product", () => json(productRows)),
+ db.get("TransactionLog", ({ request }) => {
+ const url = new URL(request.url);
+ const eventType = url.searchParams.get("eventType");
+ // Deletion check query uses eq filter
+ if (eventType === "eq.customer.subscription.deleted") {
+ return json(deletedRow ? [deletedRow] : []);
+ }
+ // Main query uses in filter
+ return json(transactionRow ? [transactionRow] : []);
+ })
+ );
+};
+
+describe("getExtraPaidSeats", () => {
+ test("returns quantity from latest subscription event", async () => {
+ setupSeatMocks({ transactionRow: subscriptionEvent(3) });
+ const result = await getExtraPaidSeats("user-1", testContext);
+ expect(result).toBe(3);
+ });
+
+ test("returns null when no Seats product exists", async () => {
+ setupSeatMocks({ productRows: [] });
+ const result = await getExtraPaidSeats("user-1", testContext);
+ expect(result).toBeNull();
+ });
+
+ test("returns null when no subscription event exists", async () => {
+ setupSeatMocks({ transactionRow: null });
+ const result = await getExtraPaidSeats("user-1", testContext);
+ expect(result).toBeNull();
+ });
+
+ test("returns null when subscription was deleted after the latest event", async () => {
+ setupSeatMocks({
+ transactionRow: subscriptionEvent(2),
+ deletedRow: { eventId: "evt-del" },
+ });
+ const result = await getExtraPaidSeats("user-1", testContext);
+ expect(result).toBeNull();
+ });
+
+ test("returns quantity when no deletion event exists", async () => {
+ setupSeatMocks({
+ transactionRow: subscriptionEvent(5),
+ deletedRow: null,
+ });
+ const result = await getExtraPaidSeats("user-1", testContext);
+ expect(result).toBe(5);
+ });
+
+ test("returns null when eventData has no quantity", async () => {
+ setupSeatMocks({
+ transactionRow: {
+ subscriptionId: "sub-seats",
+ eventCreated: 1000,
+ eventData: { data: { object: {} } },
+ },
+ });
+ const result = await getExtraPaidSeats("user-1", testContext);
+ expect(result).toBeNull();
+ });
+});
diff --git a/packages/plans/src/plan-client.server.ts b/packages/plans/src/plan-client.server.ts
index 8c809a4d0a..1ce09f6890 100644
--- a/packages/plans/src/plan-client.server.ts
+++ b/packages/plans/src/plan-client.server.ts
@@ -206,22 +206,39 @@ export const getPlanInfo = async (
};
/**
- * Returns the Stripe subscription item quantity for the given user, derived
- * from the latest customer.subscription.updated/created event in TransactionLog.
- * Returns null when no subscription event exists yet (free plan, AppSumo, etc.).
+ * Returns the extra-seat subscription quantity for the given user, derived
+ * from the latest customer.subscription.updated/created event in TransactionLog
+ * whose product is an extra-seat plan (maxSeatsPerWorkspace > 0, maxWorkspaces <= 1).
+ *
+ * Returns null when no matching event exists (free plan, no extra seats, etc.).
*/
-export const getPaidSeats = async (
+export const getExtraPaidSeats = async (
userId: string,
context: { postgrest: PostgrestContext }
): Promise<number | null> => {
+ const productResult = await context.postgrest.client
+ .from("Product")
+ .select("id")
+ .eq("name", "Seats");
+
+ if (productResult.error) {
+ throw productResult.error;
+ }
+
+ const seatProductIds = (productResult.data ?? []).map((p) => p.id);
+ if (seatProductIds.length === 0) {
+ return null;
+ }
+
const result = await context.postgrest.client
.from("TransactionLog")
- .select("eventData")
+ .select("eventData,subscriptionId,eventCreated")
.eq("userId", userId)
.in("eventType", [
"customer.subscription.updated",
"customer.subscription.created",
])
+ .in("productId", seatProductIds)
.order("eventCreated", { ascending: false })
.limit(1)
.maybeSingle();
@@ -230,7 +247,31 @@ export const getPaidSeats = async (
throw result.error;
}
- const eventData = result.data?.eventData as
+ if (!result.data) {
+ return null;
+ }
+
+ // Check if the subscription was cancelled after this event.
+ if (result.data.subscriptionId) {
+ const deleted = await context.postgrest.client
+ .from("TransactionLog")
+ .select("eventId")
+ .eq("subscriptionId", result.data.subscriptionId)
+ .eq("eventType", "customer.subscription.deleted")
+ .eq("status", "canceled")
+ .gt("eventCreated", result.data.eventCreated)
+ .limit(1)
+ .maybeSingle();
+
+ if (deleted.error) {
+ throw deleted.error;
+ }
+ if (deleted.data) {
+ return null;
+ }
+ }
+
+ const eventData = result.data.eventData as
| {
data?: {
object?: {
diff --git a/packages/project/src/db/workspace.test.ts b/packages/project/src/db/workspace.test.ts
index b7d4d6f482..6c1ec495df 100644
--- a/packages/project/src/db/workspace.test.ts
+++ b/packages/project/src/db/workspace.test.ts
@@ -219,139 +219,217 @@ describe("findMany (msw)", () => {
expect(member?.isDowngraded).toBe(true);
});
- test("returns member workspaces with isDowngraded=true when actualMembers > paidSeats", async () => {
- // Owner has workspaces plan (maxWorkspaces > 1), 3 members + 1 pending = 4 non-owner total,
- // seatsIncluded=2 and extra-seat sub quantity=1 → paidSeats=3 < memberCount=4.
+ // Helper: set up MSW mocks for a member-workspace downgrade scenario.
+ // The viewer (user-1) owns nothing and is a member of ws-2 owned by owner-2.
+ const setupDowngradeScenario = (opts: {
+ /** Unique member userIds returned by WorkspaceMember */
+ members: string[];
+ /** Pending invite count (Content-Range header) */
+ pendingInvites: number;
+ /** TransactionLog response — null means no subscription event */
+ transactionLog: object | null;
+ }) => {
server.use(
db.get("Workspace", ({ request }) => {
const url = new URL(request.url);
- // owned workspaces lookup for the viewer (user-1)
if (url.searchParams.get("userId") === "eq.user-1") {
return json([]);
}
- // owner's workspaces lookup used by countAllMembers
if (url.searchParams.get("userId") === "eq.owner-2") {
- return json([{ id: "ws-2" }, { id: "ws-3" }]);
+ return json([{ id: "ws-2" }]);
}
- // member workspace details lookup (by id in list)
return json([{ ...workspaceRow, id: "ws-2", userId: "owner-2" }]);
}),
db.get("WorkspaceMember", ({ request }) => {
const url = new URL(request.url);
- // memberships lookup: userId=eq.user-1
if (url.searchParams.get("userId") === "eq.user-1") {
return json([{ workspaceId: "ws-2", relation: "editors" }]);
}
- // countAllMembers lookup: workspaceId=in.(...)
- return json([
- { userId: "member-1" },
- { userId: "member-2" },
- { userId: "member-3" },
- ]);
+ return json(opts.members.map((id) => ({ userId: id })));
}),
db.head("Notification", () =>
- empty({ headers: { "Content-Range": "*/1" } })
- ),
- db.get("TransactionLog", () =>
- json({
- eventData: {
- data: { object: { items: { data: [{ quantity: 1 }] } } },
- },
+ empty({
+ headers: { "Content-Range": `*/${opts.pendingInvites}` },
})
- )
- );
-
+ ),
+ db.get("Product", () => json([{ id: "prod-seats" }])),
+ db.get("TransactionLog", () => json(opts.transactionLog))
+ );
+ };
+
+ // ---- extraSeats from subscription (quantity present) ----
+
+ test("downgraded when members > seatsIncluded + extraSeats (with subscription)", async () => {
+ // 3 members + 1 pending = 4 total, seatsIncluded=1, quantity=1 → paidSeats=2 < 4
+ setupDowngradeScenario({
+ members: ["m-1", "m-2", "m-3"],
+ pendingInvites: 1,
+ transactionLog: {
+ eventData: {
+ data: { object: { items: { data: [{ quantity: 1 }] } } },
+ },
+ },
+ });
+ const ctx = createContext();
+ ctx.getOwnerPlanFeatures = async () => ({
+ ...defaultPlanFeatures,
+ maxWorkspaces: 5,
+ seatsIncluded: 1,
+ });
+ const result = await findMany("user-1", ctx);
+ expect(result.find((w) => w.id === "ws-2")?.isDowngraded).toBe(true);
+ });
+
+ test("not downgraded when members === seatsIncluded + extraSeats (boundary with subscription)", async () => {
+ // 3 members, seatsIncluded=2, quantity=1 → paidSeats=3, 3 === 3
+ setupDowngradeScenario({
+ members: ["m-1", "m-2", "m-3"],
+ pendingInvites: 0,
+ transactionLog: {
+ eventData: {
+ data: { object: { items: { data: [{ quantity: 1 }] } } },
+ },
+ },
+ });
const ctx = createContext();
ctx.getOwnerPlanFeatures = async () => ({
...defaultPlanFeatures,
maxWorkspaces: 5,
seatsIncluded: 2,
});
-
const result = await findMany("user-1", ctx);
- const member = result.find((w) => w.id === "ws-2");
- expect(member?.isDowngraded).toBe(true);
+ expect(result.find((w) => w.id === "ws-2")?.isDowngraded).toBe(false);
+ });
+
+ test("not downgraded when members < seatsIncluded + extraSeats (well under with subscription)", async () => {
+ // 1 member, seatsIncluded=2, quantity=2 → paidSeats=4, 1 < 4
+ setupDowngradeScenario({
+ members: ["m-1"],
+ pendingInvites: 0,
+ transactionLog: {
+ eventData: {
+ data: { object: { items: { data: [{ quantity: 2 }] } } },
+ },
+ },
+ });
+ const ctx = createContext();
+ ctx.getOwnerPlanFeatures = async () => ({
+ ...defaultPlanFeatures,
+ maxWorkspaces: 5,
+ seatsIncluded: 2,
+ });
+ const result = await findMany("user-1", ctx);
+ expect(result.find((w) => w.id === "ws-2")?.isDowngraded).toBe(false);
+ });
+
+ test("not downgraded when extra seats save you from exceeding seatsIncluded", async () => {
+ // 3 members, seatsIncluded=2, quantity=2 → paidSeats=4, 3 < 4
+ setupDowngradeScenario({
+ members: ["m-1", "m-2", "m-3"],
+ pendingInvites: 0,
+ transactionLog: {
+ eventData: {
+ data: { object: { items: { data: [{ quantity: 2 }] } } },
+ },
+ },
+ });
+ const ctx = createContext();
+ ctx.getOwnerPlanFeatures = async () => ({
+ ...defaultPlanFeatures,
+ maxWorkspaces: 5,
+ seatsIncluded: 2,
+ });
+ const result = await findMany("user-1", ctx);
+ expect(result.find((w) => w.id === "ws-2")?.isDowngraded).toBe(false);
});
- test("returns member workspaces with isDowngraded=false when actualMembers <= paidSeats", async () => {
- // owner has workspaces plan, 1 non-owner member, seatsIncluded=2 → memberCount(1) < paidSeats(2).
- server.use(
- db.get("Workspace", ({ request }) => {
- const url = new URL(request.url);
- if (url.searchParams.get("userId") === "eq.user-1") {
- return json([]);
- }
- if (url.searchParams.get("userId") === "eq.owner-2") {
- return json([{ id: "ws-2" }]);
- }
- return json([{ ...workspaceRow, id: "ws-2", userId: "owner-2" }]);
- }),
- db.get("WorkspaceMember", ({ request }) => {
- const url = new URL(request.url);
- // memberships lookup: userId=eq.user-1
- if (url.searchParams.get("userId") === "eq.user-1") {
- return json([{ workspaceId: "ws-2", relation: "editors" }]);
- }
- // countAllMembers lookup: workspaceId=in.(...)
- return json([{ userId: "member-1" }]);
- }),
- db.head("Notification", () =>
- empty({ headers: { "Content-Range": "*/0" } })
- ),
- db.get("TransactionLog", () => json(null))
- );
+ // ---- extraSeats = null (no subscription event in TransactionLog) ----
+ test("not downgraded when members < seatsIncluded and extraSeats is null", async () => {
+ // 1 member, seatsIncluded=2, no subscription event → paidSeats=2, 1 < 2
+ setupDowngradeScenario({
+ members: ["m-1"],
+ pendingInvites: 0,
+ transactionLog: null,
+ });
const ctx = createContext();
ctx.getOwnerPlanFeatures = async () => ({
...defaultPlanFeatures,
maxWorkspaces: 5,
seatsIncluded: 2,
});
+ const result = await findMany("user-1", ctx);
+ expect(result.find((w) => w.id === "ws-2")?.isDowngraded).toBe(false);
+ });
+ test("not downgraded when members === seatsIncluded and extraSeats is null", async () => {
+ // 2 members, seatsIncluded=2, no subscription event → paidSeats=2, 2 === 2
+ setupDowngradeScenario({
+ members: ["m-1", "m-2"],
+ pendingInvites: 0,
+ transactionLog: null,
+ });
+ const ctx = createContext();
+ ctx.getOwnerPlanFeatures = async () => ({
+ ...defaultPlanFeatures,
+ maxWorkspaces: 5,
+ seatsIncluded: 2,
+ });
const result = await findMany("user-1", ctx);
- const member = result.find((w) => w.id === "ws-2");
- expect(member?.isDowngraded).toBe(false);
+ expect(result.find((w) => w.id === "ws-2")?.isDowngraded).toBe(false);
});
- test("returns isDowngraded=false when memberCount === seatsIncluded (boundary)", async () => {
- // Exactly seatsIncluded non-owner members: slots are full but not exceeded.
- // No extra-seat sub needed and no suspension should fire.
- server.use(
- db.get("Workspace", ({ request }) => {
- const url = new URL(request.url);
- if (url.searchParams.get("userId") === "eq.user-1") {
- return json([]);
- }
- if (url.searchParams.get("userId") === "eq.owner-2") {
- return json([{ id: "ws-2" }]);
- }
- return json([{ ...workspaceRow, id: "ws-2", userId: "owner-2" }]);
- }),
- db.get("WorkspaceMember", ({ request }) => {
- const url = new URL(request.url);
- if (url.searchParams.get("userId") === "eq.user-1") {
- return json([{ workspaceId: "ws-2", relation: "editors" }]);
- }
- // 2 members exactly filling seatsIncluded=2 (no extra sub).
- return json([{ userId: "member-1" }, { userId: "member-2" }]);
- }),
- db.head("Notification", () =>
- empty({ headers: { "Content-Range": "*/0" } })
- ),
- db.get("TransactionLog", () => json(null))
- );
+ test("downgraded when members > seatsIncluded and extraSeats is null", async () => {
+ // 3 members, seatsIncluded=2, no subscription event → paidSeats=2, 3 > 2
+ setupDowngradeScenario({
+ members: ["m-1", "m-2", "m-3"],
+ pendingInvites: 0,
+ transactionLog: null,
+ });
+ const ctx = createContext();
+ ctx.getOwnerPlanFeatures = async () => ({
+ ...defaultPlanFeatures,
+ maxWorkspaces: 5,
+ seatsIncluded: 2,
+ });
+ const result = await findMany("user-1", ctx);
+ expect(result.find((w) => w.id === "ws-2")?.isDowngraded).toBe(true);
+ });
+
+ // ---- pending invites count toward members ----
+ test("downgraded when members + pending > paidSeats", async () => {
+ // 2 members + 1 pending = 3 total, seatsIncluded=2, no extra seats → 3 > 2
+ setupDowngradeScenario({
+ members: ["m-1", "m-2"],
+ pendingInvites: 1,
+ transactionLog: null,
+ });
const ctx = createContext();
ctx.getOwnerPlanFeatures = async () => ({
...defaultPlanFeatures,
maxWorkspaces: 5,
seatsIncluded: 2,
});
+ const result = await findMany("user-1", ctx);
+ expect(result.find((w) => w.id === "ws-2")?.isDowngraded).toBe(true);
+ });
+ test("not downgraded when members + pending === paidSeats", async () => {
+ // 1 member + 1 pending = 2 total, seatsIncluded=2, no extra seats → 2 === 2
+ setupDowngradeScenario({
+ members: ["m-1"],
+ pendingInvites: 1,
+ transactionLog: null,
+ });
+ const ctx = createContext();
+ ctx.getOwnerPlanFeatures = async () => ({
+ ...defaultPlanFeatures,
+ maxWorkspaces: 5,
+ seatsIncluded: 2,
+ });
const result = await findMany("user-1", ctx);
- const member = result.find((w) => w.id === "ws-2");
- // memberCount(2) === paidSeats(2) → not downgraded.
- expect(member?.isDowngraded).toBe(false);
+ expect(result.find((w) => w.id === "ws-2")?.isDowngraded).toBe(false);
});
});
diff --git a/packages/project/src/db/workspace.ts b/packages/project/src/db/workspace.ts
index e16c9db815..5274850412 100644
--- a/packages/project/src/db/workspace.ts
+++ b/packages/project/src/db/workspace.ts
@@ -11,7 +11,7 @@ import {
NOTIFICATION_TTL_MS,
} from "../shared/notification-schema";
import { create as createNotification } from "./notification";
-import { getPaidSeats } from "@webstudio-is/plans/index.server";
+import { getExtraPaidSeats } from "@webstudio-is/plans/index.server";
export type Workspace = Database["public"]["Tables"]["Workspace"]["Row"];
@@ -253,7 +253,7 @@ export const findMany = async (userId: string, context: AppContext) => {
}
const [memberCount, extraSeats] = await Promise.all([
countAllMembers(ownerId, context),
- getPaidSeats(ownerId, context),
+ getExtraPaidSeats(ownerId, context),
]);
// seatsIncluded is the number of non-owner member slots included in
// the plan. The owner is not counted — consistent with the billing
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 5643fe4364..c1a56af613 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -458,6 +458,9 @@ importers:
html-tags:
specifier: ^4.0.0
version: 4.0.0
+ msw:
+ specifier: ^2.13.2
+ version: 2.13.2(@types/[email protected])([email protected])
react-router-dom:
specifier: ^6.30.0