Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

83.2 KB
Raw Blame
import { create } from "@bufbuild/protobuf";
import dayjs from "dayjs";
import {
  Building2,
  ChevronDown,
  ChevronRight,
  Pencil,
  Plus,
  ShieldUser,
  Trash2,
  Users,
  X,
} from "lucide-react";
import React, {
  useCallback,
  useEffect,
  useMemo,
  useRef,
  useState,
} from "react";
import { useTranslation } from "react-i18next";
import { v4 as uuidv4 } from "uuid";
import { WORKSPACE_ROUTE_GROUPS } from "@/app/router";
import { AccountMultiSelect } from "@/components/AccountMultiSelect";
import { AccountTypeBadge } from "@/components/AccountTypeBadge";
import { DatabaseResourceSelector as DatabaseResourceSelectorComponent } from "@/components/DatabaseResourceSelector";
import { ExprEditor, type OptionConfig } from "@/components/ExprEditor";
import { FeatureBadge } from "@/components/FeatureBadge";
import { HumanizeTs } from "@/components/HumanizeTs";
import { LearnMoreLink } from "@/components/LearnMoreLink";
import { PermissionGuard } from "@/components/PermissionGuard";
import {
  ProjectPageInfo,
  ProjectPageLayout,
  ProjectPageToolbar,
} from "@/components/ProjectPageLayout";
import { RoleSelect } from "@/components/RoleSelect";
import { DirectExecutionCallout } from "@/components/role-grant/DirectExecutionCallout";
import { DirectExecutionField } from "@/components/role-grant/DirectExecutionField";
import { RoleDescription } from "@/components/role-grant/RoleDescription";
import { UserCell } from "@/components/UserCell";
import { Alert } from "@/components/ui/alert";
import { Badge } from "@/components/ui/badge";
import { Button } from "@/components/ui/button";
import { Checkbox } from "@/components/ui/checkbox";
import { ExpirationPicker } from "@/components/ui/expiration-picker";
import { FormError, FormField } from "@/components/ui/form";
import { Input } from "@/components/ui/input";
import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group";
import { SearchInput } from "@/components/ui/search-input";
import {
  Sheet,
  SheetBody,
  SheetContent,
  SheetFooter,
  SheetHeader,
  SheetTitle,
} from "@/components/ui/sheet";
import {
  Table,
  TableBody,
  TableCell,
  TableHead,
  TableHeader,
  TableRow,
} from "@/components/ui/table";
import { Tabs, TabsList, TabsPanel, TabsTrigger } from "@/components/ui/tabs";
import { Textarea } from "@/components/ui/textarea";
import { Tooltip } from "@/components/ui/tooltip";
import {
  WorkspacePageLayout,
  WorkspacePageToolbar,
} from "@/components/WorkspacePageLayout";
import {
  useCurrentUser,
  useEnvironmentList,
  usePlanFeature,
} from "@/hooks/useAppState";
import { useEscapeKey } from "@/hooks/useEscapeKey";
import { useProjectByName } from "@/hooks/useProjectByName";
import {
  getMemberBindings,
  groupProjectRoleBindings,
} from "@/lib/memberBindings";
import {
  GRANT_ACCESS_PRODUCT_INTRO,
  useProductIntro,
} from "@/lib/productIntro";
import {
  type DirectExecutionValue,
  directExecutionEnvironments,
  directExecutionOf,
  EMPTY_DIRECT_EXECUTION,
  isDirectExecutionValid,
} from "@/lib/project-member/directExecution";
import {
  getRoleEnvironmentLimitationKind,
  getRolesEnvironmentLimitationKind,
  roleHasDatabaseLimitation,
} from "@/lib/project-member/utils";
import { displayRoleTitleFromList } from "@/lib/role";
import { cn } from "@/lib/utils";
import { RequestRoleSheet } from "@/modules/access-control/RequestRoleSheet";
import {
  getRequestRoleButtonState,
  REQUEST_ROLE_REQUIRED_PERMISSIONS,
} from "@/modules/access-control/requestRoleButton";
import type { DatabaseMode } from "@/modules/access-control/types";
import type { ConditionGroupExpr, Factor, Operator } from "@/modules/cel";
import {
  buildCELExpr,
  emptySimpleExpr,
  validateSimpleExpr,
  wrapAsGroup,
} from "@/modules/cel";
import { pushNotification } from "@/stores";
import { useAppStore } from "@/stores/app";
import { projectNamePrefix } from "@/stores/modules/v1/common";
import {
  ALL_USERS_USER_EMAIL,
  type DatabaseResource,
  isDefaultProject,
  type Permission,
  PresetRoleType,
  userBindingPrefix,
} from "@/types";
import { ExprSchema as ConditionExprSchema } from "@/types/proto-es/google/type/expr_pb";
import { State } from "@/types/proto-es/v1/common_pb";
import { type Binding, BindingSchema } from "@/types/proto-es/v1/iam_policy_pb";
import { Setting_SettingName } from "@/types/proto-es/v1/setting_service_pb";
import { PlanFeature } from "@/types/proto-es/v1/subscription_service_pb";
import type { User } from "@/types/proto-es/v1/user_service_pb";
import type { GroupBinding, MemberBinding } from "@/types/v1/member";
import {
  batchConvertParsedExprToCELString,
  formatAbsoluteDateTime,
  getDatabaseNameOptionConfig,
  hasProjectPermissionV2,
  hasWorkspacePermissionV2,
  isBindingPolicyExpired,
  revokeMemberFromBinding,
  sortRoles,
} from "@/utils";
import {
  CEL_ATTRIBUTE_RESOURCE_DATABASE,
  CEL_ATTRIBUTE_RESOURCE_SCHEMA_NAME,
  CEL_ATTRIBUTE_RESOURCE_TABLE_NAME,
} from "@/utils/cel-attributes";
import {
  buildConditionExpr,
  convertFromExpr,
  readableCondition,
  stringifyConditionExpression,
} from "@/utils/issue/cel";
import { MemberBindingResourceTable } from "./MemberBindingResourceTable";
import { getSetIamPolicyPermissionGuardConfig } from "./membersPageActions";

const EMPTY_ROLE_SET = new Set<string>();

function RolePermissionPreview({
  permissions,
}: {
  permissions: readonly string[];
}) {
  const { t } = useTranslation();

  if (permissions.length === 0) return null;

  return (
    <FormField title={<>{t("common.permissions")}</>}>
      <div className="max-h-32 overflow-auto rounded-sm border border-control-border bg-control-bg p-2">
        <div className="flex flex-wrap gap-1">
          {permissions.map((permission) => (
            <Badge
              key={permission}
              className="bg-control-bg-hover text-control-light"
            >
              {permission}
            </Badge>
          ))}
        </div>
      </div>
    </FormField>
  );
}

// ============================================================
// MemberTable (view by members)
// ============================================================

