diff --git a/docs/content/docs/api/reference/account-org.mdx b/docs/content/docs/api/reference/account-org.mdx index ab1883147..bf92dbdaa 100644 --- a/docs/content/docs/api/reference/account-org.mdx +++ b/docs/content/docs/api/reference/account-org.mdx @@ -1643,9 +1643,9 @@ Auth: Session only (not available to API keys). **Org permission** `manage_team` `POST /organization/transfer-ownership` -Transfers organization ownership to another member. +Transfers organization ownership to another member. The caller must be the current owner and becomes an Admin; the new owner's roles and restricted access are cleared. -Auth: Session only (not available to API keys). **Org permission** `transfer_ownership`. +Auth: Session only (not available to API keys). **Org permission** `transfer_ownership`. Requires a recent confirmation (`POST /auth/reauth`); without one it answers `403 reauth_required`. #### Request body @@ -1663,6 +1663,14 @@ Auth: Session only (not available to API keys). **Org permission** `transfer_own { "message": "ownership transferred" } ``` +#### Errors + +| Status | When | +|--------|------| +| `400` | `new_owner_user_id` is the caller, or is not a member of the organization. | +| `403` | The caller is not the organization's owner. | +| `409` | The member's account is scheduled for deletion or suspended. | + ### Upload organization avatar `POST /organization/avatar` diff --git a/docs/content/docs/guides/team-roles.mdx b/docs/content/docs/guides/team-roles.mdx index b46596c68..baafc87c2 100644 --- a/docs/content/docs/guides/team-roles.mdx +++ b/docs/content/docs/guides/team-roles.mdx @@ -95,6 +95,14 @@ Each row shows email, role, access, and join date, with your own row tagged "you To remove someone, hover (or tap) their row and click the remove icon. **You cannot remove the owner or yourself.** To leave a workspace you own, transfer ownership first. +### Transfer ownership + +A workspace has exactly one owner. The owner sees a key icon on every other member's row: click it, confirm, and that member becomes the owner. You are asked to sign in again first if you have not done so recently. The new owner must already be a member, so invite them and wait for them to accept before handing over. + +The handover takes effect at once. The new owner gets full control, including billing, deleting the workspace and transferring ownership again, and any roles or restricted access they held are cleared. You stay in the workspace as an Admin, and only the new owner can hand ownership back. Mailboxes, campaigns, contacts, warmup, API keys and a link to Warmbly Cloud are untouched: they belong to the workspace, not to its owner. + +A member whose account is scheduled for deletion or suspended cannot take ownership. Only the owner can transfer, and the action is not available to API keys. + Removal applies to someone who is signed in right now. Their open dashboard loses the workspace on its next request and its live updates stop, and they are asked to pick another workspace they belong to. Apps they authorized in the workspace are disconnected. Nothing they created is removed with them: mailboxes, contacts, campaigns and API keys belong to the workspace, so revoke their keys under **API keys** if those should go too. Realtime channels refresh access at least every 30 seconds and before delivering with an expired authorization check, even if a change event is missed. A changed role or a new owner reaches open dashboards' live updates without a reload. diff --git a/internal/app/organization/service.go b/internal/app/organization/service.go index f604886fa..1aa071894 100644 --- a/internal/app/organization/service.go +++ b/internal/app/organization/service.go @@ -1227,22 +1227,24 @@ func (s *organizationService) TransferOwnership(ctx context.Context, orgID, acto return errx.New(errx.Forbidden, "only the workspace owner can transfer ownership") } - // Verify new owner is a member - member, err := s.orgRepo.GetMember(ctx, orgID, newOwnerUserID) - if err != nil { - errs.CaptureException(err) - return errx.New(errx.Internal, "failed to verify membership") - } - if member == nil { - return errx.New(errx.BadRequest, "new owner must be a member of the organization") + if newOwnerUserID == actorUserID { + return errx.New(errx.BadRequest, "you already own this workspace") } - if err := s.orgRepo.TransferOwnership(ctx, orgID, newOwnerUserID); err != nil { + // The repository decides again against the locked row, so two requests cannot both move it. + switch err := s.orgRepo.TransferOwnership(ctx, orgID, actorUserID, newOwnerUserID); { + case err == nil: + return nil + case errors.Is(err, repository.ErrOwnershipNotHeld): + return errx.New(errx.Forbidden, "only the workspace owner can transfer ownership") + case errors.Is(err, repository.ErrNewOwnerNotMember): + return errx.New(errx.BadRequest, "new owner must be a member of the organization") + case errors.Is(err, repository.ErrNewOwnerUnavailable): + return errx.New(errx.Conflict, "that member's account cannot take ownership right now") + default: errs.CaptureException(err) return errx.New(errx.Internal, "failed to transfer ownership") } - - return nil } // HasPermission checks if a user has a specific permission diff --git a/internal/repository/ownership_transfer_live_test.go b/internal/repository/ownership_transfer_live_test.go new file mode 100644 index 000000000..f604dbb1f --- /dev/null +++ b/internal/repository/ownership_transfer_live_test.go @@ -0,0 +1,143 @@ +package repository + +import ( + "context" + "errors" + "testing" + + "github.com/google/uuid" + + "github.com/warmbly/warmbly/internal/models" +) + +// A workspace has exactly one owner, a member, unscoped, moved only by the owner. +// +// WARMBLY_TEST_DB=postgres://warmbly:warmbly@localhost:15432/warmbly_dev?sslmode=disable \ +// go test ./internal/repository/ -run LiveOwnershipTransfer -v +func TestLiveOwnershipTransfer(t *testing.T) { + _, pool := liveContactDB(t) + requireSchemaVersion(t, pool, 278) + ctx := context.Background() + repo := NewOrganizationRepository(pool) + + owner, member, outsider, leaving, banned := uuid.New(), uuid.New(), uuid.New(), uuid.New(), uuid.New() + org := uuid.New() + admin, manager := uuid.New(), uuid.New() + folder := uuid.New() + exec := func(sql string, args ...any) { + t.Helper() + if _, err := pool.Exec(ctx, sql, args...); err != nil { + t.Fatalf("fixture %q: %v", sql[:min(60, len(sql))], err) + } + } + t.Cleanup(func() { + c := context.Background() + _, _ = pool.Exec(c, `DELETE FROM organizations WHERE id = $1`, org) + _, _ = pool.Exec(c, `DELETE FROM users WHERE id = ANY($1)`, []uuid.UUID{owner, member, outsider, leaving, banned}) + }) + for _, u := range []uuid.UUID{owner, member, outsider, leaving, banned} { + exec(`INSERT INTO users (id, first_name, last_name, email, password_hash) VALUES ($1, 'Owner', 'Live', $2, 'x')`, u, "own-"+u.String()[:8]+"@test.local") + } + exec(`UPDATE users SET deletion_scheduled_at = NOW(), deletion_scheduled_for = NOW() + INTERVAL '7 days' WHERE id = $1`, leaving) + exec(`UPDATE users SET banned_at = NOW() WHERE id = $1`, banned) + exec(`INSERT INTO organizations (id, name, slug, owner_user_id) VALUES ($1, 'Ownership', $2, $3)`, org, "own-"+org.String()[:8], owner) + adminMask := int64(int16(models.GetRolePermissions(models.RoleAdmin))) + managerMask := int64(int16(models.GetRolePermissions(models.RoleManager))) + exec(`INSERT INTO organization_roles (id, organization_id, name, permissions) VALUES ($1, $2, 'Admin', $3)`, admin, org, adminMask) + exec(`INSERT INTO organization_roles (id, organization_id, name, permissions) VALUES ($1, $2, 'ManagerOwn', $3)`, manager, org, managerMask) + exec(`INSERT INTO organization_members (organization_id, user_id, role, permissions, accepted_at) VALUES ($1, $2, 'owner', -1, NOW())`, org, owner) + for _, u := range []uuid.UUID{member, leaving, banned} { + exec(`INSERT INTO organization_members (organization_id, user_id, role, role_id, permissions, accepted_at) VALUES ($1, $2, 'ManagerOwn', $3, $4, NOW())`, org, u, manager, managerMask) + exec(`INSERT INTO organization_member_roles (organization_id, user_id, role_id) VALUES ($1, $2, $3)`, org, u, manager) + } + exec(`INSERT INTO folders (id, organization_id, title, color, position) VALUES ($1, $2, 'Client', '#000000', 0)`, folder, org) + if err := repo.SetMemberAccess(ctx, org, member, &models.MemberAccess{Scope: models.AccessScopeRestricted, FolderIDs: []uuid.UUID{folder}}, owner); err != nil { + t.Fatalf("restrict member: %v", err) + } + + ownerOf := func() uuid.UUID { + t.Helper() + var id uuid.UUID + if err := pool.QueryRow(ctx, `SELECT owner_user_id FROM organizations WHERE id = $1`, org).Scan(&id); err != nil { + t.Fatalf("read owner: %v", err) + } + return id + } + owners := func() int { + t.Helper() + var n int + if err := pool.QueryRow(ctx, `SELECT COUNT(*) FROM organization_members WHERE organization_id = $1 AND role = 'owner'`, org).Scan(&n); err != nil { + t.Fatalf("count owners: %v", err) + } + return n + } + + for name, tc := range map[string]struct { + actor, target uuid.UUID + want error + }{ + "a member who is not the owner": {member, member, ErrOwnershipNotHeld}, + "an account outside the roster": {owner, outsider, ErrNewOwnerNotMember}, + "an unknown account": {owner, uuid.New(), ErrNewOwnerNotMember}, + "an account leaving": {owner, leaving, ErrNewOwnerUnavailable}, + "a banned account": {owner, banned, ErrNewOwnerUnavailable}, + "the owner themselves": {owner, owner, ErrNewOwnerUnavailable}, + } { + t.Run("refuses "+name, func(t *testing.T) { + if err := repo.TransferOwnership(ctx, org, tc.actor, tc.target); !errors.Is(err, tc.want) { + t.Fatalf("err = %v, want %v", err, tc.want) + } + if got := ownerOf(); got != owner || owners() != 1 { + t.Fatalf("owner = %s with %d owner rows, want %s with 1", got, owners(), owner) + } + }) + } + + if err := repo.TransferOwnership(ctx, org, owner, member); err != nil { + t.Fatalf("transfer: %v", err) + } + if got := ownerOf(); got != member || owners() != 1 { + t.Fatalf("owner = %s with %d owner rows, want %s with 1", got, owners(), member) + } + + t.Run("the new owner is unscoped and holds no role", func(t *testing.T) { + m, err := repo.GetMember(ctx, org, member) + if err != nil || m == nil { + t.Fatalf("get member: %v", err) + } + if !m.IsOwner() || m.RoleID != nil || m.AccessScope != models.AccessScopeWorkspace { + t.Fatalf("member = role %q, role_id %v, scope %q", m.Role, m.RoleID, m.AccessScope) + } + var roles, grants int + if err := pool.QueryRow(ctx, ` + SELECT (SELECT COUNT(*) FROM organization_member_roles WHERE organization_id = $1 AND user_id = $2), + (SELECT COUNT(*) FROM organization_member_campaign_access WHERE organization_id = $1 AND user_id = $2)`, + org, member).Scan(&roles, &grants); err != nil { + t.Fatalf("count: %v", err) + } + if roles != 0 || grants != 0 { + t.Fatalf("roles = %d, grants = %d; want 0/0", roles, grants) + } + }) + + t.Run("the previous owner is an Admin through a role assignment", func(t *testing.T) { + m, err := repo.GetMember(ctx, org, owner) + if err != nil || m == nil { + t.Fatalf("get member: %v", err) + } + if m.IsOwner() || m.RoleID == nil || *m.RoleID != admin || int64(int16(m.Permissions)) != adminMask { + t.Fatalf("member = role %q, role_id %v, permissions %d", m.Role, m.RoleID, m.Permissions) + } + var assigned bool + if err := pool.QueryRow(ctx, `SELECT EXISTS (SELECT 1 FROM organization_member_roles WHERE organization_id = $1 AND user_id = $2 AND role_id = $3)`, + org, owner, admin).Scan(&assigned); err != nil || !assigned { + t.Fatalf("admin assignment = %v, %v", assigned, err) + } + }) + + t.Run("the previous owner cannot move it again", func(t *testing.T) { + if err := repo.TransferOwnership(ctx, org, owner, owner); !errors.Is(err, ErrOwnershipNotHeld) { + t.Fatalf("err = %v, want %v", err, ErrOwnershipNotHeld) + } + }) +} diff --git a/internal/repository/pg_organization.go b/internal/repository/pg_organization.go index 4741716c4..51d70f8e8 100644 --- a/internal/repository/pg_organization.go +++ b/internal/repository/pg_organization.go @@ -89,7 +89,7 @@ type OrganizationRepository interface { DeleteExpiredInvitations(ctx context.Context) error // Ownership transfer - TransferOwnership(ctx context.Context, orgID, newOwnerUserID uuid.UUID) error + TransferOwnership(ctx context.Context, orgID, currentOwnerUserID, newOwnerUserID uuid.UUID) error // Resource counts GetCampaignCounts(ctx context.Context, orgID uuid.UUID) (total int, active int, err error) @@ -652,26 +652,71 @@ func (r *organizationRepository) DeleteExpiredInvitations(ctx context.Context) e return err } -// TransferOwnership transfers organization ownership to a new user -func (r *organizationRepository) TransferOwnership(ctx context.Context, orgID, newOwnerUserID uuid.UUID) error { +// ErrOwnershipNotHeld means the caller does not own the workspace when the transfer is written. +var ErrOwnershipNotHeld = errors.New("caller does not own the workspace") + +// ErrNewOwnerNotMember means the proposed owner has no membership in the workspace. +var ErrNewOwnerNotMember = errors.New("new owner is not a member of the workspace") + +// ErrNewOwnerUnavailable means the proposed owner's account cannot take a workspace. +var ErrNewOwnerUnavailable = errors.New("new owner's account cannot take a workspace") + +// TransferOwnership moves ownership from currentOwnerUserID to another member +// in one transaction, decided against the locked organization row. +func (r *organizationRepository) TransferOwnership(ctx context.Context, orgID, currentOwnerUserID, newOwnerUserID uuid.UUID) error { tx, err := r.db.Begin(ctx) if err != nil { return err } - defer tx.Rollback(ctx) + defer tx.Rollback(ctx) //nolint:errcheck - // Get current owner - var currentOwnerID uuid.UUID - err = tx.QueryRow(ctx, `SELECT owner_user_id FROM organizations WHERE id = $1`, orgID).Scan(¤tOwnerID) + var owner uuid.UUID + err = tx.QueryRow(ctx, `SELECT owner_user_id FROM organizations WHERE id = $1 FOR UPDATE`, orgID).Scan(&owner) if err != nil { return err } + if owner != currentOwnerUserID { + return ErrOwnershipNotHeld + } + if newOwnerUserID == owner { + return ErrNewOwnerUnavailable + } - // Update organization owner - _, err = tx.Exec(ctx, `UPDATE organizations SET owner_user_id = $2, updated_at = $3 WHERE id = $1`, orgID, newOwnerUserID, time.Now()) + // An account deletion takes the workspaces it owns with it, and a banned account cannot run one. + var available bool + err = tx.QueryRow(ctx, `SELECT banned_at IS NULL AND deletion_scheduled_for IS NULL FROM users WHERE id = $1 FOR SHARE`, newOwnerUserID).Scan(&available) + if errors.Is(err, pgx.ErrNoRows) { + return ErrNewOwnerNotMember + } if err != nil { return err } + if !available { + return ErrNewOwnerUnavailable + } + + // Owner is a membership status, not a role: role_id must be NULL so role + // edits can never write through onto the owner row, and it is never scoped. + tag, err := tx.Exec(ctx, ` + UPDATE organization_members SET role = 'owner', role_id = NULL, permissions = $3, access_scope = $4 + WHERE organization_id = $1 AND user_id = $2`, + orgID, newOwnerUserID, models.RolePermissions[models.RoleOwner], models.AccessScopeWorkspace) + if err != nil { + return err + } + if tag.RowsAffected() == 0 { + return ErrNewOwnerNotMember + } + if _, err = tx.Exec(ctx, `DELETE FROM organization_member_roles WHERE organization_id = $1 AND user_id = $2`, orgID, newOwnerUserID); err != nil { + return err + } + if err = writeMemberGrants(ctx, tx, orgID, newOwnerUserID, &models.MemberAccess{Scope: models.AccessScopeWorkspace}, uuid.Nil); err != nil { + return err + } + + if _, err = tx.Exec(ctx, `UPDATE organizations SET owner_user_id = $2, updated_at = NOW() WHERE id = $1`, orgID, newOwnerUserID); err != nil { + return err + } // Re-home the old owner onto the org's Admin role row when one exists // (roles are data); otherwise fall back to a detached Admin-mask member. @@ -683,15 +728,16 @@ func (r *organizationRepository) TransferOwnership(ctx context.Context, orgID, n FROM (SELECT 1) one LEFT JOIN organization_roles r ON r.organization_id = $1 AND r.name = 'Admin' WHERE om.organization_id = $1 AND om.user_id = $2`, - orgID, currentOwnerID, models.RolePermissions[models.RoleAdmin]) + orgID, owner, models.RolePermissions[models.RoleAdmin]) if err != nil { return err } - - // Owner is a membership status, not a role: role_id must be NULL so role - // edits can never write through onto the owner row. - _, err = tx.Exec(ctx, `UPDATE organization_members SET role = 'owner', role_id = NULL, permissions = $3 WHERE organization_id = $1 AND user_id = $2`, - orgID, newOwnerUserID, models.RolePermissions[models.RoleOwner]) + // The assignment row keeps the snapshot above true through a later recompute. + _, err = tx.Exec(ctx, ` + INSERT INTO organization_member_roles (organization_id, user_id, role_id) + SELECT om.organization_id, om.user_id, om.role_id FROM organization_members om + WHERE om.organization_id = $1 AND om.user_id = $2 AND om.role_id IS NOT NULL + ON CONFLICT DO NOTHING`, orgID, owner) if err != nil { return err } diff --git a/web/src/app/app/settings/members/page.tsx b/web/src/app/app/settings/members/page.tsx index 640a713d9..b76b191b4 100644 --- a/web/src/app/app/settings/members/page.tsx +++ b/web/src/app/app/settings/members/page.tsx @@ -11,6 +11,7 @@ import { AnimatePresence } from "framer-motion"; import { CheckIcon, CopyIcon, + KeyRoundIcon, Loader2Icon, MailIcon, SendIcon, @@ -28,6 +29,7 @@ import useInviteMember from "@/lib/api/hooks/app/organizations/useInviteMember"; import useRemoveMember from "@/lib/api/hooks/app/organizations/useRemoveMember"; import useCancelInvitation from "@/lib/api/hooks/app/organizations/useCancelInvitation"; import useUpdateMemberRole from "@/lib/api/hooks/app/organizations/useUpdateMemberRole"; +import useTransferOwnership from "@/lib/api/hooks/app/organizations/useTransferOwnership"; import useRoles from "@/lib/api/hooks/app/organizations/useRoles"; import useAuthConfig from "@/lib/api/hooks/auth/useAuthConfig"; import type OrganizationRole from "@/lib/api/models/app/organizations/OrganizationRole"; @@ -65,6 +67,7 @@ export default function MembersSettingsPage() { const removeMember = useRemoveMember(); const cancelInvite = useCancelInvitation(); const updateRole = useUpdateMemberRole(); + const transferOwnership = useTransferOwnership(); const setAccess = useSetMemberAccess(); const [editingAccess, setEditingAccess] = React.useState(null); const customRoles = useRoles(); @@ -74,6 +77,8 @@ export default function MembersSettingsPage() { const currentOrg = useAppStore((s) => s.currentOrganization); const memberList = members.data ?? []; + // Only the owner can hand the workspace over, whatever a custom role holds. + const ownsWorkspace = currentOrg?.role === "owner"; const inviteList = invites.data ?? []; const expiredCount = inviteList.filter((i) => i.expired).length; @@ -90,6 +95,25 @@ export default function MembersSettingsPage() { } }); } + // Ownership is the server's to move, so the roster waits for its answer. + function doTransfer(id: string, label: string) { + confirm?.show( + `Make ${label} the owner of ${currentOrg?.name || "this workspace"}? They get full control, including billing, ownership and deleting the workspace. You stay a member as an Admin, and only they can hand ownership back.`, + async () => { + try { + await toast.promise(transferOwnership.mutateAsync(id), { + loading: "Transferring ownership…", + success: "Ownership transferred", + error: (e: AppError) => buildError(e), + }); + } catch { + /* surfaced */ + } + }, + undefined, + { title: "Transfer ownership?", confirmLabel: "Transfer ownership" }, + ); + } function doCancelInvite(id: string) { confirm?.show(`Cancel this invitation?`, async () => { try { @@ -243,7 +267,7 @@ export default function MembersSettingsPage() { Role Access Joined - + @@ -307,16 +331,30 @@ export default function MembersSettingsPage() { : "—"} - {access.canManage && !isOwner && !isSelf && ( - - )} +
+ {ownsWorkspace && !isOwner && !isSelf && ( + + )} + {access.canManage && !isOwner && !isSelf && ( + + )} +
); diff --git a/web/src/lib/api/client/app/organizations/transferOwnership.ts b/web/src/lib/api/client/app/organizations/transferOwnership.ts index 1b2f27e20..967d8e112 100644 --- a/web/src/lib/api/client/app/organizations/transferOwnership.ts +++ b/web/src/lib/api/client/app/organizations/transferOwnership.ts @@ -1,10 +1,10 @@ import Request from "../../Request"; -export default async function transferOwnership(data: { user_id: string }): Promise { +export default async function transferOwnership(newOwnerUserId: string): Promise { return await Request({ method: "POST", url: `/organization/transfer-ownership`, - data, + data: { new_owner_user_id: newOwnerUserId }, authorization: true, }) } diff --git a/web/src/lib/api/hooks/app/organizations/useTransferOwnership.ts b/web/src/lib/api/hooks/app/organizations/useTransferOwnership.ts index fcc22edd3..b0086bbc6 100644 --- a/web/src/lib/api/hooks/app/organizations/useTransferOwnership.ts +++ b/web/src/lib/api/hooks/app/organizations/useTransferOwnership.ts @@ -5,13 +5,11 @@ export default function useTransferOwnership() { const queryClient = useQueryClient(); return useMutation({ - mutationFn: (data: { user_id: string }) => transferOwnership(data), + mutationFn: (newOwnerUserId: string) => transferOwnership(newOwnerUserId), + // The workspace list carries the caller's own role, so it is refetched with the roster. onSuccess: () => { queryClient.invalidateQueries({ - queryKey: ["organizations", "members"], - }) - queryClient.invalidateQueries({ - queryKey: ["organizations", "current"], + queryKey: ["organizations"], }) } })