Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

4.7 KB
Raw Blame
import { type ReactNode } from "react";

import { DialogController } from "@/src/components/design-system/DialogController/DialogController";
import { CreateProjectMemberDialog } from "@/src/features/rbac/components/CreateProjectMemberDialog";
import {
  useEntitlementLimit,
  useHasEntitlement,
} from "@/src/features/entitlements/hooks";
import { default as useIsFeatureEnabled } from "@/src/features/feature-flags/hooks/useIsFeatureEnabled";
import { usePostHogClientCapture } from "@/src/features/posthog-analytics/usePostHogClientCapture";
import { useHasOrganizationAccess } from "@/src/features/rbac/utils/checkOrganizationAccess";
import { useHasProjectAccess } from "@/src/features/rbac/utils/checkProjectAccess";
import { api } from "@/src/utils/api";

type CreateProjectMemberDialogControllerProps = {
  orgId: string;
  project: { id: string; name: string } | undefined;
  children: (control: {
    hasAccess: boolean;
    hasOnlySingleProjectAccess: boolean;
    isSubmitting: boolean;
    usageLimit:
      | {
          current: number | undefined;
          max: number;
        }
      | undefined;
    openDialog: () => void;
  }) => ReactNode;
};

export function CreateProjectMemberDialogController({
  orgId,
  project,
  children,
}: CreateProjectMemberDialogControllerProps) {
  const hasOrgAccess = useHasOrganizationAccess({
    organizationId: orgId,
    scope: "organizationMembers:CUD",
  });
  const hasProjectAccess = useHasProjectAccess({
    projectId: project?.id,
    scope: "projectMembers:CUD",
  });
  const canManageOrgOwnership = useHasOrganizationAccess({
    organizationId: orgId,
    scope: "organizationMembers:manageOwnership",
  });
  // Org owners outrank any project role override they hold.
  const canManageProjectOwnership =
    useHasProjectAccess({
      projectId: project?.id,
      scope: "projectMembers:manageOwnership",
    }) || canManageOrgOwnership;
  const hasProjectRoleEntitlement = useHasEntitlement("rbac-project-roles");
  const isAiGatewayEnabled = useIsFeatureEnabled("aiGateway", {
    enableForAdmins: false,
    organizationId: orgId,
  });
  const hasOnlySingleProjectAccess =
    !hasOrgAccess && hasProjectAccess && hasProjectRoleEntitlement;
  const hasAccess = hasOrgAccess || hasOnlySingleProjectAccess;

  const orgMemberLimit = useEntitlementLimit("organization-member-count");
  const orgMemberCount = api.members.allFromOrg.useQuery(
    {
      orgId,
      page: 0,
      limit: 1,
    },
    {
      enabled: hasOrgAccess,
    },
  ).data?.totalCount;
  const inviteCount = api.members.allInvitesFromOrg.useQuery(
    {
      orgId,
      page: 0,
      limit: 1,
    },
    {
      enabled: hasOrgAccess,
    },
  ).data?.totalCount;

  const utils = api.useUtils();
  const capture = usePostHogClientCapture();
  const createProjectMemberMutation = api.members.create.useMutation({
    onSuccess: () => utils.members.invalidate(),
    // The form owns error presentation; avoid a duplicate global toast.
    onError: () => undefined,
  });
  const usageLimit =
    typeof orgMemberLimit === "number"
      ? {
          current: (orgMemberCount ?? 0) + (inviteCount ?? 0),
          max: orgMemberLimit,
        }
      : undefined;

  return (
    <DialogController
      renderDialog={({ closeDialog }) => (
        <CreateProjectMemberDialog
          project={project}
          hasOnlySingleProjectAccess={hasOnlySingleProjectAccess}
          hasProjectRoleEntitlement={hasProjectRoleEntitlement}
          canManageOrgOwnership={canManageOrgOwnership}
          canManageProjectOwnership={canManageProjectOwnership}
          isAiGatewayEnabled={isAiGatewayEnabled}
          isPending={createProjectMemberMutation.isPending}
          createProjectMember={(values) => {
            capture(
              project
                ? "project_settings:send_membership_invitation"
                : "organization_settings:send_membership_invitation",
              {
                orgRole: values.orgRole,
                projectRole: values.projectRole,
              },
            );

            return createProjectMemberMutation
              .mutateAsync({
                orgId,
                email: values.email,
                orgRole: values.orgRole,
                projectId: project?.id,
                projectRole:
                  values.projectRole === "NONE"
                    ? undefined
                    : values.projectRole,
              })
              .then(() => undefined);
          }}
          onSuccess={closeDialog}
        />
      )}
    >
      {({ openDialog }) =>
        children({
          hasAccess,
          hasOnlySingleProjectAccess,
          isSubmitting: createProjectMemberMutation.isPending,
          usageLimit,
          openDialog,
        })
      }
    </DialogController>
  );
}