Files
memos/web/src/components/Settings/LinkedIdentitySection.tsx
T
2026-11-17 23:18:15 +08:00

197 lines
7.7 KiB
TypeScript

import { Badge, Button, List } from "@usememos/ui";
import { useEffect, useMemo, useState } from "react";
import InfoChip from "@/components/Settings/InfoChip";
import { getIdentityProviderTypeLabel, getSSOProviderUid } from "@/components/Settings/sso-display";
import { identityProviderServiceClient, userServiceClient } from "@/connect";
import { findManagedResource, useConfigurationStatus } from "@/hooks/useConfigurationQueries";
import useCurrentUser from "@/hooks/useCurrentUser";
import { absolutifyLink } from "@/lib/browser";
import { handleError } from "@/lib/error";
import { showErrorToast, toast } from "@/lib/toast";
import { IdentityProvider, IdentityProvider_Type } from "@/types/proto/api/idp_service_pb";
import { LinkedIdentity } from "@/types/proto/api/user_service_pb";
import { useTranslate } from "@/utils/i18n";
import { storeOAuthState } from "@/utils/oauth";
import ManagedByConfigurationChip from "./ManagedByConfigurationChip";
import SettingGroup from "./SettingGroup";
import { SettingList } from "./SettingList";
interface LinkedIdentityRow {
name: string;
providerUid: string;
title: string;
typeLabel: string;
externalUid: string;
isLinked: boolean;
linkedIdentity?: LinkedIdentity;
identityProvider: IdentityProvider;
}
const LinkedIdentitySection = () => {
const t = useTranslate();
const currentUser = useCurrentUser();
const configurationStatus = useConfigurationStatus();
const [identityProviderList, setIdentityProviderList] = useState<IdentityProvider[]>([]);
const [linkedIdentityList, setLinkedIdentityList] = useState<LinkedIdentity[]>([]);
const fetchData = async () => {
if (!currentUser?.name) {
return;
}
const [{ identityProviders }, { linkedIdentities }] = await Promise.all([
identityProviderServiceClient.listIdentityProviders({}),
userServiceClient.listLinkedIdentities({ parent: currentUser.name }),
]);
setIdentityProviderList(identityProviders);
setLinkedIdentityList(linkedIdentities);
};
useEffect(() => {
if (!currentUser?.name) {
return;
}
fetchData().catch((error: unknown) => {
handleError(error, showErrorToast, {
context: "Load linked identities",
});
});
}, [currentUser?.name]);
const oauthIdentityProviders = useMemo(
() => identityProviderList.filter((identityProvider) => identityProvider.type === IdentityProvider_Type.OAUTH2),
[identityProviderList],
);
const linkedIdentityByProviderName = useMemo(() => {
const mapping = new Map<string, LinkedIdentity>();
for (const linkedIdentity of linkedIdentityList) {
if (!mapping.has(linkedIdentity.identityProvider)) {
mapping.set(linkedIdentity.identityProvider, linkedIdentity);
}
}
return mapping;
}, [linkedIdentityList]);
const rows = useMemo<LinkedIdentityRow[]>(
() =>
oauthIdentityProviders.map((identityProvider) => {
const linkedIdentity = linkedIdentityByProviderName.get(identityProvider.name);
return {
name: identityProvider.name,
providerUid: getSSOProviderUid(identityProvider.name),
title: identityProvider.title,
typeLabel: getIdentityProviderTypeLabel(identityProvider.type),
externalUid: linkedIdentity?.externalUid ?? "",
isLinked: !!linkedIdentity,
linkedIdentity,
identityProvider,
};
}),
[linkedIdentityByProviderName, oauthIdentityProviders],
);
const handleLinkIdentityProvider = async (identityProvider: IdentityProvider) => {
if (!currentUser?.name) {
return;
}
const redirectUri = absolutifyLink("/auth/callback");
const oauth2Config = identityProvider.config?.config?.case === "oauth2Config" ? identityProvider.config.config.value : undefined;
if (!oauth2Config) {
showErrorToast(t("setting.sso.invalid-config"));
return;
}
try {
const returnUrl = `${window.location.pathname}${window.location.search}${window.location.hash}`;
const { state, codeChallenge } = await storeOAuthState(identityProvider.name, "link", returnUrl, currentUser.name);
let authUrl = `${oauth2Config.authUrl}?client_id=${
oauth2Config.clientId
}&redirect_uri=${encodeURIComponent(redirectUri)}&state=${state}&response_type=code&scope=${encodeURIComponent(
oauth2Config.scopes.join(" "),
)}`;
if (codeChallenge) {
authUrl += `&code_challenge=${codeChallenge}&code_challenge_method=S256`;
}
window.location.href = authUrl;
} catch (error) {
handleError(error, showErrorToast, {
context: "Failed to initiate OAuth flow",
fallbackMessage: t("error.link-identity-failed"),
});
}
};
const handleUnlinkIdentityProvider = async (row: LinkedIdentityRow) => {
if (!row.linkedIdentity?.name) {
return;
}
try {
await userServiceClient.deleteLinkedIdentity({
name: row.linkedIdentity.name,
});
await fetchData();
toast.add({ title: t("setting.sso.unlink-success", { name: row.title }), type: "success" });
} catch (error) {
handleError(error, showErrorToast, {
context: "Delete linked identity",
fallbackMessage: t("error.unlink-identity-failed"),
});
}
};
return (
<SettingGroup showSeparator title={t("setting.sso.accounts-title")} description={t("setting.sso.accounts-description")}>
{rows.length === 0 ? (
<p className="py-6 text-center mu-body text-mu-text-secondary">{t("setting.sso.no-sso-found")}</p>
) : (
<SettingList>
{rows.map((row) => (
<List.Item key={row.name} className="flex items-start gap-3">
<div className="min-w-0 flex-1 space-y-2">
<div className="flex flex-wrap items-center gap-2">
<span className="min-w-0 mu-label break-words text-mu-text">{row.title}</span>
<Badge size="xs">{row.typeLabel}</Badge>
</div>
<div className="flex flex-wrap items-center gap-2">
<InfoChip label={t("setting.sso.provider-uid")} value={row.providerUid} />
</div>
<div className="flex flex-wrap items-center gap-2">
<Badge tone={row.isLinked ? "neutral" : "outline"}>
{row.isLinked ? t("setting.sso.linked") : t("setting.sso.not-linked")}
</Badge>
{row.isLinked && row.externalUid ? (
<InfoChip label={t("setting.sso.extern-uid")} value={row.externalUid} tooltip={row.externalUid} />
) : null}
<ManagedByConfigurationChip resource={findManagedResource(configurationStatus, row.linkedIdentity?.name ?? "")} />
</div>
<p className="mu-caption text-mu-text-secondary">
{row.isLinked ? t("setting.sso.extern-uid-description") : t("setting.sso.not-linked-description")}
</p>
</div>
<div className="shrink-0">
{row.linkedIdentity ? (
// A link the configuration declares is unlinked in its file, not here.
findManagedResource(configurationStatus, row.linkedIdentity.name) ? null : (
<Button variant="neutral" onClick={() => handleUnlinkIdentityProvider(row)}>
{t("common.unlink")}
</Button>
)
) : (
<Button variant="neutral" onClick={() => handleLinkIdentityProvider(row.identityProvider)}>
{t("common.link")}
</Button>
)}
</div>
</List.Item>
))}
</SettingList>
)}
</SettingGroup>
);
};
export default LinkedIdentitySection;