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: seats management (#5707)

Oleg Isonend8157f3cb6f1
diff --git a/apps/builder/app/services/workspace-router.server.ts b/apps/builder/app/services/workspace-router.server.ts
index efbc8623f9..4eb261b68c 100644
--- a/apps/builder/app/services/workspace-router.server.ts
+++ b/apps/builder/app/services/workspace-router.server.ts
@@ -288,13 +288,10 @@ export const workspaceRouter = router({
try {
await workspaceApi.removeMember(input, ctx);
- // Release the seat immediately on removal.
- await syncOwnerSeats(input.workspaceId, ctx).catch((error) => {
- console.error(
- "[payment-worker] Failed to release seat on member removal:",
- error
- );
- });
+ // 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) {
diff --git a/packages/prisma-client/prisma/schema.prisma b/packages/prisma-client/prisma/schema.prisma
index 3cf95a6bb9..be8c6d80bb 100644
--- a/packages/prisma-client/prisma/schema.prisma
+++ b/packages/prisma-client/prisma/schema.prisma
@@ -131,8 +131,6 @@ view UserProduct {
customerId String?
// Easier to debug
customerEmail String?
- // Seat quantity from Stripe subscription (Team plan)
- seatQuantity Int?
@@unique([userId, productId])
}
diff --git a/packages/project/src/db/workspace.test.ts b/packages/project/src/db/workspace.test.ts
index 3d419899e2..b7d4d6f482 100644
--- a/packages/project/src/db/workspace.test.ts
+++ b/packages/project/src/db/workspace.test.ts
@@ -218,6 +218,141 @@ describe("findMany (msw)", () => {
const member = result.find((w) => w.id === "ws-2");
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.
+ 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" }]);
+ }
+ // 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" },
+ ]);
+ }),
+ db.head("Notification", () =>
+ empty({ headers: { "Content-Range": "*/1" } })
+ ),
+ db.get("TransactionLog", () =>
+ json({
+ 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);
+ });
+
+ 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))
+ );
+
+ 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);
+ });
+
+ 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))
+ );
+
+ 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);
+ });
});
// ---------------------------------------------------------------------------
@@ -235,8 +370,8 @@ describe("countAllMembers (msw)", () => {
test("returns sum of active members + pending invites", async () => {
server.use(
db.get("Workspace", () => json([workspaceRow])),
- db.head("WorkspaceMember", () =>
- empty({ headers: { "Content-Range": "*/3" } })
+ db.get("WorkspaceMember", () =>
+ json([{ userId: "m1" }, { userId: "m2" }, { userId: "m3" }])
),
db.head("Notification", () =>
empty({ headers: { "Content-Range": "*/2" } })
@@ -246,6 +381,22 @@ describe("countAllMembers (msw)", () => {
const count = await countAllMembers("user-1", createContext());
expect(count).toBe(5);
});
+
+ test("deduplicates same member across multiple workspaces", async () => {
+ // "user-a" appears in two workspaces — should count as 1, not 2.
+ server.use(
+ db.get("Workspace", () => json([{ id: "ws-1" }, { id: "ws-2" }])),
+ db.get("WorkspaceMember", () =>
+ json([{ userId: "user-a" }, { userId: "user-a" }])
+ ),
+ db.head("Notification", () =>
+ empty({ headers: { "Content-Range": "*/0" } })
+ )
+ );
+
+ const count = await countAllMembers("user-1", createContext());
+ expect(count).toBe(1);
+ });
});
// ---------------------------------------------------------------------------
diff --git a/packages/project/src/db/workspace.ts b/packages/project/src/db/workspace.ts
index 26a798100f..e16c9db815 100644
--- a/packages/project/src/db/workspace.ts
+++ b/packages/project/src/db/workspace.ts
@@ -11,6 +11,7 @@ import {
NOTIFICATION_TTL_MS,
} from "../shared/notification-schema";
import { create as createNotification } from "./notification";
+import { getPaidSeats } from "@webstudio-is/plans/index.server";
export type Workspace = Database["public"]["Tables"]["Workspace"]["Row"];
@@ -18,8 +19,11 @@ export type WorkspaceWithRelation = Workspace & {
/** The current user's relation to the workspace: "own" for owners */
role: Role | "own";
/**
- * True when the workspace owner's plan no longer supports workspace features
- * (maxWorkspaces <= 1). Members lose project access but workspace data stays intact.
+ * True when the workspace owner has lost workspace access for members.
+ * Fires when either:
+ * - owner's plan no longer grants workspaces (`maxWorkspaces <= 1`), or
+ * - `actualMembers > paidSeats` (owner has more members than paid seats).
+ * Members lose project access but workspace data stays intact.
*/
isDowngraded: boolean;
};
@@ -231,22 +235,35 @@ export const findMany = async (userId: string, context: AppContext) => {
throw memberOf.error;
}
- // For member workspaces, check if the owner's plan still supports workspace features.
- // Collect unique owner IDs and batch-check their plans.
+ // For member workspaces, check whether the owner still grants workspace access.
+ // Two conditions downgrade: plan no longer includes workspaces
+ // (`maxWorkspaces <= 1`), or owner has more members than paid seats
+ // (`actualMembers > paidSeats`). Collect unique owner IDs and batch-check.
const ownerIds = [...new Set(memberOf.data.map((w) => w.userId))];
const downgradedOwners = new Set<string>();
if (ownerIds.length > 0) {
- // Use allSettled so a single owner's plan-check failure doesn't
+ // Use allSettled so a single owner's check failure doesn't
// break the entire workspace list. Failed checks default to not-downgraded.
- const plans = await Promise.allSettled(
+ const checks = await Promise.allSettled(
ownerIds.map(async (ownerId) => {
const plan = await context.getOwnerPlanFeatures(ownerId);
- return { ownerId, maxWorkspaces: plan.maxWorkspaces };
+ if (plan.maxWorkspaces <= 1) {
+ return { ownerId, isDowngraded: true };
+ }
+ const [memberCount, extraSeats] = await Promise.all([
+ countAllMembers(ownerId, context),
+ getPaidSeats(ownerId, context),
+ ]);
+ // seatsIncluded is the number of non-owner member slots included in
+ // the plan. The owner is not counted — consistent with the billing
+ // formula used at invite time and at invoice renewal.
+ const paidSeats = plan.seatsIncluded + (extraSeats ?? 0);
+ return { ownerId, isDowngraded: memberCount > paidSeats };
})
);
- for (const result of plans) {
- if (result.status === "fulfilled" && result.value.maxWorkspaces <= 1) {
+ for (const result of checks) {
+ if (result.status === "fulfilled" && result.value.isDowngraded) {
downgradedOwners.add(result.value.ownerId);
}
}
@@ -314,9 +331,11 @@ export const countAllMembers = async (
const workspaceIds = workspaces.data.map((w) => w.id);
const [membersResult, pendingResult] = await Promise.all([
+ // Fetch all userIds so we can deduplicate — the same person may be a
+ // member of several of the owner's workspaces but counts as one seat.
context.postgrest.client
.from("WorkspaceMember")
- .select("userId", { count: "exact", head: true })
+ .select("userId")
.in("workspaceId", workspaceIds)
.is("removedAt", null),
context.postgrest.client
@@ -324,11 +343,7 @@ export const countAllMembers = async (
.select("id", { count: "exact", head: true })
.eq("type", "workspaceInvite")
.eq("senderId", userId)
- .eq("status", "pending")
- .gte(
- "createdAt",
- new Date(Date.now() - NOTIFICATION_TTL_MS).toISOString()
- ),
+ .eq("status", "pending"),
]);
if (membersResult.error) {
@@ -338,12 +353,10 @@ export const countAllMembers = async (
throw pendingResult.error;
}
- // Avoid double-counting: a pending invite recipient who is also already
- // a member would be in both sets. This is theoretically impossible
- // (addMember guards against it) but we subtract to be safe by using the
- // total of accepted members + non-accepted pending invites.
- // Simple approximation: accepted + pending counts (small overlap risk is acceptable).
- return (membersResult.count ?? 0) + (pendingResult.count ?? 0);
+ const uniqueMembers = new Set(
+ (membersResult.data ?? []).map((row) => row.userId)
+ );
+ return uniqueMembers.size + (pendingResult.count ?? 0);
};
export const addMember = async (