Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

9.3 KB
Raw Blame
import { createMemo, createSignal } from 'solid-js';
import type {
  Resource,
  ResourceCapability,
  ResourceChangeKind,
  ResourceChangeSourceAdapter,
  ResourceChangeSourceType,
  ResourceRelationship,
} from '@/types/resource';
import type { ResourceIntelligence } from '@/types/aiIntelligence';
import { AIAPI } from '@/api/ai';
import { ActionAuditAPI } from '@/api/actionAudit';
import { ResourceAPI } from '@/api/resources';
import { createNonSuspendingQuery } from '@/hooks/createNonSuspendingQuery';
import type { ActionAuditListResponse } from '@/types/actionAudit';
import { getAPIReadAccessErrorMessage } from '@/utils/apiAccessError';

interface UseResourceDetailDrawerHistoryStateOptions {
  resource: Resource;
  enableRemoteHistory?: boolean;
}

type ResourceFacetBundle = Awaited<ReturnType<typeof ResourceAPI.getFacetBundle>> | null;
type ActionAuditRequest = {
  id: string;
  limit: number;
};

type TimelineFacetRequest = {
  id: string;
  kind: ResourceChangeKind | '';
  sourceType: ResourceChangeSourceType | '';
  sourceAdapter: ResourceChangeSourceAdapter | '';
};

