Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
import { batch, createEffect, createMemo, createSignal, on, onCleanup, onMount } from 'solid-js';
import { apiFetch, apiErrorFromResponse, getOrgID } from '@/utils/apiClient';
import { eventBus } from '@/stores/events';
import { createStore } from 'solid-js/store';
import { notificationStore } from '@/stores/notifications';
import { logger } from '@/utils/logger';
import {
getSSOCopySuccessMessage,
getSSOCopyErrorMessage,
getSSOConnectionTestErrorMessage,
getSSOMetadataFetchErrorMessage,
getSSOMetadataUrlRequiredMessage,
getSSOProviderDeleteErrorMessage,
getSSOProviderDeleteSuccessMessage,
getSSOProviderDetailsLoadErrorMessage,
getSSOProviderSaveErrorMessage,
getSSOProviderSaveSuccessMessage,
getSSOProviderToggleErrorMessage,
getSSOProviderToggleSuccessMessage,
getSSOTestResultPresentation,
} from '@/utils/ssoProviderPresentation';
import type {
MetadataPreview,
ProviderForm,
SSOProvider,
SSOProvidersResponse,
SSOProviderTestResult,
} from '@/components/Settings/ssoProvidersModel';
import {
buildMetadataPreviewPayload,
buildProviderPayload,
buildProviderTestPayload,
canTestProviderForm,
createEmptyProviderForm,
mapProviderDetailsToForm,
} from '@/components/Settings/ssoProvidersModel';
interface SSOProvidersPanelProps {
onConfigUpdated?: () => void;
canManage?: boolean;
currentUser?: string;
}
export const useSSOProvidersState = (props: SSOProvidersPanelProps) => {
const [providers, setProviders] = createSignal<SSOProvider[]>([]);
const [loading, setLoading] = createSignal(true);
const [saving, setSaving] = createSignal(false);
const [editorFeedback, setEditorFeedback] = createSignal<{
tone: 'success' | 'error';
message: string;
} | null>(null);
const [showModal, setShowModalValue] = createSignal(false);
const [editingProvider, setEditingProvider] = createSignal<SSOProvider | null>(null);
const [form, setForm] = createStore<ProviderForm>(createEmptyProviderForm());
const [advancedOpen, setAdvancedOpen] = createSignal(false);
const [deleteConfirm, setDeleteConfirmValue] = createSignal<string | null>(null);
const [publicUrl, setPublicUrl] = createSignal('');
const [testing, setTesting] = createSignal(false);
const [testResult, setTestResult] = createSignal<SSOProviderTestResult | null>(null);
const [showMetadataPreview, setShowMetadataPreviewValue] = createSignal(false);
const [metadataPreview, setMetadataPreview] = createSignal<MetadataPreview | null>(null);
const [loadingPreview, setLoadingPreview] = createSignal(false);
const [loadError, setLoadError] = createSignal(false);
const [providersLoaded, setProvidersLoaded] = createSignal(false);
const [loadingDetails, setLoadingDetails] = createSignal(false);
const [mutating, setMutating] = createSignal(false);
const managementAllowed = createMemo(() => props.canManage !== false);
const authenticatedUser = createMemo(() => props.currentUser);
const currentOrg = () => getOrgID() || 'default';
const [selectedOrg, setSelectedOrg] = createSignal(currentOrg());
const [selectedUser, setSelectedUser] = createSignal(authenticatedUser());
const [selectedManagement, setSelectedManagement] = createSignal(managementAllowed());
let disposed = false;
let contextVersion = 0;
let editorVersion = 0;
let readController: AbortController | undefined;
let detailController: AbortController | undefined;
let testController: AbortController | undefined;
let previewController: AbortController | undefined;
let mutationController: AbortController | undefined;
const contextIsCurrent = () =>
!disposed &&
selectedOrg() === currentOrg() &&
selectedUser() === authenticatedUser() &&
selectedManagement() === managementAllowed();
const canManage = () => contextIsCurrent() && managementAllowed();
const canEdit = () =>
canManage() && providersLoaded() && !loading() && !loadError() && !mutating();
const isCurrentProvider = (provider: SSOProvider) => providers().includes(provider);
const requestOptions = (controller: AbortController) => ({
signal: controller.signal,
expectedOrgID: selectedOrg(),
retry: false,
});
const clearPreviewAndTest = () => {
testController?.abort();
previewController?.abort();
testController = previewController = undefined;
batch(() => {
setTesting(false);
setTestResult(null);
setLoadingPreview(false);
setMetadataPreview(null);
setShowMetadataPreviewValue(false);
});
};
const setShowMetadataPreview = (open: boolean) => {
setShowMetadataPreviewValue(open);
if (!open) setMetadataPreview(null);
};
const clearEditor = () => {
editorVersion += 1;
detailController?.abort();
detailController = undefined;
clearPreviewAndTest();
batch(() => {
setLoadingDetails(false);
setShowModalValue(false);
setEditingProvider(null);
setEditorFeedback(null);
setForm(createEmptyProviderForm());
setAdvancedOpen(false);
});
};
const setShowModal = (open: boolean) => {
if (!open && !mutating()) clearEditor();
};
const setDeleteConfirm = (id: string | null) => {
if (mutating()) return;
if (id === null || (canEdit() && providers().some((provider) => provider.id === id))) {
clearEditor();
setDeleteConfirmValue(id);
}
};
// A test/preview describes exactly the submitted draft, not later edits in
// the same dialog. Closing/replacing that dialog also releases its payload.
createEffect(
on(
() => JSON.stringify(form),
() => {
clearPreviewAndTest();
setEditorFeedback(null);
},
{ defer: true },
),
);
const loadProviders = async () => {
if (!contextIsCurrent() || readController) return;
const version = contextVersion;
const controller = new AbortController();
const isCurrent = () =>
contextIsCurrent() && version === contextVersion && readController === controller;
readController = controller;
setLoading(true);
setLoadError(false);
setProvidersLoaded(false);
setProviders([]);
try {
const response = await apiFetch('/api/security/sso/providers', requestOptions(controller));
if (!isCurrent()) return;
if (!response.ok) throw new Error('Provider read refused');
const data = (await response.json()) as SSOProvidersResponse;
if (!isCurrent()) return;
const ids = new Set<string>();
// A missing or malformed list is unknown, not an empty configuration.
if (
!data ||
!Array.isArray(data.providers) ||
data.providers.some((provider) => {
if (
!provider ||
typeof provider.id !== 'string' ||
!provider.id.trim() ||
ids.has(provider.id) ||
typeof provider.name !== 'string' ||
!['oidc', 'saml'].includes(provider.type) ||
typeof provider.enabled !== 'boolean'
)
return true;
ids.add(provider.id);
return false;
})
)
throw new Error('Invalid provider inventory');
setProviders(data.providers);
setProvidersLoaded(true);
setPublicUrl(window.location.origin);
// The optional public URL is not evidence that a provider read failed.
try {
const statusResponse = await apiFetch('/api/security/status', requestOptions(controller));
if (statusResponse.ok) {
const status = (await statusResponse.json()) as { publicUrl?: string };
if (isCurrent() && typeof status.publicUrl === 'string' && status.publicUrl)
setPublicUrl(status.publicUrl);
}
} catch {
/* Keep the current origin when optional status is unavailable. */
}
} catch {
if (!isCurrent()) return;
setLoadError(true);
logger.error('[SSOProvidersPanel] Failed to load providers.');
} finally {
if (isCurrent()) {
readController = undefined;
setLoading(false);
}
}
};
const resetContext = () => {
contextVersion += 1;
readController?.abort();
mutationController?.abort();
readController = mutationController = undefined;
batch(() => {
setSelectedOrg(currentOrg());
setSelectedUser(authenticatedUser());
setSelectedManagement(managementAllowed());
clearEditor();
setProviders([]);
setProvidersLoaded(false);
setPublicUrl('');
setDeleteConfirmValue(null);
setSaving(false);
setMutating(false);
});
void loadProviders();
};
createEffect(on([managementAllowed, authenticatedUser], resetContext, { defer: true }));
const unsubscribeOrg = eventBus.on('org_switched', resetContext);
onMount(() => void loadProviders());
onCleanup(() => {
disposed = true;
contextVersion += 1;
readController?.abort();
mutationController?.abort();
clearEditor();
setProviders([]);
unsubscribeOrg();
});
const openAddModal = (type: 'oidc' | 'saml') => {
if (!canEdit()) return;
clearEditor();
setDeleteConfirmValue(null);
setForm('type', type);
setShowModalValue(true);
};
const openEditModal = async (provider: SSOProvider) => {
if (!canEdit() || !isCurrentProvider(provider)) return;
clearEditor();
setDeleteConfirmValue(null);
const version = editorVersion;
const context = contextVersion;
const controller = new AbortController();
detailController = controller;
const isCurrent = () =>
canEdit() &&
version === editorVersion &&
context === contextVersion &&
detailController === controller;
setLoadingDetails(true);
try {
const response = await apiFetch(
`/api/security/sso/providers/${encodeURIComponent(provider.id)}`,
requestOptions(controller),
);
if (!isCurrent()) return;
if (!response.ok) throw new Error('Provider details refused');
const data = await response.json();
if (!isCurrent()) return;
if (!data || data.id !== provider.id || data.type !== provider.type)
throw new Error('Mismatched provider details');
setForm(mapProviderDetailsToForm(data));
setEditingProvider(provider);
setShowModalValue(true);
} catch {
if (!isCurrent()) return;
logger.error('[SSOProvidersPanel] Failed to load provider details.');
notificationStore.error(getSSOProviderDetailsLoadErrorMessage());
} finally {
if (detailController === controller) {
detailController = undefined;
setLoadingDetails(false);
}
}
};
const beginMutation = () => {
if (!canEdit()) return;
const context = contextVersion;
const controller = new AbortController();
mutationController = controller;
setMutating(true);
return {
options: requestOptions(controller),
isCurrent: () =>
contextIsCurrent() && context === contextVersion && mutationController === controller,
finish: () => {
if (mutationController !== controller) return;
mutationController = undefined;
setMutating(false);
setSaving(false);
},
};
};
const handleSave = async (event?: Event) => {
event?.preventDefault();
if (!showModal() || testing() || loadingPreview()) return;
const mutation = beginMutation();
if (!mutation) return;
const isEdit = Boolean(editingProvider());
const providerId = editingProvider()?.id;
const payload = buildProviderPayload(form);
setEditorFeedback(null);
setSaving(true);
try {
const response = await apiFetch(
isEdit
? `/api/security/sso/providers/${encodeURIComponent(providerId!)}`
: '/api/security/sso/providers',
{
...mutation.options,
method: isEdit ? 'PUT' : 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
},
);
if (!mutation.isCurrent()) return;
if (!response.ok) {
const error = await apiErrorFromResponse(response);
if (!mutation.isCurrent()) return;
setEditorFeedback({ tone: 'error', message: getSSOProviderSaveErrorMessage(error) });
logger.error('[SSOProvidersPanel] Failed to save provider.', { status: response.status });
return;
}
notificationStore.success(getSSOProviderSaveSuccessMessage(isEdit));
clearEditor();
await loadProviders();
if (mutation.isCurrent()) props.onConfigUpdated?.();
} catch {
if (!mutation.isCurrent()) return;
// A lost response cannot establish whether the server saved the change.
logger.error('[SSOProvidersPanel] Failed to save provider.');
setEditorFeedback({ tone: 'error', message: getSSOProviderSaveErrorMessage() });
} finally {
mutation.finish();
}
};
const handleDelete = async (providerId: string) => {
if (
deleteConfirm() !== providerId ||
!providers().some((provider) => provider.id === providerId)
)
return;
const mutation = beginMutation();
if (!mutation) return;
try {
const response = await apiFetch(
`/api/security/sso/providers/${encodeURIComponent(providerId)}`,
{
...mutation.options,
method: 'DELETE',
},
);
if (!mutation.isCurrent()) return;
if (!response.ok) throw new Error('Provider deletion refused');
notificationStore.success(getSSOProviderDeleteSuccessMessage());
setDeleteConfirmValue(null);
await loadProviders();
if (mutation.isCurrent()) props.onConfigUpdated?.();
} catch {
if (!mutation.isCurrent()) return;
logger.error('[SSOProvidersPanel] Failed to delete provider.');
notificationStore.error(getSSOProviderDeleteErrorMessage());
} finally {
mutation.finish();
}
};
const handleToggleEnabled = async (provider: SSOProvider) => {
if (!isCurrentProvider(provider)) return;
const mutation = beginMutation();
if (!mutation) return;
clearEditor();
try {
// Only writable fields; omitted nested configuration and secret are preserved.
const response = await apiFetch(
`/api/security/sso/providers/${encodeURIComponent(provider.id)}`,
{
...mutation.options,
method: 'PUT',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
id: provider.id,
name: provider.name,
type: provider.type,
enabled: !provider.enabled,
displayName: provider.displayName,
iconUrl: provider.iconUrl,
priority: provider.priority,
allowedGroups: provider.allowedGroups ?? [],
allowedDomains: provider.allowedDomains ?? [],
allowedEmails: provider.allowedEmails ?? [],
groupsClaim: provider.groupsClaim,
groupRoleMappings: provider.groupRoleMappings,
}),
},
);
if (!mutation.isCurrent()) return;
if (!response.ok) throw new Error('Provider update refused');
notificationStore.success(getSSOProviderToggleSuccessMessage(!provider.enabled));
await loadProviders();
if (mutation.isCurrent()) props.onConfigUpdated?.();
} catch {
if (!mutation.isCurrent()) return;
logger.error('[SSOProvidersPanel] Failed to toggle provider.');
notificationStore.error(getSSOProviderToggleErrorMessage());
} finally {
mutation.finish();
}
};
const copyToClipboard = async (text: string, label: string) => {
if (!contextIsCurrent()) return;
const context = contextVersion;
const editor = editorVersion;
const isCurrent = () =>
contextIsCurrent() && context === contextVersion && editor === editorVersion;
try {
await navigator.clipboard.writeText(text);
if (!isCurrent()) return;
const message = getSSOCopySuccessMessage(label);
if (showModal()) {
setEditorFeedback({ tone: 'success', message });
} else {
notificationStore.success(message);
}
} catch {
if (!isCurrent()) return;
const message = getSSOCopyErrorMessage(label);
if (showModal()) {
setEditorFeedback({ tone: 'error', message });
} else {
notificationStore.error(message);
}
}
};
const testResultPresentation = createMemo(() =>
testResult() ? getSSOTestResultPresentation(Boolean(testResult()?.success)) : null,
);
const testConnection = async () => {
if (!canEdit() || !showModal() || !canTest() || testing() || loadingPreview()) return;
const controller = new AbortController();
testController = controller;
const version = editorVersion;
const context = contextVersion;
const payload = JSON.stringify(buildProviderTestPayload(form));
const isCurrent = () =>
canEdit() &&
showModal() &&
version === editorVersion &&
context === contextVersion &&
testController === controller &&
payload === JSON.stringify(buildProviderTestPayload(form));
setEditorFeedback(null);
setTesting(true);
setTestResult(null);
try {
const response = await apiFetch('/api/security/sso/providers/test', {
...requestOptions(controller),
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: payload,
});
if (!isCurrent()) return;
if (!response.ok) throw new Error('Connection test refused');
const result = (await response.json()) as SSOProviderTestResult;
if (isCurrent()) setTestResult(result);
} catch {
if (!isCurrent()) return;
logger.error('[SSOProvidersPanel] Test connection failed.');
setTestResult({ success: false, message: getSSOConnectionTestErrorMessage() });
} finally {
if (testController === controller) {
testController = undefined;
setTesting(false);
}
}
};
const canTest = () => canTestProviderForm(form);
const fetchMetadataPreview = async () => {
if (!canEdit() || !showModal() || testing() || loadingPreview()) {
return;
}
setEditorFeedback(null);
if (!form.samlIdpMetadataUrl.trim()) {
setEditorFeedback({ tone: 'error', message: getSSOMetadataUrlRequiredMessage() });
return;
}
const controller = new AbortController();
previewController = controller;
const version = editorVersion;
const context = contextVersion;
const payload = JSON.stringify(buildMetadataPreviewPayload(form));
const isCurrent = () =>
canEdit() &&
showModal() &&
version === editorVersion &&
context === contextVersion &&
previewController === controller &&
payload === JSON.stringify(buildMetadataPreviewPayload(form));
setLoadingPreview(true);
setMetadataPreview(null);
try {
const response = await apiFetch('/api/security/sso/providers/metadata/preview', {
...requestOptions(controller),
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: payload,
});
if (!isCurrent()) return;
if (!response.ok) {
const error = await apiErrorFromResponse(response);
if (!isCurrent()) return;
setEditorFeedback({ tone: 'error', message: getSSOMetadataFetchErrorMessage(error) });
logger.error('[SSOProvidersPanel] Metadata preview failed.', { status: response.status });
return;
}
const preview = (await response.json()) as MetadataPreview;
if (!isCurrent()) return;
setMetadataPreview(preview);
setShowMetadataPreview(true);
} catch {
if (!isCurrent()) return;
logger.error('[SSOProvidersPanel] Metadata preview failed.');
setEditorFeedback({ tone: 'error', message: getSSOMetadataFetchErrorMessage() });
} finally {
if (previewController === controller) {
previewController = undefined;
setLoadingPreview(false);
}
}
};
return {
providers,
loading,
loadError,
loadProviders,
loadingDetails,
canEdit,
mutating,
saving,
editorFeedback,
showModal,
setShowModal,
editingProvider,
form,
setForm,
advancedOpen,
setAdvancedOpen,
deleteConfirm,
setDeleteConfirm,
publicUrl,
testing,
testResult,
setTestResult,
showMetadataPreview,
setShowMetadataPreview,
metadataPreview,
loadingPreview,
canManage,
openAddModal,
openEditModal,
handleSave,
handleDelete,
handleToggleEnabled,
copyToClipboard,
testResultPresentation,
testConnection,
canTest,
fetchMetadataPreview,
};
};