function MemberTable({
  bindings,
  allowEdit,
  selectedBindings,
  onSelectionChange,
  onUpdateBinding,
  onRevokeBinding,
  scope,
}: {
  bindings: MemberBinding[];
  allowEdit: boolean;
  selectedBindings: string[];
  onSelectionChange: (selected: string[]) => void;
  onUpdateBinding: (binding: MemberBinding) => void;
  onRevokeBinding: (binding: MemberBinding) => void;
  scope: "workspace" | "project";
}) {
  const { t } = useTranslation();
  const currentUser = useCurrentUser();
  const isSaaSMode = useAppStore((s) => s.isSaaSMode());
  const batchGetOrFetchUsers = useAppStore(
    (state) => state.batchGetOrFetchUsers
  );
  const roleList = useAppStore((state) => state.roleList);
  const canGetGroups = hasWorkspacePermissionV2("bb.groups.get");
  const canGetUsers = hasWorkspacePermissionV2("bb.users.get");

  // Group expand state. Cache is keyed by group name and invalidated
  // when the group-binding *content* changes — not on `bindings`
  // reference change, because the parent rebuilds `memberBindings` via
  // `useMemo(() => getMemberBindings(...))` and gets a new array identity
  // whenever its deps change. We can't use the `prevBindingsRef.current
  // !== bindings` shortcut that `GroupsPage` uses (its `groups` comes
  // from a reducer-backed `usePagedData` with stable identity).
  // Comparing a content-derived signature instead lets the cache only
  // reset on real membership changes — same effect, different trigger.
  const [expandedGroups, setExpandedGroups] = useState<Set<string>>(new Set());
  const [memberCache, setMemberCache] = useState<Map<string, User[]>>(
    new Map()
  );
  const memberCacheRef = useRef(memberCache);
  memberCacheRef.current = memberCache;
  const loadingRef = useRef<Set<string>>(new Set());

  const fetchGroupMembers = useCallback(
    (group: GroupBinding) => {
      if (loadingRef.current.has(group.name)) return;
      loadingRef.current.add(group.name);
      const memberNames = group.members.map((m) => m.member);
      batchGetOrFetchUsers(memberNames)
        .then((users: (User | undefined)[]) => {
          setMemberCache((prev) => {
            const next = new Map(prev);
            next.set(
              group.name,
              users.filter((u): u is User => !!u)
            );
            return next;
          });
        })
        .catch(() => {
          // Allow retry on next expand
        })
        .finally(() => loadingRef.current.delete(group.name));
    },
    [batchGetOrFetchUsers]
  );

  // Signature of just the group bindings — that's all the cache cares
  // about. Recomputed on every render (because `bindings` reference
  // changes), but yields a stable string when group content is
  // unchanged, so the effect below only fires on real membership
  // changes.
  const groupBindingsSignature = useMemo(() => {
    const parts: string[] = [];
    for (const b of bindings) {
      if (b.type !== "groups" || !b.group) continue;
      const members = b.group.members
        .map((m) => m.member)
        .sort()
        .join(",");
      parts.push(`${b.group.name}:${members}`);
    }
    return parts.join("|");
  }, [bindings]);

  // Reset the cache and refetch currently-expanded groups when the
  // group-bindings signature changes (membership edit, IAM refresh).
  const expandedGroupsRef = useRef(expandedGroups);
  expandedGroupsRef.current = expandedGroups;
  const bindingsRef = useRef(bindings);
  bindingsRef.current = bindings;
  const fetchGroupMembersRef = useRef(fetchGroupMembers);
  fetchGroupMembersRef.current = fetchGroupMembers;
  useEffect(() => {
    setMemberCache(new Map());
    loadingRef.current = new Set();
    for (const groupName of expandedGroupsRef.current) {
      const mb = bindingsRef.current.find(
        (b) => b.type === "groups" && b.group?.name === groupName
      );
      if (mb?.group) {
        fetchGroupMembersRef.current(mb.group);
      }
    }
  }, [groupBindingsSignature]);

  const toggleGroupExpand = useCallback(
    (group: GroupBinding) => {
      setExpandedGroups((prev) => {
        const next = new Set(prev);
        if (next.has(group.name)) {
          next.delete(group.name);
        } else {
          next.add(group.name);
        }
        return next;
      });

      // Fetch members if not cached
      if (!memberCacheRef.current.has(group.name)) {
        fetchGroupMembers(group);
      }
    },
    [fetchGroupMembers]
  );

  const selectableBindings = useMemo(
    () =>
      bindings.filter(
        (b) => scope !== "project" || b.projectRoleBindings.length > 0
      ),
    [bindings, scope]
  );

  // Drop selections that are no longer rendered. The parent filters
  // `bindings` by search text, so without this a user could select rows,
  // type a search that hides them, and still bulk-revoke hidden members.
  useEffect(() => {
    const visibleNames = new Set(bindings.map((b) => b.binding));
    const next = selectedBindings.filter((b) => visibleNames.has(b));
    if (next.length !== selectedBindings.length) {
      onSelectionChange(next);
    }
  }, [bindings, selectedBindings, onSelectionChange]);

  const allSelected =
    selectableBindings.length > 0 &&
    selectableBindings.every((b) => selectedBindings.includes(b.binding));

  const toggleAll = () => {
    if (allSelected) {
      onSelectionChange([]);
    } else {
      onSelectionChange(selectableBindings.map((b) => b.binding));
    }
  };

  const toggleOne = (binding: string) => {
    onSelectionChange(
      selectedBindings.includes(binding)
        ? selectedBindings.filter((b) => b !== binding)
        : [...selectedBindings, binding]
    );
  };

  const canEdit = (mb: MemberBinding) => {
    if (mb.type === "users") return mb.user?.state !== State.DELETED;
    if (mb.type === "groups") return !mb.group?.deleted;
    return true;
  };

  const isSelectDisabled = (mb: MemberBinding) => {
    return scope === "project" && mb.projectRoleBindings.length === 0;
  };

  const renderProjectRoleSummary = (bindings: Binding[]) => {
    // Show all roles, active first then expired. Expired chips get
    // line-through + reduced opacity so the count of stale bindings is
    // visible — exposing the issue rather than hiding it.
    const active = bindings.filter((b) => !isBindingPolicyExpired(b));
    const expired = bindings.filter((b) => isBindingPolicyExpired(b));
    return [
      ...groupProjectRoleBindings(active).map((group) => (
        <Badge key={`active-${group.role}`} className="text-xs gap-x-1">
          {displayRoleTitleFromList(group.role, roleList)}
          {group.bindings.length > 1 && (
            <span className="text-control-light">
              ({group.bindings.length})
            </span>
          )}
        </Badge>
      )),
      ...groupProjectRoleBindings(expired).map((group) => (
        <Badge
          key={`expired-${group.role}`}
          className="text-xs gap-x-1 line-through opacity-60"
        >
          {displayRoleTitleFromList(group.role, roleList)}
          {group.bindings.length > 1 && (
            <span className="text-control-light">
              ({group.bindings.length})
            </span>
          )}
        </Badge>
      )),
    ];
  };

  return (
    <div className="border rounded-sm overflow-hidden">
      <Table>
        <TableHeader>
          <TableRow className="bg-control-bg">
            {allowEdit && (
              <TableHead className="w-10">
                <Checkbox checked={allSelected} onCheckedChange={toggleAll} />
              </TableHead>
            )}
            <TableHead>{t("settings.members.table.account")}</TableHead>
            <TableHead>{t("settings.members.table.roles")}</TableHead>
            <TableHead className="w-24">{t("common.operations")}</TableHead>
          </TableRow>
        </TableHeader>
        <TableBody>
          {bindings.map((mb) => {
            const isGroupExpanded =
              mb.type === "groups" &&
              mb.group &&
              expandedGroups.has(mb.group.name);
            const groupMembers = mb.group
              ? memberCache.get(mb.group.name)
              : undefined;

            return (
              <React.Fragment key={mb.binding}>
                <TableRow>
                  {allowEdit && (
                    <TableCell>
                      <Checkbox
                        checked={selectedBindings.includes(mb.binding)}
                        disabled={isSelectDisabled(mb)}
                        onCheckedChange={() => toggleOne(mb.binding)}
                      />
                    </TableCell>
                  )}
                  <TableCell>
                    <UserCell
                      title={mb.title}
                      subtitle={
                        mb.type === "users"
                          ? mb.user?.email
                          : mb.binding.replace("group:", "groups/")
                      }
                      avatar={
                        mb.type === "groups" ? (
                          <>
                            <Button
                              appearance="secondary"
                              size="xs"
                              type="button"
                              className="flex shrink-0 items-center justify-center cursor-pointer"
                              onClick={() =>
                                mb.group && toggleGroupExpand(mb.group)
                              }
                            >
                              {isGroupExpanded ? (
                                <ChevronDown className="size-4 text-control-light" />
                              ) : (
                                <ChevronRight className="size-4 text-control-light" />
                              )}
                            </Button>
                            <div className="size-9 rounded-full bg-control-bg-hover flex items-center justify-center shrink-0">
                              <Users className="size-4 text-control-light" />
                            </div>
                          </>
                        ) : undefined
                      }
                      hoverEmail={
                        mb.type === "users" && canGetUsers
                          ? mb.user?.email
                          : undefined
                      }
                      nameLink={
                        mb.type === "groups" && canGetGroups
                          ? {
                              to: {
                                name: WORKSPACE_ROUTE_GROUPS,
                              },
                            }
                          : undefined
                      }
                      badges={
                        <>
                          {mb.type === "users" &&
                            mb.user?.name === currentUser.name && (
                              <Badge className="text-xs">
                                {t("common.you")}
                              </Badge>
                            )}
                          {isSaaSMode && mb.type === "users" && mb.pending && (
                            <Badge variant="warning" className="text-xs">
                              {t("settings.members.pending-invite")}
                            </Badge>
                          )}
                          {mb.type === "users" && (
                            <AccountTypeBadge email={mb.user?.email} />
                          )}
                          {mb.group && (
                            <span className="text-control-light text-xs">
                              ({mb.group.members.length}{" "}
                              {t("common.members", {
                                count: mb.group.members.length,
                              })}
                              )
                            </span>
                          )}
                          {mb.group?.deleted && (
                            <Badge variant="destructive" className="text-xs">
                              {t("common.deleted")}
                            </Badge>
                          )}
                        </>
                      }
                    />
                  </TableCell>
                  <TableCell>
                    <div className="flex flex-wrap gap-1">
                      {scope === "project"
                        ? renderProjectRoleSummary(mb.projectRoleBindings)
                        : sortRoles([...mb.workspaceLevelRoles]).map((role) => (
                            <Badge key={role} className="text-xs gap-x-1">
                              <Building2 className="h-3 w-3" />
                              {displayRoleTitleFromList(role, roleList)}
                            </Badge>
                          ))}
                    </div>
                  </TableCell>
                  <TableCell>
                    <div className="flex items-center gap-x-1">
                      {allowEdit && canEdit(mb) && (
                        <Button
                          appearance="secondary"
                          size="sm"
                          aria-label={t("common.edit")}
                          onClick={() => onUpdateBinding(mb)}
                        >
                          <Pencil className="h-4 w-4" />
                        </Button>
                      )}
                      {allowEdit && (
                        <Button
                          appearance="secondary"
                          size="sm"
                          onClick={() => {
                            if (
                              window.confirm(
                                t("settings.members.revoke-access-alert")
                              )
                            ) {
                              onRevokeBinding(mb);
                            }
                          }}
                        >
                          <Trash2 className="h-4 w-4" />
                        </Button>
                      )}
                    </div>
                  </TableCell>
                </TableRow>
                {/* Expanded group members */}
                {isGroupExpanded &&
                  (groupMembers ? (
                    groupMembers.map((user) => (
                      <TableRow key={`${mb.binding}-${user.name}`}>
                        {allowEdit && <TableCell />}
                        <TableCell>
                          <UserCell
                            title={user.title}
                            subtitle={user.email}
                            size="sm"
                            className="pl-12"
                            hoverEmail={canGetUsers ? user.email : undefined}
                            badges={
                              user.name === currentUser.name ? (
                                <Badge className="text-xs">
                                  {t("common.you")}
                                </Badge>
                              ) : undefined
                            }
                          />
                        </TableCell>
                        <TableCell />
                        <TableCell />
                      </TableRow>
                    ))
                  ) : (
                    <TableRow>
                      {allowEdit && <TableCell />}
                      <TableCell>
                        <div className="flex items-center gap-x-3 pl-12">
                          <span className="text-sm text-control-light">
                            {t("common.loading")}
                          </span>
                        </div>
                      </TableCell>
                      <TableCell />
                      <TableCell />
                    </TableRow>
                  ))}
              </React.Fragment>
            );
          })}
          {bindings.length === 0 && (
            <TableRow>
              <TableCell
                colSpan={allowEdit ? 4 : 3}
                className="px-4 py-8 text-center text-control-light"
              >
                {t("common.no-data")}
              </TableCell>
            </TableRow>
          )}
        </TableBody>
      </Table>
    </div>
  );
}