export const useResourceDetailDrawerHistoryState = (
  options: UseResourceDetailDrawerHistoryStateOptions,
) => {
  const resource = () => options.resource;
  const enableRemoteHistory = options.enableRemoteHistory ?? true;

  const resourceFacetId = createMemo(() => resource().id.trim());
  const [timelineKindFilter, setTimelineKindFilter] = createSignal<ResourceChangeKind | ''>('');
  const [timelineSourceTypeFilter, setTimelineSourceTypeFilter] = createSignal<
    ResourceChangeSourceType | ''
  >('');
  const [timelineSourceAdapterFilter, setTimelineSourceAdapterFilter] = createSignal<
    ResourceChangeSourceAdapter | ''
  >('');

  const resourceFacetRequest = createMemo(() => {
    if (!enableRemoteHistory) return null;
    const id = resourceFacetId();
    return id ? { id } : null;
  });

  const resourceFacetsState = createNonSuspendingQuery<ResourceFacetBundle, { id: string }>({
    source: resourceFacetRequest,
    fetcher: async (request) => {
      if (!request?.id) return null;
      return ResourceAPI.getFacetBundle(request.id, { limit: 25 });
    },
    initialValue: null,
  });
  const resourceFacets = resourceFacetsState.value;
  const refetchResourceFacets = resourceFacetsState.refetch;

  const resourceIntelligenceState = createNonSuspendingQuery<
    ResourceIntelligence | null,
    { id: string }
  >({
    source: resourceFacetRequest,
    fetcher: async (request) => {
      if (!request?.id) return null;
      return AIAPI.getResourceIntelligence(request.id);
    },
    initialValue: null,
  });
  const resourceIntelligence = resourceIntelligenceState.value;

  const actionAuditRequest = createMemo(() => {
    if (!enableRemoteHistory) return null;
    const id = resourceFacetId();
    return id ? { id, limit: 5 } : null;
  });

  const actionAuditState = createNonSuspendingQuery<ActionAuditListResponse, ActionAuditRequest>({
    source: actionAuditRequest,
    fetcher: async (request) =>
      ActionAuditAPI.listActionAudits({ resourceId: request.id, limit: request.limit }),
    initialValue: {
      audits: [],
      count: 0,
      resourceId: resourceFacetId() || undefined,
      available: false,
    },
  });
  const actionAuditResponse = actionAuditState.value;

  const timelineFacetRequest = createMemo(() => {
    if (!enableRemoteHistory) return null;
    const id = resourceFacetId();
    if (!id) return null;
    const kind = timelineKindFilter();
    const sourceType = timelineSourceTypeFilter();
    const sourceAdapter = timelineSourceAdapterFilter();
    if (!kind && !sourceType && !sourceAdapter) return null;
    return { id, kind, sourceType, sourceAdapter };
  });

  const timelineFacetsState = createNonSuspendingQuery<ResourceFacetBundle, TimelineFacetRequest>({
    source: timelineFacetRequest,
    fetcher: async (request) => {
      if (!request) return null;
      return ResourceAPI.getFacetBundle(request.id, {
        limit: 25,
        kind: request.kind || undefined,
        sourceType: request.sourceType || undefined,
        sourceAdapter: request.sourceAdapter || undefined,
      });
    },
    initialValue: null,
  });
  const timelineFacets = timelineFacetsState.value;
  const refetchTimelineFacets = timelineFacetsState.refetch;

  const resourceFacetsAccessError = createMemo(() =>
    getAPIReadAccessErrorMessage(resourceFacetsState.error()),
  );
  const timelineFacetsAccessError = createMemo(() =>
    timelineFacetRequest() ? getAPIReadAccessErrorMessage(timelineFacetsState.error()) : null,
  );
  // The query owner withdraws its value on denial. Snapshot/unfiltered
  // fallbacks must not put that evidence back under the denied request.
  const resourceTimeline = createMemo(() =>
    resourceFacetsAccessError()
      ? []
      : (resourceFacets()?.recentChanges ?? resource().recentChanges ?? []),
  );
  const resourceFacetCapabilities = createMemo<readonly ResourceCapability[]>(() =>
    resourceFacetsAccessError()
      ? []
      : (resourceFacets()?.capabilities ?? resource().capabilities ?? []),
  );
  const resourceFacetRelationships = createMemo<readonly ResourceRelationship[]>(() =>
    resourceFacetsAccessError()
      ? []
      : (resourceFacets()?.relationships ?? resource().relationships ?? []),
  );
  const resourceFacetCounts = createMemo(() =>
    resourceFacetsAccessError()
      ? null
      : (resourceFacets()?.counts ?? resource().facetCounts ?? null),
  );
  const historyFacetBundle = createMemo(() =>
    timelineFacetRequest() ? (timelineFacets() ?? resourceFacets()) : resourceFacets(),
  );
  const historyFacetCounts = createMemo(() =>
    timelineFacetsAccessError()
      ? null
      : (historyFacetBundle()?.counts ?? resourceFacetCounts() ?? null),
  );
  const historyRecentChanges = createMemo(() =>
    timelineFacetsAccessError() ? [] : (historyFacetBundle()?.recentChanges ?? resourceTimeline()),
  );
  const historyTimeline = createMemo(() => historyRecentChanges());
  const hasTimelineFilters = createMemo(() =>
    Boolean(timelineKindFilter() || timelineSourceTypeFilter() || timelineSourceAdapterFilter()),
  );
  const historyLoadingLabel = createMemo(() => {
    if (timelineFacetRequest()) {
      return timelineFacetsState.loading()
        ? 'Refreshing filtered changes...'
        : timelineFacetsState.error()
          ? 'Filtered changes unavailable'
          : 'Filtered changes loaded';
    }
    return resourceFacetsState.loading()
      ? 'Refreshing changes...'
      : resourceFacetsState.error()
        ? 'Changes unavailable'
        : 'Changes loaded';
  });
  const resourceTimelineCount = createMemo(
    () => historyFacetCounts()?.recentChanges ?? historyRecentChanges().length,
  );
  const sortedResourceTimeline = createMemo(() =>
    [...historyTimeline()].sort((left, right) => {
      const leftTime = Date.parse(left.observedAt || '');
      const rightTime = Date.parse(right.observedAt || '');
      return (
        (Number.isFinite(rightTime) ? rightTime : 0) - (Number.isFinite(leftTime) ? leftTime : 0)
      );
    }),
  );
  const resourceActionAudits = createMemo(() => actionAuditResponse().audits ?? []);
  const actionAuditCount = createMemo(
    () => actionAuditResponse().count ?? resourceActionAudits().length,
  );
  const actionAuditAvailable = createMemo(() =>
    Boolean(actionAuditResponse().available || resourceActionAudits().length > 0),
  );
  const actionAuditLoadingLabel = createMemo(() =>
    actionAuditState.loading()
      ? 'Refreshing actions...'
      : actionAuditState.error()
        ? 'Actions unavailable'
        : 'Actions loaded',
  );
  const sortedActionAudits = createMemo(() =>
    [...resourceActionAudits()].sort((left, right) => {
      const leftTime = Date.parse(left.updatedAt || left.createdAt || '');
      const rightTime = Date.parse(right.updatedAt || right.createdAt || '');
      return (
        (Number.isFinite(rightTime) ? rightTime : 0) - (Number.isFinite(leftTime) ? leftTime : 0)
      );
    }),
  );
  const facetBundleError = createMemo(() => {
    const error = timelineFacetRequest()
      ? timelineFacetsState.error()
      : resourceFacetsState.error();
    if (!error) return '';
    return (
      getAPIReadAccessErrorMessage(error) ||
      (error as Error)?.message ||
      'Failed to load resource history'
    );
  });
  const actionAuditError = createMemo(() => {
    const error = actionAuditState.error();
    if (!error) return '';
    return (
      getAPIReadAccessErrorMessage(error) ||
      (error as Error)?.message ||
      'Failed to load action history'
    );
  });

  const refetchHistoryFacets = () => {
    if (timelineFacetRequest()) {
      return refetchTimelineFacets();
    }
    return refetchResourceFacets();
  };

  return {
    timelineKindFilter,
    setTimelineKindFilter,
    timelineSourceTypeFilter,
    setTimelineSourceTypeFilter,
    timelineSourceAdapterFilter,
    setTimelineSourceAdapterFilter,
    resourceIntelligence,
    resourceTimeline,
    resourceFacetCapabilities,
    resourceFacetRelationships,
    historyFacetCounts,
    historyRecentChanges,
    hasTimelineFilters,
    historyLoadingLabel,
    resourceTimelineCount,
    sortedResourceTimeline,
    actionAuditAvailable,
    actionAuditCount,
    actionAuditError,
    actionAuditLoadingLabel,
    sortedActionAudits,
    facetBundleError,
    refetchActionAudits: actionAuditState.refetch,
    refetchHistoryFacets,
  };
};