feat: add a Transfer ownership action to the Members roster for the workspace owner, with an in-app confirmation and the recent sign-in prompt, and have the transfer decided in one transaction against the locked workspace row so the new owner is a current member in good standing, holds no roles or restricted access, and the previous owner keeps an Admin role assignment, documented in the team roles guide and the API reference

This commit is contained in:
Matthew Meszaros
2026-11-10 19:23:44 +01:00
parent 28447fedae
commit d0ab6f96e6
8 changed files with 289 additions and 46 deletions
@@ -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`
+8
View File
@@ -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.
</Fold>
+13 -11
View File
@@ -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
@@ -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)
}
})
}
+61 -15
View File
@@ -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(&currentOwnerID)
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
}
+49 -11
View File
@@ -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<OrganizationMember | null>(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() {
<Th className="md:w-44">Role</Th>
<Th className="md:w-48">Access</Th>
<Th className="w-40 hidden md:table-cell">Joined</Th>
<th className="w-12 px-3 py-2"></th>
<th className={`${ownsWorkspace ? "w-20" : "w-12"} px-3 py-2`}></th>
</tr>
</thead>
<tbody>
@@ -307,16 +331,30 @@ export default function MembersSettingsPage() {
: "—"}
</td>
<td className="px-3">
{access.canManage && !isOwner && !isSelf && (
<button
type="button"
onClick={() => doRemove(m.user_id, email)}
aria-label="Remove member"
className="size-6 rounded text-slate-400 hover:text-red-600 hover:bg-red-50 inline-flex items-center justify-center transition-colors opacity-100 md:opacity-0 md:group-hover:opacity-100"
>
<TrashIcon className="w-3 h-3" />
</button>
)}
<div className="flex items-center justify-end gap-1">
{ownsWorkspace && !isOwner && !isSelf && (
<button
type="button"
onClick={() => doTransfer(m.user_id, email)}
disabled={transferOwnership.isPending}
aria-label="Transfer ownership"
title="Transfer ownership"
className="size-6 rounded text-slate-400 hover:text-sky-700 hover:bg-sky-50 inline-flex items-center justify-center transition-colors opacity-100 md:opacity-0 md:group-hover:opacity-100 focus-visible:opacity-100 disabled:opacity-50"
>
<KeyRoundIcon className="w-3 h-3" />
</button>
)}
{access.canManage && !isOwner && !isSelf && (
<button
type="button"
onClick={() => doRemove(m.user_id, email)}
aria-label="Remove member"
className="size-6 rounded text-slate-400 hover:text-red-600 hover:bg-red-50 inline-flex items-center justify-center transition-colors opacity-100 md:opacity-0 md:group-hover:opacity-100"
>
<TrashIcon className="w-3 h-3" />
</button>
)}
</div>
</td>
</tr>
);
@@ -1,10 +1,10 @@
import Request from "../../Request";
export default async function transferOwnership(data: { user_id: string }): Promise<void> {
export default async function transferOwnership(newOwnerUserId: string): Promise<void> {
return await Request<void>({
method: "POST",
url: `/organization/transfer-ownership`,
data,
data: { new_owner_user_id: newOwnerUserId },
authorization: true,
})
}
@@ -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"],
})
}
})