rastack 0.0.55 → 0.0.57

package/admin/useAdmin.ts

@@ -20,6 +20,7 @@ import {
   FilterKind,
   FilterOption,
   PAGE_SIZE,
+  adminResources,
   boolFilterOptions,
   buildWriteBody,
   changelistHeaders,
@@ -414,6 +415,96 @@ export function useResourceForm(
   return { model, loading, loadError, submitError, done };
 }
 
+/** Per-model record count, plus the resource it belongs to. */
+export interface ModelStat {
+  resource: AdminResource;
+  count: number;
+}
+
+/** The manifest-derived, engine-counted numbers the Insight dashboard renders. */
+export interface DashboardStats {
+  loading: boolean;
+  /** Every admin model with its live record count, richest first. */
+  models: ModelStat[];
+  totalRecords: number;
+  modelCount: number;
+  appCount: number;
+  /** Total foreign-key relations across the schema. */
+  relationCount: number;
+  /** Record totals grouped by app, richest first. */
+  byApp: { app: string; count: number; models: number }[];
+}
+
+/**
+ * Count every admin model's rows from the engine (one cheap `page_size=1` list
+ * per model, read from the DRF `count`) and roll them up into the numbers the
+ * Insight dashboard shows. All real, all live — the dashboard only animates how
+ * they appear.
+ */
+export function useDashboardStats(
+  engine: RastackEngine,
+  resources: AdminResource[],
+): DashboardStats {
+  const models = useMemo(() => adminResources(resources), [resources]);
+  const [counts, setCounts] = useState<Record<string, number> | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    setCounts(null);
+    (async () => {
+      const entries = await Promise.all(
+        models.map(async (r): Promise<[string, number]> => {
+          try {
+            const res: EngineResult = await engine.handle(
+              "GET",
+              listPath(r.app, r.model),
+              { page_size: "1" },
+              undefined,
+            );
+            return [r.key, ok(res) ? readListEnvelope(res.body).count : 0];
+          } catch {
+            return [r.key, 0];
+          }
+        }),
+      );
+      if (!cancelled) setCounts(Object.fromEntries(entries));
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [engine, models]);
+
+  return useMemo((): DashboardStats => {
+    const loading = counts === null;
+    const withCounts: ModelStat[] = models
+      .map((resource) => ({ resource, count: counts?.[resource.key] ?? 0 }))
+      .sort((a, b) => b.count - a.count || a.resource.label.localeCompare(b.resource.label));
+
+    const appMap = new Map<string, { count: number; models: number }>();
+    for (const m of withCounts) {
+      const cur = appMap.get(m.resource.app) ?? { count: 0, models: 0 };
+      cur.count += m.count;
+      cur.models += 1;
+      appMap.set(m.resource.app, cur);
+    }
+
+    return {
+      loading,
+      models: withCounts,
+      totalRecords: withCounts.reduce((s, m) => s + m.count, 0),
+      modelCount: models.length,
+      appCount: appMap.size,
+      relationCount: models.reduce(
+        (s, r) => s + r.fields.filter((f) => f.type === "fk").length,
+        0,
+      ),
+      byApp: [...appMap.entries()]
+        .map(([app, v]) => ({ app, count: v.count, models: v.models }))
+        .sort((a, b) => b.count - a.count || a.app.localeCompare(b.app)),
+    };
+  }, [counts, models]);
+}
+
 /** Delete a record via the engine; resolves true on success. */
 export function useDeleteRecord(
   engine: RastackEngine,