// ============================================================
// MemberTableByRole (view by roles)
// ============================================================

function MemberTableByRole({
  bindings,
  allowEdit,
  onUpdateBinding,
  onRevokeBinding,
  scope,
}: {
  bindings: MemberBinding[];
  allowEdit: boolean;
  onUpdateBinding: (binding: MemberBinding) => void;
  onRevokeBinding: (binding: MemberBinding) => void;
  scope: "workspace" | "project";
}) {
  const { t } = useTranslation();
  const currentUser = useCurrentUser();
  const isSaaSMode = useAppStore((s) => s.isSaaSMode());
  const roleList = useAppStore((state) => state.roleList);
  const [expandedRoles, setExpandedRoles] = useState<Set<string>>(new Set());
  const initializedRef = useRef(false);

  type RoleMember = { member: MemberBinding; allExpired: boolean };
  const roleToBindings = useMemo(() => {
    const map = new Map<string, RoleMember[]>();
    const appendToRole = (role: string, entry: RoleMember) => {
      const arr = map.get(role) ?? [];
      arr.push(entry);
      map.set(role, arr);
    };
    for (const mb of bindings) {
      if (scope === "project") {
        // Group this member's bindings by role so we can mark a row expired
        // only when ALL of its bindings for that role are expired.
        const bindingsByRole = new Map<string, Binding[]>();
        for (const b of mb.projectRoleBindings) {
          const arr = bindingsByRole.get(b.role) ?? [];
          arr.push(b);
          bindingsByRole.set(b.role, arr);
        }
        for (const [role, roleBindings] of bindingsByRole) {
          const allExpired = roleBindings.every((b) =>
            isBindingPolicyExpired(b)
          );
          appendToRole(role, { member: mb, allExpired });
        }
      } else {
        for (const role of mb.workspaceLevelRoles) {
          appendToRole(role, { member: mb, allExpired: false });
        }
      }
    }
    const sortedRoles = sortRoles([...map.keys()]);
    return sortedRoles.map((role) => ({
      role,
      // Active members first, expired-only members last.
      members: (map.get(role) ?? []).slice().sort((a, b) => {
        return Number(a.allExpired) - Number(b.allExpired);
      }),
    }));
  }, [bindings, scope]);

  // Expand all roles by default on first load
  useEffect(() => {
    if (!initializedRef.current && roleToBindings.length > 0) {
      initializedRef.current = true;
      setExpandedRoles(new Set(roleToBindings.map((r) => r.role)));
    }
  }, [roleToBindings]);

  const toggleRole = (role: string) => {
    setExpandedRoles((prev) => {
      const next = new Set(prev);
      if (next.has(role)) next.delete(role);
      else next.add(role);
      return next;
    });
  };

  const canEdit = (mb: MemberBinding) => {
    if (mb.type === "users") return mb.user?.state !== State.DELETED;
    if (mb.type === "groups") return !mb.group?.deleted;
    return true;
  };

  return (
    <div className="border rounded-sm overflow-hidden">
      <Table>
        <TableBody striped={false}>
          {roleToBindings.map(({ role, members }) => {
            const expanded = expandedRoles.has(role);
            return (
              <React.Fragment key={role}>
                <TableRow
                  className="bg-control-bg cursor-pointer"
                  onClick={() => toggleRole(role)}
                >
                  <TableCell colSpan={3}>
                    <div className="flex items-center gap-x-2">
                      {expanded ? (
                        <ChevronDown className="h-4 w-4" />
                      ) : (
                        <ChevronRight className="h-4 w-4" />
                      )}
                      {scope === "workspace" && (
                        <Building2 className="h-4 w-4 text-control-light" />
                      )}
                      <span className="font-medium">
                        {displayRoleTitleFromList(role, roleList)}
                      </span>
                      <span className="text-control-light text-xs">
                        ({members.length})
                      </span>
                    </div>
                  </TableCell>
                </TableRow>
                {expanded &&
                  members.map(({ member: mb, allExpired }) => (
                    <TableRow
                      key={`${role}-${mb.binding}`}
                      className={cn(allExpired && "opacity-60")}
                    >
                      <TableCell className="pl-10">
                        <UserCell
                          title={mb.title}
                          subtitle={
                            mb.type === "users"
                              ? mb.user?.email
                              : mb.binding.replace("group:", "groups/")
                          }
                          size="sm"
                          avatar={
                            mb.type === "groups" ? (
                              <div className="size-7 rounded-full bg-control-bg-hover flex items-center justify-center shrink-0">
                                <Users className="size-3.5 text-control-light" />
                              </div>
                            ) : undefined
                          }
                          nameClassName={
                            allExpired ? "line-through" : undefined
                          }
                          badges={
                            <>
                              {allExpired && (
                                <Badge
                                  variant="destructive"
                                  className="text-xs"
                                >
                                  {t("common.expired")}
                                </Badge>
                              )}
                              {mb.type === "users" &&
                                mb.user?.name === currentUser.name && (
                                  <Badge className="text-xs">
                                    {t("common.you")}
                                  </Badge>
                                )}
                              {isSaaSMode &&
                                mb.type === "users" &&
                                mb.pending && (
                                  <Badge variant="warning" className="text-xs">
                                    {t("settings.members.pending-invite")}
                                  </Badge>
                                )}
                              {mb.type === "users" && (
                                <AccountTypeBadge email={mb.user?.email} />
                              )}
                              {mb.group?.deleted && (
                                <Badge
                                  variant="destructive"
                                  className="text-xs"
                                >
                                  {t("common.deleted")}
                                </Badge>
                              )}
                            </>
                          }
                        />
                      </TableCell>
                      <TableCell />
                      <TableCell className="w-24">
                        <div className="flex items-center gap-x-1">
                          {allowEdit && canEdit(mb) && (
                            <Button
                              appearance="secondary"
                              size="sm"
                              aria-label={t("common.edit")}
                              onClick={() => onUpdateBinding(mb)}
                            >
                              <Pencil className="h-4 w-4" />
                            </Button>
                          )}
                          {allowEdit && (
                            <Button
                              appearance="secondary"
                              size="sm"
                              onClick={() => {
                                if (
                                  window.confirm(
                                    t("settings.members.revoke-access-alert")
                                  )
                                ) {
                                  onRevokeBinding(mb);
                                }
                              }}
                            >
                              <Trash2 className="h-4 w-4" />
                            </Button>
                          )}
                        </div>
                      </TableCell>
                    </TableRow>
                  ))}
              </React.Fragment>
            );
          })}
          {roleToBindings.length === 0 && (
            <TableRow>
              <TableCell
                colSpan={3}
                className="px-4 py-8 text-center text-control-light"
              >
                {t("common.no-data")}
              </TableCell>
            </TableRow>
          )}
        </TableBody>
      </Table>
    </div>
  );
}

// ============================================================
// Expiration presets
// ============================================================

interface ExpirationPreset {
  labelKey: string;
  days: number;
}

// A small set of common presets. Users needing any other duration pick the
// "Custom" option, which reveals a datetime picker.
const EXPIRATION_PRESETS: ExpirationPreset[] = [
  { labelKey: "project.members.expiration-presets.one-week", days: 7 },
  { labelKey: "project.members.expiration-presets.one-month", days: 30 },
  { labelKey: "project.members.expiration-presets.three-months", days: 90 },
  { labelKey: "project.members.expiration-presets.one-year", days: 365 },
];

function computeExpirationTimestamp(days?: number): number | undefined {
  if (days === undefined) return undefined;
  return Date.now() + days * 86400000;
}

// Validates the form's expiration against the workspace cap. "Never" (no
// timestamp) is only allowed when no cap is configured; a chosen timestamp
// must be in the future and within the cap.
function isExpirationValid(
  form: RoleBindingFormState,
  maximumRoleExpirationDays: number | undefined
): boolean {
  if (form.expirationTimestampInMS === undefined) {
    return maximumRoleExpirationDays === undefined;
  }
  const now = Date.now();
  if (form.expirationTimestampInMS <= now) return false;
  if (
    maximumRoleExpirationDays !== undefined &&
    form.expirationTimestampInMS > now + maximumRoleExpirationDays * 86400000
  ) {
    return false;
  }
  return true;
}

