@elevasis/ui 1.15.3 → 1.17.1

package/dist/features/operations/index.js

@@ -0,0 +1,241 @@
+import { ExecutionStats } from '../../chunk-ZGK6XZVY.js';
+import { SubshellLoader } from '../../chunk-ADSSLKKP.js';
+import { PageTitleCaption, TabCountBadge, ResourceCard } from '../../chunk-7S5FS7WW.js';
+import '../../chunk-KBLGVZBD.js';
+import { useStatusFilter, useResourceSearch, useResourcesDomainFilters, filterByDomainFilters } from '../../chunk-XGVD76EL.js';
+import { usePaginationState, useResources, useRecentExecutionsByResource } from '../../chunk-TRVSTJTK.js';
+import '../../chunk-LXHZYSMQ.js';
+import '../../chunk-NJJ3NQ7B.js';
+import '../../chunk-MHW43EOH.js';
+import '../../chunk-F6RBK7NJ.js';
+import '../../chunk-XA34RETF.js';
+import '../../chunk-ELJIFLCB.js';
+import '../../chunk-L4XXM55J.js';
+import '../../chunk-SLVC5OJ2.js';
+import '../../chunk-RNP5R5I3.js';
+import '../../chunk-F25DUOWI.js';
+import '../../chunk-NUULWBAD.js';
+import '../../chunk-SZHARWKU.js';
+import '../../chunk-UEYUPTAD.js';
+import '../../chunk-7ATCF6UL.js';
+import '../../chunk-53GNREDV.js';
+import '../../chunk-QJ2KCHKX.js';
+import '../../chunk-U2522LSW.js';
+import '../../chunk-RULQSZYX.js';
+import { formatRelativeTime } from '../../chunk-FCFLBMVI.js';
+import '../../chunk-CC3SDRIF.js';
+import '../../chunk-ALA56RGZ.js';
+import { useInitialization } from '../../chunk-DVKEEY5J.js';
+import '../../chunk-QEPXAWE2.js';
+import '../../chunk-DD3CCMCZ.js';
+import '../../chunk-BRJ3QZ4E.js';
+import '../../chunk-Q7DJKLEN.js';
+import { Stack, Card, Text, Button, Tabs, Group, Pagination } from '@mantine/core';
+import { IconApps, IconRoute, IconBrain } from '@tabler/icons-react';
+import { useState, useEffect, useMemo } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+function ResourcesPage({
+  initialFilter,
+  onTypeChange,
+  timeRange,
+  onResourceClick,
+  pageSize = 20
+}) {
+  const { organizationReady } = useInitialization();
+  const urlType = initialFilter;
+  const [selectedFilter, setSelectedFilter] = useState(urlType || "all");
+  const statusFilter = useStatusFilter((s) => s.value);
+  const searchQuery = useResourceSearch((s) => s.query);
+  const domainFilters = useResourcesDomainFilters((s) => s.filters);
+  const { page, setPage, offset, totalPages } = usePaginationState(pageSize, [
+    selectedFilter,
+    statusFilter,
+    domainFilters,
+    searchQuery
+  ]);
+  useEffect(() => {
+    if (urlType) {
+      setSelectedFilter(urlType);
+    } else {
+      setSelectedFilter("all");
+    }
+  }, [urlType]);
+  const { data, error, refetch, isFetching } = useResources();
+  const { data: executionData } = useRecentExecutionsByResource({
+    timeRange
+  });
+  const executionLookup = useMemo(() => {
+    if (!executionData?.resources) return /* @__PURE__ */ new Map();
+    return new Map(executionData.resources.map((r) => [r.resourceId, r]));
+  }, [executionData]);
+  const { workflows = [], agents = [], total = 0 } = data || {};
+  const filteredResources = useMemo(() => {
+    const typedWorkflows = (workflows || []).map((w) => ({ ...w, type: "workflow" }));
+    const typedAgents = (agents || []).map((a) => ({ ...a, type: "agent" }));
+    let resources = [];
+    switch (selectedFilter) {
+      case "workflow":
+        resources = typedWorkflows;
+        break;
+      case "agent":
+        resources = typedAgents;
+        break;
+      case "all":
+        resources = [...typedWorkflows, ...typedAgents];
+        break;
+      default:
+        resources = [];
+    }
+    if (statusFilter !== "all") {
+      resources = resources.filter((resource) => resource.status === statusFilter);
+    }
+    resources = filterByDomainFilters(resources, domainFilters);
+    if (searchQuery.trim()) {
+      const q = searchQuery.toLowerCase();
+      resources = resources.filter(
+        (r) => r.name.toLowerCase().includes(q) || r.resourceId.toLowerCase().includes(q) || r.description?.toLowerCase().includes(q)
+      );
+    }
+    const enriched = resources.map((resource) => {
+      const execData = executionLookup.get(resource.resourceId);
+      return {
+        ...resource,
+        lastExecution: execData?.lastExecution,
+        totalExecutions: execData?.totalExecutions || 0,
+        successCount: execData?.successCount || 0,
+        failureCount: execData?.failureCount || 0,
+        successRate: execData?.successRate || 0
+      };
+    });
+    enriched.sort((a, b) => {
+      if (a.lastExecution && b.lastExecution) {
+        return new Date(b.lastExecution).getTime() - new Date(a.lastExecution).getTime();
+      }
+      if (a.lastExecution) return -1;
+      if (b.lastExecution) return 1;
+      return a.name.localeCompare(b.name);
+    });
+    return enriched;
+  }, [workflows, agents, selectedFilter, statusFilter, domainFilters, searchQuery, executionLookup]);
+  if (!organizationReady || isFetching && !data) {
+    return /* @__PURE__ */ jsx(SubshellLoader, {});
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxs(Stack, { children: [
+      /* @__PURE__ */ jsx(PageTitleCaption, { title: "Resources", caption: "Failed to load resources" }),
+      /* @__PURE__ */ jsxs(Card, { children: [
+        /* @__PURE__ */ jsxs(Text, { c: "red", children: [
+          "Error: ",
+          error.message
+        ] }),
+        /* @__PURE__ */ jsx(Button, { onClick: () => refetch(), children: "Retry" })
+      ] })
+    ] });
+  }
+  const getResourceCount = (type) => {
+    const filteredW = filterByDomainFilters(workflows, domainFilters);
+    const filteredA = filterByDomainFilters(agents, domainFilters);
+    switch (type) {
+      case "workflow":
+        return filteredW.length;
+      case "agent":
+        return filteredA.length;
+      case "all":
+        return filteredW.length + filteredA.length;
+      default:
+        return 0;
+    }
+  };
+  const handleTabChange = (value) => {
+    if (value) {
+      const filterValue = value;
+      setSelectedFilter(filterValue);
+      onTypeChange(filterValue === "all" ? void 0 : filterValue);
+    }
+  };
+  const isFiltering = filteredResources.length !== total;
+  const paginatedResources = filteredResources.slice(offset, offset + pageSize);
+  return /* @__PURE__ */ jsxs(Stack, { children: [
+    /* @__PURE__ */ jsx(
+      PageTitleCaption,
+      {
+        title: "Resources",
+        caption: isFiltering ? `${filteredResources.length} Resources Available, ${total - filteredResources.length} Filtered` : `${total} Resources Available`
+      }
+    ),
+    /* @__PURE__ */ jsx(Tabs, { value: selectedFilter, onChange: handleTabChange, variant: "default", children: /* @__PURE__ */ jsxs(Tabs.List, { children: [
+      /* @__PURE__ */ jsx(
+        Tabs.Tab,
+        {
+          value: "all",
+          leftSection: /* @__PURE__ */ jsx(IconApps, { size: 16 }),
+          rightSection: /* @__PURE__ */ jsx(TabCountBadge, { count: getResourceCount("all"), isLoading: isFetching }),
+          children: "All"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Tabs.Tab,
+        {
+          value: "workflow",
+          leftSection: /* @__PURE__ */ jsx(IconRoute, { size: 16 }),
+          rightSection: /* @__PURE__ */ jsx(TabCountBadge, { count: getResourceCount("workflow"), isLoading: isFetching }),
+          children: "Workflows"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Tabs.Tab,
+        {
+          value: "agent",
+          leftSection: /* @__PURE__ */ jsx(IconBrain, { size: 16 }),
+          rightSection: /* @__PURE__ */ jsx(TabCountBadge, { count: getResourceCount("agent"), isLoading: isFetching }),
+          children: "Agents"
+        }
+      )
+    ] }) }),
+    filteredResources.length > 0 ? /* @__PURE__ */ jsx(Stack, { gap: "xs", children: paginatedResources.map((resource) => {
+      const isDormant = resource.totalExecutions === 0;
+      return /* @__PURE__ */ jsx(
+        ResourceCard,
+        {
+          resource,
+          onClick: onResourceClick,
+          layout: "row",
+          dormant: isDormant,
+          "data-resource-id": resource.resourceId,
+          lastRunLabel: resource.lastExecution ? `Last run ${formatRelativeTime(resource.lastExecution)}` : void 0,
+          rightSection: /* @__PURE__ */ jsx(
+            ExecutionStats,
+            {
+              totalExecutions: resource.totalExecutions,
+              successCount: resource.successCount,
+              failureCount: resource.failureCount,
+              successRate: resource.successRate,
+              compact: true
+            }
+          ),
+          style: isDormant ? { opacity: 0.7 } : void 0
+        },
+        resource.resourceId
+      );
+    }) }) : /* @__PURE__ */ jsx(Card, { children: /* @__PURE__ */ jsxs(Stack, { align: "center", children: [
+      /* @__PURE__ */ jsxs(Text, { c: "dimmed", children: [
+        "No resources found for ",
+        selectedFilter === "all" ? "any type" : selectedFilter
+      ] }),
+      /* @__PURE__ */ jsx(Text, { size: "sm", c: "dimmed", children: selectedFilter === "all" ? "Register workflows or agents to see them here" : `Register ${selectedFilter}s to see them here` })
+    ] }) }),
+    totalPages(filteredResources.length) > 1 && /* @__PURE__ */ jsx(Group, { justify: "flex-start", children: /* @__PURE__ */ jsx(
+      Pagination,
+      {
+        size: "sm",
+        total: totalPages(filteredResources.length),
+        value: page,
+        onChange: setPage,
+        boundaries: 1
+      }
+    ) })
+  ] });
+}
+
+export { ResourcesPage };