@hed-hog/core 0.0.387 → 0.0.390

package/hedhog/frontend/app/pages/_components/system-page-types.ts.ejs

@@ -0,0 +1,56 @@
+import type {
+  PageManifestEntry,
+  PageTemplateKind,
+} from '@/lib/pages-manifest';
+
+export type PaginatedResponse<T> = {
+  data: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+};
+
+export type MenuNode = {
+  id: number;
+  menu_id: number | null;
+  slug: string;
+  url: string;
+  icon: string | null;
+  order: number | null;
+  name?: string;
+  menu_locale?: Array<{ name?: string; locale?: { code: string } }>;
+  _count?: { role_menu?: number };
+};
+
+export type RoleSummary = {
+  id: number;
+  slug?: string;
+  name?: string;
+  role_locale?: Array<{ name?: string; description?: string }>;
+  role_menu?: Array<{ role_id: number; menu_id: number }>;
+};
+
+export type RouteSummary = {
+  id: number;
+  url: string | null;
+  method: string | null;
+  role_route?: Array<{ route_id: number; role_id: number }>;
+};
+
+/** Rota da API casada (ou não) com um endpoint inferido do código da página. */
+export type ResolvedEndpoint = {
+  method: string;
+  url: string;
+  route: RouteSummary | null;
+  roles: string[];
+};
+
+export type SystemPage = PageManifestEntry & {
+  template: PageTemplateKind;
+  menu: MenuNode | null;
+  menuParent: MenuNode | null;
+  menuLabel: string | null;
+  menuRoleCount: number;
+  /** Sem menu, sem referência no código e rota estática — candidata a resíduo. */
+  isResidue: boolean;
+};

package/hedhog/frontend/app/pages/_components/use-system-pages.ts.ejs

@@ -0,0 +1,171 @@
+'use client';
+
+import {
+  detectTemplate,
+  getManifestPages,
+  isLikelyResidue,
+  normalizeRoute,
+} from '@/lib/pages-manifest';
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+import { useMemo } from 'react';
+import type {
+  MenuNode,
+  PaginatedResponse,
+  ResolvedEndpoint,
+  RoleSummary,
+  RouteSummary,
+  SystemPage,
+} from './system-page-types';
+
+const LARGE_PAGE_SIZE = 10000;
+
+export function getMenuLabel(menu: MenuNode): string {
+  return menu.name || menu.menu_locale?.[0]?.name || menu.slug;
+}
+
+export function getRoleLabel(role: RoleSummary): string {
+  return role.role_locale?.[0]?.name || role.name || role.slug || `#${role.id}`;
+}
+
+/**
+ * Cruza as páginas do manifesto (verdade do código) com menu e rotas do banco.
+ * Nenhum dos dois lados é autoritativo sozinho: existem páginas sem menu
+ * (órfãs) e menus apontando para URLs que não têm arquivo correspondente.
+ */
+export function useSystemPages() {
+  const { request, currentLocaleCode } = useApp();
+
+  const {
+    data: menus = [],
+    isLoading: isLoadingMenus,
+    refetch: refetchMenus,
+  } = useQuery<MenuNode[]>({
+    queryKey: ['system-pages-menus', currentLocaleCode],
+    queryFn: async () => {
+      const response = await request<MenuNode[]>({
+        url: '/menu/all',
+        method: 'GET',
+      });
+
+      return Array.isArray(response.data) ? response.data : [];
+    },
+    placeholderData: (previous) => previous ?? [],
+  });
+
+  const { data: roles = [] } = useQuery<RoleSummary[]>({
+    queryKey: ['system-pages-roles', currentLocaleCode],
+    queryFn: async () => {
+      const response = await request<PaginatedResponse<RoleSummary>>({
+        url: `/role?pageSize=${LARGE_PAGE_SIZE}`,
+        method: 'GET',
+      });
+
+      return response.data?.data ?? [];
+    },
+    placeholderData: (previous) => previous ?? [],
+  });
+
+  const { data: routes = [] } = useQuery<RouteSummary[]>({
+    queryKey: ['system-pages-routes'],
+    queryFn: async () => {
+      const response = await request<PaginatedResponse<RouteSummary>>({
+        url: `/route?pageSize=${LARGE_PAGE_SIZE}`,
+        method: 'GET',
+      });
+
+      return response.data?.data ?? [];
+    },
+    placeholderData: (previous) => previous ?? [],
+  });
+
+  const menuById = useMemo(
+    () => new Map(menus.map((menu) => [menu.id, menu])),
+    [menus]
+  );
+
+  const menuByRoute = useMemo(() => {
+    const map = new Map<string, MenuNode>();
+
+    menus.forEach((menu) => {
+      if (!menu.url) {
+        return;
+      }
+
+      const key = normalizeRoute(menu.url);
+
+      // O primeiro menu encontrado vence: URLs duplicadas existem no seed e a
+      // tela de menus é o lugar certo para resolver esse conflito.
+      if (!map.has(key)) {
+        map.set(key, menu);
+      }
+    });
+
+    return map;
+  }, [menus]);
+
+  const roleById = useMemo(
+    () => new Map(roles.map((role) => [role.id, role])),
+    [roles]
+  );
+
+  const routeByKey = useMemo(() => {
+    const map = new Map<string, RouteSummary>();
+
+    routes.forEach((route) => {
+      if (!route.url || !route.method) {
+        return;
+      }
+
+      map.set(`${route.method.toUpperCase()} ${normalizeRoute(route.url)}`, route);
+    });
+
+    return map;
+  }, [routes]);
+
+  const pages = useMemo<SystemPage[]>(() => {
+    return getManifestPages().map((entry) => {
+      const menu = menuByRoute.get(normalizeRoute(entry.route)) ?? null;
+      const menuParent =
+        menu?.menu_id != null ? (menuById.get(menu.menu_id) ?? null) : null;
+
+      return {
+        ...entry,
+        template: detectTemplate(entry.features),
+        menu,
+        menuParent,
+        menuLabel: menu ? getMenuLabel(menu) : null,
+        menuRoleCount: menu?._count?.role_menu ?? 0,
+        isResidue: isLikelyResidue(entry, Boolean(menu)),
+      };
+    });
+  }, [menuById, menuByRoute]);
+
+  const resolveEndpoints = useMemo(() => {
+    return (page: SystemPage): ResolvedEndpoint[] =>
+      page.endpoints.map((endpoint) => {
+        const route =
+          routeByKey.get(
+            `${endpoint.method} ${normalizeRoute(endpoint.url)}`
+          ) ?? null;
+
+        const roleLabels = (route?.role_route ?? [])
+          .map((link) => roleById.get(link.role_id))
+          .filter((role): role is RoleSummary => Boolean(role))
+          .map(getRoleLabel)
+          .sort();
+
+        return { ...endpoint, route, roles: roleLabels };
+      });
+  }, [roleById, routeByKey]);
+
+  return {
+    pages,
+    menus,
+    roles,
+    routes,
+    roleById,
+    isLoading: isLoadingMenus,
+    resolveEndpoints,
+    refetchMenus,
+  };
+}