function ExpirationChip({
  label,
  selected,
  onClick,
}: {
  label: string;
  selected: boolean;
  onClick: () => void;
}) {
  return (
    <Button
      appearance="secondary"
      size="xs"
      type="button"
      className={cn(
        "px-2.5 py-1 text-xs rounded-sm border transition-colors",
        selected
          ? "bg-accent text-accent-text border-accent hover:bg-accent-hover"
          : "bg-background text-control border-control-border hover:bg-control-bg"
      )}
      onClick={onClick}
    >
      {label}
    </Button>
  );
}

// ============================================================
// ProjectRoleBindingForm — one role binding form in create mode
// ============================================================

interface RoleBindingFormState {
  id: string;
  role: string;
  reason: string;
  expirationDays: number | undefined;
  expirationTimestampInMS: number | undefined;
  // When true, the user picked a custom datetime instead of a preset.
  expirationCustom: boolean;
  databaseMode: DatabaseMode;
  databaseResources: DatabaseResource[];
  exprGroup: ConditionGroupExpr;
  directExecution: DirectExecutionValue;
}

// ============================================================
// DatabaseResourceSection — radio modes + selector
// ============================================================

function DatabaseResourceSection({
  projectName,
  mode,
  onModeChange,
  databaseResources,
  onDatabaseResourcesChange,
  exprGroup,
  onExprGroupChange,
  factorList,
  factorOptionConfigMap,
  factorOperatorOverrideMap,
}: {
  projectName: string;
  mode: DatabaseMode;
  onModeChange: (mode: DatabaseMode) => void;
  databaseResources: DatabaseResource[];
  onDatabaseResourcesChange: (resources: DatabaseResource[]) => void;
  exprGroup: ConditionGroupExpr;
  onExprGroupChange: (expr: ConditionGroupExpr) => void;
  factorList: Factor[];
  factorOptionConfigMap: Map<Factor, OptionConfig>;
  factorOperatorOverrideMap: Map<Factor, Operator[]>;
}) {
  const { t } = useTranslation();

  const modes: { value: DatabaseMode; label: string }[] = [
    { value: "ALL", label: t("common.all") },
    { value: "EXPRESSION", label: "CEL Expression" },
    { value: "SELECT", label: t("common.manually-select") },
  ];

  return (
    <FormField
      title={
        <>
          {t("common.databases")}
          <span className="ml-0.5 text-error">*</span>
        </>
      }
    >
      <RadioGroup
        className="gap-x-4"
        value={mode}
        onValueChange={(value) => onModeChange(value as DatabaseMode)}
      >
        {modes.map((m) => (
          <RadioGroupItem key={m.value} value={m.value}>
            {m.label}
          </RadioGroupItem>
        ))}
      </RadioGroup>

      {mode === "EXPRESSION" && (
        <ExprEditor
          expr={exprGroup}
          factorList={factorList}
          optionConfigMap={factorOptionConfigMap}
          factorOperatorOverrideMap={factorOperatorOverrideMap}
          onUpdate={onExprGroupChange}
        />
      )}

      {mode === "SELECT" && (
        <DatabaseResourceSelectorComponent
          projectName={projectName}
          value={databaseResources}
          onChange={onDatabaseResourcesChange}
        />
      )}
    </FormField>
  );
}

function ProjectRoleBindingForm({
  form,
  onChange,
  onRemove,
  canRemove,
  projectName,
  maximumRoleExpirationDays,
}: {
  form: RoleBindingFormState;
  onChange: (updated: RoleBindingFormState) => void;
  onRemove: () => void;
  canRemove: boolean;
  projectName: string;
  maximumRoleExpirationDays: number | undefined;
}) {
  const { t } = useTranslation();

  const roleList = useAppStore((state) => state.roleList);

  const visibleExpirationPresets = useMemo(
    () =>
      EXPIRATION_PRESETS.filter(
        (preset) =>
          maximumRoleExpirationDays === undefined ||
          preset.days <= maximumRoleExpirationDays
      ),
    [maximumRoleExpirationDays]
  );
  const minDatetime = dayjs().format("YYYY-MM-DDTHH:mm");
  const maxDatetime =
    maximumRoleExpirationDays !== undefined
      ? dayjs()
          .add(maximumRoleExpirationDays, "days")
          .format("YYYY-MM-DDTHH:mm")
      : undefined;
  const now = Date.now();
  const expirationIsInPast =
    form.expirationCustom &&
    form.expirationTimestampInMS !== undefined &&
    form.expirationTimestampInMS <= now;
  const expirationExceedsMax =
    form.expirationTimestampInMS !== undefined &&
    maximumRoleExpirationDays !== undefined &&
    form.expirationTimestampInMS > now + maximumRoleExpirationDays * 86400000;
  const factorList = useMemo<Factor[]>(
    () => [
      CEL_ATTRIBUTE_RESOURCE_DATABASE,
      CEL_ATTRIBUTE_RESOURCE_TABLE_NAME,
      CEL_ATTRIBUTE_RESOURCE_SCHEMA_NAME,
    ],
    []
  );
  const factorOperatorOverrideMap = useMemo(
    () =>
      new Map<Factor, Operator[]>([
        [CEL_ATTRIBUTE_RESOURCE_DATABASE, ["_==_", "@in"]],
        [CEL_ATTRIBUTE_RESOURCE_SCHEMA_NAME, ["_==_"]],
        [CEL_ATTRIBUTE_RESOURCE_TABLE_NAME, ["_==_", "@in"]],
      ]),
    []
  );
  const factorOptionConfigMap = useMemo(
    () =>
      factorList.reduce((map, factor) => {
        if (factor === CEL_ATTRIBUTE_RESOURCE_DATABASE) {
          map.set(factor, {
            ...getDatabaseNameOptionConfig(projectName),
            supportMultiple: false,
          });
        } else {
          map.set(factor, { options: [] });
        }
        return map;
      }, new Map<Factor, OptionConfig>()),
    [factorList, projectName]
  );

  const permissions = useMemo(() => {
    if (!form.role) return [];
    const presetRole = roleList.find((r) => r.name === form.role);
    return presetRole?.permissions ?? [];
  }, [form.role, roleList]);

  const showDatabases = useMemo(
    () => form.role && roleHasDatabaseLimitation(form.role),
    [form.role]
  );
  // Not memoized: the role store may fill in after the form mounts.
  const envKind = form.role
    ? getRoleEnvironmentLimitationKind(form.role)
    : undefined;

  const handleRoleChange = (role: string) => {
    onChange({
      ...form,
      role,
      databaseMode: "ALL",
      databaseResources: [],
      exprGroup: wrapAsGroup(emptySimpleExpr()),
      directExecution: EMPTY_DIRECT_EXECUTION,
    });
  };

  const handleReasonChange = (reason: string) => {
    onChange({ ...form, reason });
  };

  const handlePresetChange = (days: number | undefined) => {
    onChange({
      ...form,
      expirationCustom: false,
      expirationDays: days,
      expirationTimestampInMS: computeExpirationTimestamp(days),
    });
  };

  const handleCustomClick = () => {
    // Seed the picker with the current timestamp, or a default 1 week
    // (clamped to the cap) when switching from "Never".
    const seedDays =
      maximumRoleExpirationDays === undefined
        ? 7
        : Math.min(7, maximumRoleExpirationDays);
    onChange({
      ...form,
      expirationCustom: true,
      expirationDays: undefined,
      expirationTimestampInMS:
        form.expirationTimestampInMS ?? computeExpirationTimestamp(seedDays),
    });
  };

  const handleCustomDateChange = (value: string | undefined) => {
    onChange({
      ...form,
      expirationCustom: true,
      expirationDays: undefined,
      expirationTimestampInMS: value ? dayjs(value).valueOf() : undefined,
    });
  };

  return (
    <div className="border rounded-sm p-4 flex flex-col gap-y-4 relative">
      {canRemove && (
        <Button
          appearance="secondary"
          size="xs"
          type="button"
          className="absolute top-2 right-2 text-control-light hover:text-error"
          onClick={onRemove}
        >
          <X className="h-4 w-4" />
        </Button>
      )}

      {/* Role select */}
      <FormField title={<>{t("settings.members.assign-role")}</>}>
        <RoleSelect
          value={form.role ? [form.role] : []}
          onChange={(roles) => handleRoleChange(roles[0] ?? "")}
          multiple={false}
          scope="project"
        />
        <RoleDescription role={form.role} roleList={roleList} />
      </FormField>

      <RolePermissionPreview permissions={permissions} />

      {/* Reason */}
      <FormField
        title={
          <>
            {t("common.reason")}{" "}
            <span className="text-control-light font-normal">
              ({t("common.optional")})
            </span>
          </>
        }
      >
        <Textarea
          size="sm"
          className="w-full rounded-xs border border-control-border bg-transparent px-3 py-2 text-sm resize-none"
          rows={2}
          value={form.reason}
          onChange={(e) => handleReasonChange(e.target.value)}
        />
      </FormField>

      {/* Databases (conditional on role) */}
      {showDatabases && (
        <DatabaseResourceSection
          projectName={projectName}
          mode={form.databaseMode}
          onModeChange={(mode: DatabaseMode) =>
            onChange({
              ...form,
              databaseMode: mode,
              databaseResources: [],
              exprGroup: wrapAsGroup(emptySimpleExpr()),
            })
          }
          databaseResources={form.databaseResources}
          onDatabaseResourcesChange={(resources: DatabaseResource[]) =>
            onChange({ ...form, databaseResources: resources })
          }
          exprGroup={form.exprGroup}
          onExprGroupChange={(expr: ConditionGroupExpr) =>
            onChange({ ...form, exprGroup: expr })
          }
          factorList={factorList}
          factorOptionConfigMap={factorOptionConfigMap}
          factorOperatorOverrideMap={factorOperatorOverrideMap}
        />
      )}

      {envKind && (
        <DirectExecutionField
          kind={envKind}
          lead="grant"
          value={form.directExecution}
          onChange={(next) => onChange({ ...form, directExecution: next })}
        />
      )}

      {/* Expiration */}
      <FormField
        title={
          <>
            {t("common.expiration")}
            <span className="ml-0.5 text-error">*</span>
          </>
        }
        description={
          maximumRoleExpirationDays !== undefined
            ? t("common.expiration-max-hint", {
                days: maximumRoleExpirationDays,
              })
            : undefined
        }
      >
        <div className="flex flex-wrap gap-1.5">
          {/* "Never" is only offered when the workspace sets no cap. */}
          {maximumRoleExpirationDays === undefined && (
            <ExpirationChip
              label={t("project.members.never-expires")}
              selected={
                !form.expirationCustom && form.expirationDays === undefined
              }
              onClick={() => handlePresetChange(undefined)}
            />
          )}
          {visibleExpirationPresets.map((preset) => (
            <ExpirationChip
              key={preset.days}
              label={t(preset.labelKey)}
              selected={
                !form.expirationCustom && form.expirationDays === preset.days
              }
              onClick={() => handlePresetChange(preset.days)}
            />
          ))}
          <ExpirationChip
            label={t("common.custom")}
            selected={form.expirationCustom}
            onClick={handleCustomClick}
          />
        </div>
        {form.expirationCustom && (
          <ExpirationPicker
            value={
              form.expirationTimestampInMS
                ? dayjs(form.expirationTimestampInMS).format("YYYY-MM-DDTHH:mm")
                : undefined
            }
            onChange={handleCustomDateChange}
            minDate={minDatetime}
            maxDate={maxDatetime}
          />
        )}
        {expirationIsInPast && (
          <FormError>{t("common.expiration-must-be-future")}</FormError>
        )}
        {expirationExceedsMax && (
          <FormError>
            {t("common.expiration-exceeds-max", {
              days: maximumRoleExpirationDays,
            })}
          </FormError>
        )}
        {!form.expirationCustom && form.expirationTimestampInMS && (
          <p className="text-xs leading-4 text-control-light">
            {t("project.members.expires-at", {
              // An interpolated sentence cannot host a tooltip, so it carries
              // the full precision itself.
              date: formatAbsoluteDateTime(form.expirationTimestampInMS),
            })}
          </p>
        )}
      </FormField>
    </div>
  );
}

// ============================================================
// EditMemberRoleDrawer
// ============================================================

function EditMemberRoleDrawer({
  member,
  onClose,
  projectName,
  initialBindings,
}: {
  member?: MemberBinding;
  onClose: () => void;
  projectName?: string;
  initialBindings?: string[];
}) {
  const { t } = useTranslation();
  const environmentList = useEnvironmentList();
  const hasEnvTierFeature = usePlanFeature(
    PlanFeature.FEATURE_ENVIRONMENT_TIERS
  );
  const patchWorkspaceIamPolicy = useAppStore(
    (state) => state.patchWorkspaceIamPolicy
  );
  const findWorkspaceRolesByMember = useAppStore(
    (state) => state.findWorkspaceRolesByMember
  );
  const getProjectIamPolicy = useAppStore((state) => state.getProjectIamPolicy);
  const updateProjectIamPolicy = useAppStore(
    (state) => state.updateProjectIamPolicy
  );
  const isSaaSMode = useAppStore((s) => s.isSaaSMode());
  const workspaceResourceName = useAppStore((s) => s.workspaceResourceName());
  const roleList = useAppStore((state) => state.roleList);
  const settingsByName = useAppStore((s) => s.settingsByName);
  const hasEmailSetting = useMemo(
    () => !!useAppStore.getState().getSettingByName(Setting_SettingName.EMAIL),
    [settingsByName]
  );
  useEffect(() => {
    useAppStore
      .getState()
      .getOrFetchSettingByName(Setting_SettingName.EMAIL, true);
  }, []);

  const isEditMode = !!member;
  const isProjectCreateMode = !!projectName && !isEditMode;
  const isProjectEditMode = !!projectName && isEditMode;
  const accountParents = useMemo(
    () => [
      ...new Set(
        [workspaceResourceName, projectName].filter(
          (parent): parent is string => !!parent
        )
      ),
    ],
    [workspaceResourceName, projectName]
  );

  // Live project role bindings for the member (reactively updated when IAM policy changes).
  // Active bindings come first, expired ones last; original order is preserved within each group.
  const projectPoliciesByName = useAppStore((s) => s.projectPoliciesByName);
  const liveProjectRoleBindings = useMemo(() => {
    if (!isProjectEditMode || !member || !projectName) return [];
    const policy = getProjectIamPolicy(projectName);
    const matching = policy.bindings.filter((b) =>
      b.members.includes(member.binding)
    );
    return [...matching].sort((a, b) => {
      const aExpired = isBindingPolicyExpired(a) ? 1 : 0;
      const bExpired = isBindingPolicyExpired(b) ? 1 : 0;
      return aExpired - bExpired;
    });
    // projectPoliciesByName backs getProjectIamPolicy — recompute on its change.
  }, [
    isProjectEditMode,
    member,
    projectName,
    getProjectIamPolicy,
    projectPoliciesByName,
  ]);

  const [selectedBindings, setSelectedBindings] = useState<string[]>(
    initialBindings ?? []
  );
  const [selectedRoles, setSelectedRoles] = useState<string[]>(() => {
    if (!member) return [];
    if (projectName) return member.projectRoleBindings.map((b) => b.role);
    return [...member.workspaceLevelRoles];
  });
  const selectedRolePermissions = useMemo(
    () => [
      ...new Set(
        selectedRoles.flatMap(
          (role) =>
            roleList.find(({ name }) => name === role)?.permissions ?? []
        )
      ),
    ],
    [roleList, selectedRoles]
  );
  const [isRequesting, setIsRequesting] = useState(false);
  const [showNestedGrant, setShowNestedGrant] = useState(false);

  const [form, setForm] = useState<RoleBindingFormState>(() => ({
    id: uuidv4(),
    role: "",
    reason: "",
    expirationDays: 7,
    expirationTimestampInMS: computeExpirationTimestamp(7),
    expirationCustom: false,
    databaseMode: "ALL",
    databaseResources: [],
    exprGroup: wrapAsGroup(emptySimpleExpr()),
    directExecution: EMPTY_DIRECT_EXECUTION,
  }));

  useEscapeKey(true, onClose);

  // Workspace-configured maximum role expiration, in days. PROJECT_OWNER
  // grants are exempt; returns undefined when no cap is set. Mirrors
  // RequestRoleSheet so direct grants and role requests behave the same.
  const workspaceProfile = useAppStore((s) => s.getWorkspaceProfile());
  const maximumRoleExpirationDays = useMemo(() => {
    if (form.role === PresetRoleType.PROJECT_OWNER) return undefined;
    const seconds = workspaceProfile.maximumRoleExpiration?.seconds;
    if (!seconds) return undefined;
    return Math.floor(Number(seconds) / (60 * 60 * 24));
  }, [workspaceProfile, form.role]);

  // Helpers for project edit mode
  const getBindingScope = useCallback(
    (
      binding: Binding
    ): {
      databaseResources: DatabaseResource[];
      expiration?: Date;
    } => {
      if (!binding.parsedExpr) return { databaseResources: [] };
      const conditionExpr = convertFromExpr(binding.parsedExpr) ?? {};
      return {
        databaseResources: conditionExpr.databaseResources ?? [],
        expiration: conditionExpr.expiredTime
          ? new Date(conditionExpr.expiredTime)
          : undefined,
      };
    },
    []
  );

  const handleDeleteRole = async (roleBinding: Binding) => {
    if (!member || !projectName) return;
    const roleName = displayRoleTitleFromList(roleBinding.role, roleList);
    if (
      !window.confirm(
        t("project.members.revoke-role-from-member", {
          role: roleName,
          member: member.title,
        })
      )
    )
      return;
    setIsRequesting(true);
    try {
      const policy = revokeMemberFromBinding(
        getProjectIamPolicy(projectName),
        roleBinding,
        member.binding
      );
      await updateProjectIamPolicy(projectName, policy);
      pushNotification({
        module: "bytebase",
        style: "SUCCESS",
        title: t("common.deleted"),
      });
      // Close the drawer only when the member has no remaining roles.
      const remaining = policy.bindings.some((b) =>
        b.members.includes(member.binding)
      );
      if (!remaining) {
        onClose();
      }
    } catch {
      // error shown by store
    } finally {
      setIsRequesting(false);
    }
  };

  const handleSubmit = async () => {
    setIsRequesting(true);
    try {
      if (projectName) {
        const policy = structuredClone(getProjectIamPolicy(projectName));
        if (isEditMode) {
          // Remove member from unconditional bindings only;
          // preserve conditional bindings (expiration, database scope)
          for (const binding of policy.bindings) {
            if (!binding.condition?.expression) {
              binding.members = binding.members.filter(
                (m) => m !== member.binding
              );
            }
          }
          policy.bindings = policy.bindings.filter((b) => b.members.length > 0);
          // Add member to selected roles (unconditional)
          for (const role of selectedRoles) {
            const existing = policy.bindings.find(
              (b) => b.role === role && !b.condition?.expression
            );
            if (existing) {
              if (!existing.members.includes(member.binding)) {
                existing.members.push(member.binding);
              }
            } else {
              policy.bindings.push(
                create(BindingSchema, {
                  role,
                  members: [member.binding],
                })
              );
            }
          }
        } else {
          // Create mode with role binding form
          {
            if (!form.role) throw new Error("role is required");
            const databaseResources =
              form.databaseMode === "SELECT" &&
              form.databaseResources.length > 0
                ? form.databaseResources
                : undefined;
            const environments =
              form.role &&
              getRoleEnvironmentLimitationKind(form.role) !== undefined
                ? directExecutionEnvironments(form.directExecution)
                : undefined;
            const hasCondition =
              form.expirationTimestampInMS !== undefined ||
              form.reason !== "" ||
              databaseResources !== undefined ||
              environments !== undefined ||
              (form.databaseMode === "EXPRESSION" &&
                validateSimpleExpr(form.exprGroup));
            if (
              form.databaseMode === "EXPRESSION" &&
              validateSimpleExpr(form.exprGroup)
            ) {
              let parsedExpr;
              try {
                parsedExpr = await buildCELExpr(form.exprGroup);
              } catch {
                parsedExpr = undefined;
              }
              if (!parsedExpr) {
                pushNotification({
                  module: "bytebase",
                  style: "CRITICAL",
                  title: t(
                    "project.members.request-role.failed-to-build-expression"
                  ),
                });
                return;
              }
              const [exprString] = await batchConvertParsedExprToCELString([
                parsedExpr,
              ]);
              if (!exprString?.trim()) {
                pushNotification({
                  module: "bytebase",
                  style: "CRITICAL",
                  title: t(
                    "project.members.request-role.failed-to-build-expression"
                  ),
                });
                return;
              }
              const extraParts = stringifyConditionExpression({
                expirationTimestampInMS: form.expirationTimestampInMS,
                environments,
              });
              const fullExpression = extraParts
                ? `(${exprString}) && ${extraParts}`
                : exprString;
              const condition = create(ConditionExprSchema, {
                expression: fullExpression,
                description: form.reason,
              });
              const existingConditioned = policy.bindings.find(
                (b) =>
                  b.role === form.role &&
                  b.condition?.expression === condition.expression
              );
              if (existingConditioned) {
                for (const m of selectedBindings) {
                  if (!existingConditioned.members.includes(m)) {
                    existingConditioned.members.push(m);
                  }
                }
              } else {
                policy.bindings.push(
                  create(BindingSchema, {
                    role: form.role,
                    members: [...selectedBindings],
                    condition,
                  })
                );
              }
            } else if (hasCondition) {
              const condition = buildConditionExpr({
                role: form.role,
                description: form.reason,
                expirationTimestampInMS: form.expirationTimestampInMS,
                databaseResources,
                environments,
              });
              const existingConditioned = policy.bindings.find(
                (b) =>
                  b.role === form.role &&
                  b.condition?.expression === condition.expression
              );
              if (existingConditioned) {
                for (const m of selectedBindings) {
                  if (!existingConditioned.members.includes(m)) {
                    existingConditioned.members.push(m);
                  }
                }
              } else {
                policy.bindings.push(
                  create(BindingSchema, {
                    role: form.role,
                    members: [...selectedBindings],
                    condition,
                  })
                );
              }
            } else {
              // No condition: merge into existing unconditional binding
              const existing = policy.bindings.find(
                (b) => b.role === form.role && !b.condition?.expression
              );
              if (existing) {
                for (const binding of selectedBindings) {
                  if (!existing.members.includes(binding)) {
                    existing.members.push(binding);
                  }
                }
              } else {
                policy.bindings.push(
                  create(BindingSchema, {
                    role: form.role,
                    members: [...selectedBindings],
                  })
                );
              }
            }
          }
        }
        await updateProjectIamPolicy(projectName, policy);
      } else {
        if (isEditMode) {
          await patchWorkspaceIamPolicy([
            { member: member.binding, roles: selectedRoles },
          ]);
        } else {
          const batchPatch = selectedBindings.map((binding) => {
            const existedRoles = findWorkspaceRolesByMember(binding);
            return {
              member: binding,
              roles: [...new Set([...selectedRoles, ...existedRoles])],
            };
          });
          await patchWorkspaceIamPolicy(batchPatch);
        }
      }
      pushNotification({
        module: "bytebase",
        style: "SUCCESS",
        title: isEditMode ? t("common.updated") : t("common.created"),
      });
      onClose();
    } catch {
      // error shown by store
    } finally {
      setIsRequesting(false);
    }
  };

  const handleRevoke = async () => {
    if (!member) return;
    const isAllUsers =
      member.binding === ALL_USERS_USER_EMAIL ||
      member.binding === `${userBindingPrefix}${ALL_USERS_USER_EMAIL}`;
    const message = isAllUsers
      ? t("settings.members.revoke-allusers-alert")
      : t("settings.members.revoke-access-alert");
    if (!window.confirm(message)) return;

    setIsRequesting(true);
    try {
      if (projectName) {
        const policy = structuredClone(getProjectIamPolicy(projectName));
        for (const binding of policy.bindings) {
          binding.members = binding.members.filter((m) => m !== member.binding);
        }
        policy.bindings = policy.bindings.filter((b) => b.members.length > 0);
        await updateProjectIamPolicy(projectName, policy);
      } else {
        await patchWorkspaceIamPolicy([{ member: member.binding, roles: [] }]);
      }
      pushNotification({
        module: "bytebase",
        style: "INFO",
        title: t("settings.members.revoked"),
      });
      onClose();
    } catch {
      // error shown by store
    } finally {
      setIsRequesting(false);
    }
  };

  // The simple role picker writes bindings without an environment clause, so a
  // DDL/DML role granted here runs everywhere; say so before it is saved.
  const unscopedDirectExecutionKind =
    getRolesEnvironmentLimitationKind(selectedRoles);

  const allowConfirm = isProjectCreateMode
    ? selectedBindings.length > 0 &&
      !!form.role &&
      isExpirationValid(form, maximumRoleExpirationDays) &&
      !(
        roleHasDatabaseLimitation(form.role) &&
        form.databaseMode === "SELECT" &&
        form.databaseResources.length === 0
      ) &&
      !(
        roleHasDatabaseLimitation(form.role) &&
        form.databaseMode === "EXPRESSION" &&
        !validateSimpleExpr(form.exprGroup)
      ) &&
      isDirectExecutionValid(form.directExecution)
    : isEditMode
      ? selectedRoles.length > 0
      : selectedBindings.length > 0 && selectedRoles.length > 0;

  // Project edit mode: show detailed role bindings view
  if (isProjectEditMode && member) {
    const memberEmail = member.user?.email ?? member.binding;
    return (
      <>
        <Sheet open onOpenChange={(nextOpen) => !nextOpen && onClose()}>
          <SheetContent width="wide">
            <SheetHeader>
              <div className="flex min-w-0 items-center justify-between gap-x-2">
                <SheetTitle className="truncate">
                  {t("project.members.edit-member", {
                    member: `${member.title} (${memberEmail})`,
                  })}
                </SheetTitle>
                <Button
                  appearance="outline"
                  onClick={() => setShowNestedGrant(true)}
                >
                  <Plus className="h-4 w-4 mr-1" />
                  {t("settings.members.grant-access")}
                </Button>
              </div>
            </SheetHeader>

            {/* Body — Role Bindings */}
            <SheetBody className="px-6 py-6">
              <div className="flex flex-col gap-y-6">
                {liveProjectRoleBindings.length === 0 && (
                  <div className="text-center text-control-light py-8">
                    {t("common.no-data")}
                  </div>
                )}
                {liveProjectRoleBindings.map((binding, index) => {
                  // Keyed by role and condition so each card keeps its column
                  // widths when another card goes; the API can store the same
                  // pair twice, so repeats are numbered.
                  const identity = `${binding.role}-${binding.condition?.expression ?? ""}`;
                  const repeat = liveProjectRoleBindings
                    .slice(0, index)
                    .filter(
                      (b) =>
                        `${b.role}-${b.condition?.expression ?? ""}` ===
                        identity
                    ).length;
                  const { databaseResources, expiration } =
                    getBindingScope(binding);
                  const directExecution = directExecutionOf(
                    binding.role,
                    readableCondition(binding.parsedExpr)
                  );
                  const isExpired = isBindingPolicyExpired(binding);
                  return (
                    <div
                      key={`${identity}-${repeat}`}
                      className={cn(
                        "border rounded-sm",
                        isExpired && "opacity-60"
                      )}
                    >
                      {/* Role header */}
                      <div className="flex flex-wrap items-center justify-between gap-x-4 gap-y-2 px-4 py-3 bg-control-bg border-b">
                        <div className="flex min-w-0 items-center gap-x-2">
                          <span
                            className={cn(
                              "truncate font-medium text-sm",
                              isExpired && "line-through"
                            )}
                          >
                            {displayRoleTitleFromList(binding.role, roleList)}
                          </span>
                          {isExpired && (
                            <Badge variant="destructive" className="text-xs">
                              {t("common.expired")}
                            </Badge>
                          )}
                        </div>
                        <div className="flex items-center gap-x-4 text-sm">
                          <div className="flex items-center gap-x-2">
                            <span className="text-control-light">
                              {t("common.expiration")}
                            </span>
                            <span className="text-main">
                              {expiration ? (
                                <HumanizeTs
                                  mode="operational"
                                  tsMs={expiration.getTime()}
                                />
                              ) : (
                                t("project.members.never-expires")
                              )}
                            </span>
                          </div>
                          {/* Delete only: the grant form adds a role, so a
                              pencil here would read as editing this one. */}
                          <Button
                            appearance="secondary"
                            size="sm"
                            title={t("common.delete")}
                            disabled={isRequesting}
                            onClick={() => handleDeleteRole(binding)}
                          >
                            <Trash2 className="h-4 w-4" />
                          </Button>
                        </div>
                      </div>

                      {directExecution && (
                        <div className="mx-4 mt-3">
                          <DirectExecutionCallout
                            kind={directExecution.kind}
                            lead="binding"
                            scope={directExecution.scope}
                            environmentList={environmentList}
                            hasEnvTierFeature={hasEnvTierFeature}
                          />
                        </div>
                      )}

                      {/* Database resources table */}
                      <div className="p-4">
                        <MemberBindingResourceTable
                          resources={databaseResources}
                        />
                      </div>
                    </div>
                  );
                })}
              </div>
            </SheetBody>

            {/* Footer */}
            <SheetFooter className="justify-between">
              <div>
                <Button
                  variant="destructive"
                  disabled={isRequesting}
                  onClick={handleRevoke}
                >
                  {t("settings.members.revoke-access")}
                </Button>
              </div>
              <div className="flex items-center gap-x-2">
                <Button appearance="outline" onClick={onClose}>
                  {t("common.cancel")}
                </Button>
                <Button onClick={onClose}>{t("common.ok")}</Button>
              </div>
            </SheetFooter>
          </SheetContent>
        </Sheet>

        {/* Nested grant access drawer (stacked on top, member pre-selected) */}
        {showNestedGrant && (
          <EditMemberRoleDrawer
            projectName={projectName}
            initialBindings={[member.binding]}
            onClose={() => setShowNestedGrant(false)}
          />
        )}
      </>
    );
  }

  // Workspace edit mode, workspace/project create mode — original UI
  return (
    <Sheet open onOpenChange={(nextOpen) => !nextOpen && onClose()}>
      <SheetContent width="medium">
        <SheetHeader>
          <SheetTitle>{t("common.members", { count: 1 })}</SheetTitle>
        </SheetHeader>

        <SheetBody className="px-6 py-6">
          <div className="flex flex-col gap-y-6">
            {!isEditMode && !projectName && hasEmailSetting && (
              <Alert
                variant="info"
                description={t("settings.members.invite-email-hint")}
              />
            )}
            {/* Member input */}
            <FormField
              title={<>{t("settings.members.select-account", { count: 1 })}</>}
            >
              {isEditMode ? (
                <Input value={member.binding} disabled />
              ) : (
                <AccountMultiSelect
                  value={selectedBindings}
                  onChange={setSelectedBindings}
                  includeAllUsers={!isSaaSMode}
                  accountParents={accountParents}
                />
              )}
            </FormField>

            {/* Roles — project create mode uses rich form, otherwise simple multi-select */}
            {isProjectCreateMode ? (
              <div className="flex flex-col gap-y-4">
                <ProjectRoleBindingForm
                  form={form}
                  onChange={setForm}
                  onRemove={() => {}}
                  canRemove={false}
                  projectName={projectName}
                  maximumRoleExpirationDays={maximumRoleExpirationDays}
                />
              </div>
            ) : (
              <>
                <FormField
                  title={<>{t("settings.members.select-role", { count: 2 })}</>}
                >
                  <RoleSelect
                    value={selectedRoles}
                    onChange={setSelectedRoles}
                    scope={projectName ? "project" : undefined}
                  />
                  {unscopedDirectExecutionKind && (
                    <DirectExecutionCallout
                      kind={unscopedDirectExecutionKind}
                      lead="binding"
                      scope={{ type: "all" }}
                      environmentList={environmentList}
                      hasEnvTierFeature={hasEnvTierFeature}
                    />
                  )}
                </FormField>
                {!projectName && (
                  <RolePermissionPreview
                    permissions={selectedRolePermissions}
                  />
                )}
              </>
            )}
          </div>
        </SheetBody>

        <SheetFooter className="justify-between">
          <div>
            {isEditMode && (
              <Button
                variant="destructive"
                disabled={isRequesting}
                onClick={handleRevoke}
              >
                {t("settings.members.revoke-access")}
              </Button>
            )}
          </div>
          <div className="flex items-center gap-x-2">
            <Button appearance="outline" onClick={onClose}>
              {t("common.cancel")}
            </Button>
            <Button
              disabled={!allowConfirm || isRequesting}
              onClick={handleSubmit}
            >
              {isEditMode ? t("common.update") : t("common.create")}
            </Button>
          </div>
        </SheetFooter>
      </SheetContent>
    </Sheet>
  );
}

// ============================================================
// MembersPage
// ============================================================

export function MembersPage({ projectId }: { projectId?: string }) {
  const { t } = useTranslation();
  const workspacePolicy = useAppStore((state) => state.workspacePolicy);
  const patchWorkspaceIamPolicy = useAppStore(
    (state) => state.patchWorkspaceIamPolicy
  );
  const currentUser = useCurrentUser();
  const projectsByName = useAppStore((s) => s.projectsByName);
  const updateProjectIamPolicy = useAppStore(
    (state) => state.updateProjectIamPolicy
  );
  // subscribe to re-render on project cache change
  void projectsByName;

  const userCountInIam = useAppStore((s) => s.userCountInIam());
  const userCountLimit = useAppStore((s) => s.userCountLimit());
  const remainingUserCount = useMemo(
    () => Math.max(0, userCountLimit - userCountInIam),
    [userCountLimit, userCountInIam]
  );

  const projectName = projectId
    ? `${projectNamePrefix}${projectId}`
    : undefined;
  const projectFromName = useProjectByName(projectName ?? "");
  const project = projectName ? projectFromName : undefined;

  const [memberSearchText, setMemberSearchText] = useState("");
  const [memberViewTab, setMemberViewTab] = useState<"MEMBERS" | "ROLES">(
    "MEMBERS"
  );
  const [selectedMembers, setSelectedMembers] = useState<string[]>([]);
  const [showEditMemberDrawer, setShowEditMemberDrawer] = useState(false);
  const [editingMember, setEditingMember] = useState<
    MemberBinding | undefined
  >();
  const [showRequestRoleDialog, setShowRequestRoleDialog] = useState(false);

  const hasRequestRoleFeature = useAppStore((s) =>
    s.hasFeature(PlanFeature.FEATURE_REQUEST_ROLE_WORKFLOW)
  );
  const roleList = useAppStore((state) => state.roleList);

  // IAM policy loads are owned by the parent shells: ProjectRouteGate
  // loads project IAM on /projects/:projectId/members, and
  // DashboardFrameShell's useEnsureWorkspaceCommonData loads workspace IAM
  // (+ referenced groups) on /settings/members. This page just reads them.
  // Subscribe directly to the Zustand projectPoliciesByName slice so the
  // member table re-renders when loadProjectIamPolicy / updateProjectIamPolicy
  // writes to the app store.
  const projectIamPolicy = useAppStore((state) =>
    projectName ? state.projectPoliciesByName[projectName] : undefined
  );
  // getMemberBindings reads member metadata from the group / user /
  // service-account / workload-identity app-store maps via getState(); subscribe
  // to them (plus the IAM policies) so the list refreshes when any of those
  // caches hydrate.
  const groupsByName = useAppStore((s) => s.groupsByName);
  const usersByName = useAppStore((s) => s.usersByName);
  const serviceAccountsByName = useAppStore((s) => s.serviceAccountsByName);
  const workloadIdentitiesByName = useAppStore(
    (s) => s.workloadIdentitiesByName
  );
  const memberBindings = useMemo(
    () =>
      getMemberBindings({
        policies:
          projectName && projectIamPolicy
            ? [{ level: "PROJECT" as const, policy: projectIamPolicy }]
            : workspacePolicy
              ? [{ level: "WORKSPACE" as const, policy: workspacePolicy }]
              : [],
        searchText: memberSearchText,
        ignoreRoles: EMPTY_ROLE_SET,
      }),
    [
      projectName,
      projectIamPolicy,
      workspacePolicy,
      memberSearchText,
      groupsByName,
      usersByName,
      serviceAccountsByName,
      workloadIdentitiesByName,
    ]
  );

  const canSetIamPolicy = project
    ? !isDefaultProject(project.name) &&
      project.state !== State.DELETED &&
      hasProjectPermissionV2(project, "bb.projects.setIamPolicy")
    : hasWorkspacePermissionV2("bb.workspaces.setIamPolicy");

  useProductIntro({
    id: GRANT_ACCESS_PRODUCT_INTRO,
    title: t("workspace-setup-guide.intro.grant-access-title"),
    description: t("workspace-setup-guide.intro.grant-access-description"),
    disabled: !!projectName || !canSetIamPolicy,
  });

  // Whether the current user already holds every PROJECT_OWNER permission
  // (workspace- or project-scoped). hasProjectPermissionV2 falls back to
  // workspace permissions, so a single check covers both contexts. It checks
  // every owner permission rather than `setIamPolicy` alone.
  // Computed inline (not memoized) so it tracks live IAM policy changes, the
  // same way canSetIamPolicy above does — the permission check reads
  // current-user state that isn't captured by [project, roleList] deps.
  const ownerPermissions = project
    ? (roleList.find((r) => r.name === PresetRoleType.PROJECT_OWNER)
        ?.permissions ?? [])
    : [];
  // Require a non-empty owner permission set: when roleList is empty (roles
  // still loading, or listRoles failed and the loader continued with []), a
  // vacuous every() would otherwise report "full access" and wrongly block a
  // non-owner from the request-role flow. Falling through to false keeps the
  // request flow reachable (it has its own permission guard).
  const hasFullProjectAccess =
    !!project &&
    ownerPermissions.length > 0 &&
    ownerPermissions.every((permission) =>
      hasProjectPermissionV2(project, permission as Permission)
    );

  const handleRevokeSelected = async () => {
    if (
      selectedMembers.some(
        (m) => m === `${userBindingPrefix}${currentUser.email}`
      )
    ) {
      pushNotification({
        module: "bytebase",
        style: "WARN",
        title: t("settings.members.cannot-revoke-self"),
      });
      return;
    }
    if (window.confirm(t("settings.members.revoke-access-alert"))) {
      try {
        if (projectName && projectIamPolicy) {
          const policy = structuredClone(projectIamPolicy);
          for (const binding of policy.bindings) {
            binding.members = binding.members.filter(
              (member) => !selectedMembers.includes(member)
            );
          }
          policy.bindings = policy.bindings.filter((b) => b.members.length > 0);
          await updateProjectIamPolicy(projectName, policy);
        } else {
          await patchWorkspaceIamPolicy(
            selectedMembers.map((m) => ({ member: m, roles: [] }))
          );
        }
        pushNotification({
          module: "bytebase",
          style: "INFO",
          title: t("settings.members.revoked"),
        });
        setSelectedMembers([]);
      } catch {
        // error already shown by store
      }
    }
  };

  const handleMemberUpdateBinding = (binding: MemberBinding) => {
    setEditingMember(binding);
    setShowEditMemberDrawer(true);
  };

  const handleMemberRevokeBinding = async (binding: MemberBinding) => {
    try {
      if (projectName && projectIamPolicy) {
        const policy = structuredClone(projectIamPolicy);
        for (const b of policy.bindings) {
          b.members = b.members.filter((member) => member !== binding.binding);
        }
        policy.bindings = policy.bindings.filter((b) => b.members.length > 0);
        await updateProjectIamPolicy(projectName, policy);
      } else {
        await patchWorkspaceIamPolicy([{ member: binding.binding, roles: [] }]);
      }
      pushNotification({
        module: "bytebase",
        style: "INFO",
        title: t("settings.members.revoked"),
      });
    } catch {
      // error already shown by store
    }
  };

  const scope = projectName ? "project" : "workspace";

  const requestRoleButtonState = useMemo(
    () =>
      getRequestRoleButtonState({
        t,
        projectName,
        projectReady: !!project,
        allowRequestRole: project?.allowRequestRole ?? false,
        hasFullProjectAccess,
        hasRequestRoleFeature,
      }),
    [t, projectName, project, hasFullProjectAccess, hasRequestRoleFeature]
  );

  const requestRoleDisabledReason = requestRoleButtonState.disabledReason;

  const setIamPolicyPermissionGuard = useMemo(
    () => getSetIamPolicyPermissionGuardConfig(project),
    [project]
  );

  const PageLayout = projectName ? ProjectPageLayout : WorkspacePageLayout;
  const PageToolbar = projectName ? ProjectPageToolbar : WorkspacePageToolbar;

  return (
    <PageLayout>
      {!projectName && remainingUserCount <= 3 && (
        <Alert
          variant="warning"
          title={t("subscription.usage.user-count.title")}
          description={
            <>
              {remainingUserCount > 0
                ? t("subscription.usage.user-count.remaining", {
                    total: userCountLimit,
                    count: remainingUserCount,
                  })
                : t("subscription.usage.user-count.runoutof", {
                    total: userCountLimit,
                  })}{" "}
              {t("subscription.usage.user-count.upgrade")}
            </>
          }
        />
      )}
      {projectName && (
        <ProjectPageInfo
          description={
            <>
              {t("project.members.description")}{" "}
              <LearnMoreLink href="https://docs.bytebase.com/administration/roles/?source=console#project-roles" />
            </>
          }
        />
      )}

      <PageToolbar>
        <SearchInput
          placeholder={t("settings.members.search-member")}
          value={memberSearchText}
          onChange={(e) => setMemberSearchText(e.target.value)}
        />
        <div className="flex items-center gap-x-2">
          <PermissionGuard {...setIamPolicyPermissionGuard}>
            {({ disabled }) => (
              <div className="flex items-center gap-x-2">
                {memberViewTab === "MEMBERS" && (
                  <Button
                    appearance="outline"
                    disabled={
                      disabled ||
                      !canSetIamPolicy ||
                      selectedMembers.length === 0
                    }
                    onClick={handleRevokeSelected}
                  >
                    {t("settings.members.revoke-access")}
                  </Button>
                )}
                <Button
                  data-product-intro-target={GRANT_ACCESS_PRODUCT_INTRO}
                  disabled={disabled || !canSetIamPolicy}
                  onClick={() => {
                    setEditingMember(undefined);
                    setShowEditMemberDrawer(true);
                  }}
                >
                  <Plus />
                  {t("settings.members.grant-access")}
                </Button>
              </div>
            )}
          </PermissionGuard>
          {requestRoleButtonState.visible &&
            (requestRoleDisabledReason ? (
              <Tooltip content={requestRoleDisabledReason}>
                <span className="inline-flex">
                  <Button
                    disabled
                    onClick={() => setShowRequestRoleDialog(true)}
                  >
                    {hasRequestRoleFeature ? (
                      <ShieldUser className="size-4 mr-1" />
                    ) : (
                      <FeatureBadge
                        feature={PlanFeature.FEATURE_REQUEST_ROLE_WORKFLOW}
                        clickable={false}
                        className="mr-1"
                      />
                    )}
                    {t("issue.title.request-role")}
                  </Button>
                </span>
              </Tooltip>
            ) : (
              <PermissionGuard
                permissions={[...REQUEST_ROLE_REQUIRED_PERMISSIONS]}
                project={project}
              >
                {({ disabled }) => (
                  <Button
                    disabled={disabled}
                    onClick={() => setShowRequestRoleDialog(true)}
                  >
                    <ShieldUser className="size-4 mr-1" />
                    {t("issue.title.request-role")}
                  </Button>
                )}
              </PermissionGuard>
            ))}
        </div>
      </PageToolbar>

      <Tabs
        value={memberViewTab}
        onValueChange={(v) => setMemberViewTab(v as "MEMBERS" | "ROLES")}
      >
        <TabsList>
          <TabsTrigger value="MEMBERS">
            {t("settings.members.view-by-members")}
          </TabsTrigger>
          <TabsTrigger value="ROLES">
            {t("settings.members.view-by-roles")}
          </TabsTrigger>
        </TabsList>
        <TabsPanel value="MEMBERS">
          <div className="py-4">
            <MemberTable
              bindings={memberBindings}
              allowEdit={canSetIamPolicy}
              selectedBindings={selectedMembers}
              onSelectionChange={setSelectedMembers}
              onUpdateBinding={handleMemberUpdateBinding}
              onRevokeBinding={handleMemberRevokeBinding}
              scope={scope}
            />
          </div>
        </TabsPanel>
        <TabsPanel value="ROLES">
          <div className="py-4">
            <MemberTableByRole
              bindings={memberBindings}
              allowEdit={canSetIamPolicy}
              onUpdateBinding={handleMemberUpdateBinding}
              onRevokeBinding={handleMemberRevokeBinding}
              scope={scope}
            />
          </div>
        </TabsPanel>
      </Tabs>

      {project && (
        <RequestRoleSheet
          open={showRequestRoleDialog}
          project={project}
          onClose={() => setShowRequestRoleDialog(false)}
        />
      )}

      {showEditMemberDrawer && (
        <EditMemberRoleDrawer
          member={editingMember}
          projectName={projectName}
          onClose={() => {
            setShowEditMemberDrawer(false);
            setEditingMember(undefined);
          }}
        />
      )}
    </PageLayout>
  );
}