rl-core-front 0.14.4 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rl-core-front",
-  "version": "0.14.4",
+  "version": "0.15.0",
   "description": "Telas e componentes Next.js do core: login com 2FA, usuários, RBAC, auditoria, logs e listagens com filtro dinâmico",
   "author": "Rodrigo Liberti",
   "license": "MIT",

package/src/_services/api/schema.d.ts

@@ -122,6 +122,60 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/auth/device/login": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Login pelo aparelho confiável: sem senha e sem 2FA
+         * @description O app apresenta o vínculo criado num login completo, depois de destravá-lo com a biometria. O vínculo rotaciona a cada uso.
+         */
+        post: operations["AuthController_deviceLogin"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/devices": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Aparelhos confiáveis da conta */
+        get: operations["AuthController_devices"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/auth/devices/{family}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /** Esquece um aparelho: o próximo acesso dele exige senha + 2FA */
+        delete: operations["AuthController_forgetDevice"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/auth/profile": {
         parameters: {
             query?: never;
@@ -784,6 +838,38 @@ export interface paths {
         patch: operations["NotificationsController_markAsRead"];
         trace?: never;
     };
+    "/exports/{handler}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: operations["ExportController_request"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/exports/{jobId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["ExportController_download"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/jobs/{id}": {
         parameters: {
             query?: never;
@@ -920,11 +1006,45 @@ export interface components {
             accessToken?: string;
             /** @description Apenas para client=mobile */
             refreshToken?: string;
+            /** @description Vínculo do aparelho (client=mobile). Guardar no Keychain: é o que abre os próximos acessos sem senha e sem 2FA */
+            deviceToken?: string;
         };
         RefreshTokenCommand: {
             /** @description Refresh token do cliente mobile. No web vem pelo cookie. */
             refreshToken?: string;
         };
+        LogoutCommand: {
+            /** @description Refresh token do cliente mobile. No web vem pelo cookie. */
+            refreshToken?: string;
+            /** @description Enviar apenas para esquecer o aparelho junto com a saída */
+            deviceToken?: string;
+        };
+        DeviceLoginCommand: {
+            /** @description Vínculo do aparelho, guardado no Keychain */
+            deviceToken: string;
+        };
+        DeviceLoginResponse: {
+            user: components["schemas"]["SessionUserResponse"];
+            accessToken: string;
+            refreshToken: string;
+            /** @description O vínculo rotaciona a cada uso: guarde este */
+            deviceToken: string;
+        };
+        TrustedDeviceResponse: {
+            /** Format: uuid */
+            id: string;
+            /**
+             * Format: uuid
+             * @description Identifica o aparelho ao longo das rotações — é o que se revoga
+             */
+            family: string;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            expiresAt: string;
+            ipAddress?: Record<string, never> | null;
+            userAgent?: Record<string, never> | null;
+        };
         RegenerateBackupCommand: {
             /** @description Código TOTP atual (6 dígitos) */
             code: string;
@@ -969,7 +1089,7 @@ export interface components {
         UpdateProfileCommand: {
             name?: string;
             lastName?: string;
-            phone?: string;
+            phone?: Record<string, never> | null;
         };
         ChangePasswordCommand: {
             currentPassword: string;
@@ -1357,6 +1477,29 @@ export interface components {
             /** @description Dado extra. `route` é usado pelo cliente para navegar. */
             payload?: Record<string, never>;
         };
+        RequestExportCommand: {
+            /**
+             * @description Filtro dinâmico, no mesmo formato da listagem
+             * @example {"createdAt":{"$BETWEEN":["2026-01-01","2026-06-30"]}}
+             */
+            filter?: string;
+            /**
+             * @description Busca livre, a mesma da toolbar da listagem
+             * @example marvel
+             */
+            search?: string;
+            /** @description Campo de ordenação do catálogo */
+            sortBy?: string;
+            /** @enum {string} */
+            sortDir?: "ASC" | "DESC";
+        };
+        ExportAcceptedResponse: {
+            /** @example 184 */
+            jobId: string;
+            /** @example funkos */
+            name: string;
+        };
+        StreamableFile: Record<string, never>;
         JobProgressResponse: {
             /** @example 120 */
             processed: number;
@@ -1416,6 +1559,13 @@ export interface components {
             state: string;
             /** Format: uuid */
             ownerId: string | null;
+            /**
+             * @example {
+             *       "handler": "funkos",
+             *       "fileName": "funkos_2026-09-04.xlsx"
+             *     }
+             */
+            payload: Record<string, never> | null;
             /** @example 2 */
             attemptsMade: number;
             /** @example 69 */
@@ -1572,9 +1722,70 @@ export interface operations {
         };
         requestBody: {
             content: {
-                "application/json": components["schemas"]["RefreshTokenCommand"];
+                "application/json": components["schemas"]["LogoutCommand"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
             };
         };
+    };
+    AuthController_deviceLogin: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["DeviceLoginCommand"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["DeviceLoginResponse"];
+                };
+            };
+        };
+    };
+    AuthController_devices: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TrustedDeviceResponse"][];
+                };
+            };
+        };
+    };
+    AuthController_forgetDevice: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                family: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
         responses: {
             200: {
                 headers: {
@@ -2966,6 +3177,67 @@ export interface operations {
             };
         };
     };
+    ExportController_request: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                handler: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RequestExportCommand"];
+            };
+        };
+        responses: {
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ExportAcceptedResponse"];
+                };
+            };
+        };
+    };
+    ExportController_download: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                jobId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description A planilha */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["StreamableFile"];
+                };
+            };
+            /** @description Ainda em geração */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description O arquivo expirou */
+            410: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     JobStatusController_status: {
         parameters: {
             query?: never;
@@ -2989,7 +3261,9 @@ export interface operations {
     };
     QueueAdminController_counts: {
         parameters: {
-            query?: never;
+            query?: {
+                queue?: "jobs" | "exports";
+            };
             header?: never;
             path?: never;
             cookie?: never;
@@ -3012,6 +3286,9 @@ export interface operations {
                 state: "waiting" | "active" | "completed" | "failed" | "delayed";
                 page: string;
                 limit: string;
+                sortBy?: "name" | "attemptsMade" | "percent" | "createdAt" | "failedReason";
+                sortDir?: "ASC" | "DESC";
+                queue?: "jobs" | "exports";
             };
             header?: never;
             path?: never;
@@ -3031,7 +3308,9 @@ export interface operations {
     };
     QueueAdminController_retry: {
         parameters: {
-            query?: never;
+            query?: {
+                queue?: "jobs" | "exports";
+            };
             header?: never;
             path: {
                 id: string;
@@ -3050,7 +3329,9 @@ export interface operations {
     };
     QueueAdminController_remove: {
         parameters: {
-            query?: never;
+            query?: {
+                queue?: "jobs" | "exports";
+            };
             header?: never;
             path: {
                 id: string;

package/src/components/app-shell.tsx

@@ -4,6 +4,7 @@ import {
   ChevronDown,
   ChevronRight,
   History,
+  Keyboard,
   LayoutDashboard,
   ListChecks,
   LogOut,
@@ -11,6 +12,7 @@ import {
   ScrollText,
   Settings,
   ShieldCheck,
+  SlidersHorizontal,
   User,
   Users,
 } from "lucide-react";
@@ -143,6 +145,28 @@ const PROFILE: NavItem = {
   icon: User,
   perm: null,
 };
+/** Sem permissão: atalho é do teclado, não do papel. */
+const SHORTCUTS: NavItem = {
+  key: "nav.shortcuts",
+  href: "/atalhos",
+  icon: Keyboard,
+  perm: null,
+};
+
+/**
+ * O que é do usuário, e não do sistema: o perfil dele e as teclas.
+ *
+ * Fica no rodapé do menu e sem permissão nenhuma — nenhum dos dois opera coisa
+ * alguma, e esconder "como uso o teclado" de alguém não protege nada. Separado
+ * de "Administração", que é o grupo de quem opera o sistema dos outros.
+ */
+const SETTINGS_CHILDREN: NavItem[] = [PROFILE, SHORTCUTS];
+
+const SETTINGS_GROUP: NavGroup = {
+  key: "nav.settings",
+  icon: SlidersHorizontal,
+  children: SETTINGS_CHILDREN,
+};
 const ADMIN_CHILDREN: NavItem[] = [
   {
     key: "nav.users",
@@ -269,6 +293,7 @@ export function AppShell({
     const known: NavItem[] = [
       DASHBOARD,
       PROFILE,
+      SHORTCUTS,
       ...ADMIN_CHILDREN,
       // Achata pai e filhos: a rota de um filho precisa ser barrada como
       // qualquer outra, e o pai de grupo não tem rota para checar.
@@ -444,7 +469,7 @@ export function AppShell({
       )}
 
       <div className="mt-1">
-        <NavLink item={PROFILE} mini={mini} />
+        <NavGroupBlock group={SETTINGS_GROUP} mini={mini} />
       </div>
     </div>
   );

package/src/components/ui/create-button.tsx

@@ -0,0 +1,64 @@
+"use client";
+
+import { Plus } from "lucide-react";
+import * as React from "react";
+
+import { Button, type ButtonProps } from "#core/components/ui/button";
+import { useI18n } from "#core/contexts";
+import {
+  CREATE_SHORTCUT_KEYS,
+  CREATE_SHORTCUT_LABEL,
+  useShortcut,
+} from "#core/hooks/use-shortcut";
+
+export interface CreateButtonProps extends Omit<ButtonProps, "children"> {
+  /** O que o botão diz. Vem traduzido da tela: cada uma cria uma coisa. */
+  label: string;
+  /** O que abrir. É a mesma função do clique e do atalho — não há dois caminhos. */
+  onCreate: () => void;
+  /** Some com o ícone, para quem quer só o texto. */
+  hideIcon?: boolean;
+}
+
+/**
+ * O botão de cadastrar de qualquer listagem — e, junto dele, o atalho.
+ *
+ * Existe para o atalho não depender de alguém lembrar: quem põe o botão ganha
+ * o teclado no mesmo gesto, e tela nova nasce com o comportamento em vez de
+ * herdá-lo por disciplina. É o par do `Esc` que o modal já entende — um fecha,
+ * o outro abre.
+ *
+ * O atalho vive **enquanto o botão existe**. Como toda tela já esconde o botão
+ * de quem não pode criar, esconder o botão desliga o atalho sozinho: não há
+ * uma segunda checagem de permissão para sair do lugar.
+ *
+ * ```tsx
+ * {canCreate && (
+ *   <CreateButton size="sm" label={t("funkos.newItem")} onCreate={openCreate} />
+ * )}
+ * ```
+ */
+const CreateButton = React.forwardRef<HTMLButtonElement, CreateButtonProps>(
+  ({ label, onCreate, hideIcon = false, title, ...props }, ref) => {
+    const { t } = useI18n();
+
+    useShortcut(CREATE_SHORTCUT_KEYS, onCreate, { double: true });
+
+    return (
+      <Button
+        ref={ref}
+        onClick={onCreate}
+        // Atalho que ninguém descobre é atalho que não existe: o título é onde
+        // ele se apresenta. Quem passar o seu próprio continua mandando.
+        title={title ?? t("common.shortcutHint", { keys: CREATE_SHORTCUT_LABEL })}
+        {...props}
+      >
+        {!hideIcon && <Plus className="h-4 w-4" />}
+        {label}
+      </Button>
+    );
+  },
+);
+CreateButton.displayName = "CreateButton";
+
+export { CreateButton };

package/src/components/ui/data-table.tsx

@@ -26,9 +26,10 @@ import {
   ChevronLeft,
   ChevronRight,
   Filter,
+  GripVertical,
   SlidersHorizontal,
 } from "lucide-react";
-import type { JSX } from "react";
+import type { JSX, PointerEvent as ReactPointerEvent } from "react";
 import { useMemo, useState } from "react";
 
 import { countConditions } from "#core/_utils/advanced-filter";
@@ -53,6 +54,7 @@ import {
 import { useI18n } from "#core/contexts";
 import { useColumnVisibility } from "#core/hooks/use-column-visibility";
 import type { FiltersState } from "#core/hooks/use-filters";
+import { cn } from "#core/lib/utils";
 
 export const dataTableFeatures = tableFeatures({
   columnVisibilityFeature,
@@ -113,6 +115,19 @@ interface DataTableProps<T extends RowData> {
    * indistinguível de bug, e manda o usuário procurar defeito onde não há.
    */
   emptyMessage?: string;
+  /**
+   * Arrastar a linha pela alça para reordenar a listagem.
+   *
+   * A tabela avisa **onde soltou** — a linha `activeId` sobre a linha `overId`
+   * — e não mexe em `data`: quem guarda a ordem é o servidor, e a lista volta
+   * de lá. Mandar a ordem inteira faria duas abas abertas sobrescreverem uma à
+   * outra com o estado velho de quem salvou por último.
+   *
+   * Exige `getRowId` — é dele que saem os dois ids. A alça fica inerte
+   * enquanto uma coluna estiver ordenando: ali a posição na tela não é a ordem
+   * gravada, e arrastar escreveria uma sequência que ninguém viu.
+   */
+  onRowReorder?: (activeId: string, overId: string) => void;
 }
 
 /** Extras que uma coluna pode declarar em `meta`. */
@@ -165,10 +180,14 @@ export function DataTable<T extends RowData>({
   filters,
   hiddenFilterFields,
   emptyMessage,
+  onRowReorder,
 }: DataTableProps<T>): JSX.Element {
   const { t } = useI18n();
   const [colsOpen, setColsOpen] = useState(false);
   const [filtersOpen, setFiltersOpen] = useState(false);
+  /** A linha na mão e a linha embaixo do dedo, enquanto o arrasto dura. */
+  const [draggedRow, setDraggedRow] = useState<string | null>(null);
+  const [targetRow, setTargetRow] = useState<string | null>(null);
 
   const { hiddenColumns, saveHiddenColumns } = useColumnVisibility(storageKey);
   const columnVisibility = useMemo<ColumnVisibilityState>(() => {
@@ -232,7 +251,58 @@ export function DataTable<T extends RowData>({
     : table.getFilteredRowModel().rows.length;
   const { pageIndex, pageSize } = table.state.pagination;
   const pageCount = table.getPageCount();
-  const colSpan = table.getVisibleLeafColumns().length || 1;
+  const reorderable = Boolean(onRowReorder && getRowId);
+  /*
+    Ordenando por uma coluna, a sequência da tela não é a que está gravada:
+    soltar a linha "em cima da terceira" escreveria uma ordem que ninguém viu.
+    A coluna da alça continua no lugar para a tabela não mudar de largura — só
+    o botão fica inerte, e o `title` diz o motivo.
+  */
+  const canReorder = reorderable && (table.state.sorting ?? []).length === 0;
+  const colSpan =
+    (table.getVisibleLeafColumns().length || 1) + (reorderable ? 1 : 0);
+
+  const startRowDrag =
+    (rowId: string) =>
+    (event: ReactPointerEvent<HTMLButtonElement>): void => {
+      // A captura mantém os eventos na alça mesmo com o dedo já longe dela;
+      // sem ela, o arrasto morre no primeiro pixel fora do botão.
+      event.currentTarget.setPointerCapture(event.pointerId);
+      setDraggedRow(rowId);
+      setTargetRow(rowId);
+    };
+
+  /**
+   * Que linha está embaixo do ponteiro.
+   *
+   * Pelo ponto e não pelo alvo do evento: com a captura ativa, todo `move`
+   * chega na alça de origem, e é o `elementFromPoint` que sabe onde o dedo
+   * está de verdade.
+   */
+  const moveRowDrag = (event: ReactPointerEvent<HTMLButtonElement>): void => {
+    if (!draggedRow) {
+      return;
+    }
+
+    const under = document
+      .elementFromPoint(event.clientX, event.clientY)
+      ?.closest("tr[data-row-id]");
+    const id = under?.getAttribute("data-row-id");
+
+    if (id) {
+      setTargetRow(id);
+    }
+  };
+
+  /** Soltou: avisa quem chamou e devolve a tabela ao estado parado. */
+  const endRowDrag = (): void => {
+    if (draggedRow && targetRow && draggedRow !== targetRow) {
+      onRowReorder?.(draggedRow, targetRow);
+    }
+
+    setDraggedRow(null);
+    setTargetRow(null);
+  };
 
   const filtersEnabled = Boolean(filters);
   const activeFilters = !filters
@@ -301,6 +371,11 @@ export function DataTable<T extends RowData>({
           <TableHeader>
             {table.getHeaderGroups().map((hg) => (
               <TableRow key={hg.id}>
+                {reorderable && (
+                  <TableHead className="w-px">
+                    <span className="sr-only">{t("table.reorder")}</span>
+                  </TableHead>
+                )}
                 {hg.headers.map((header) => {
                   const canSort = header.column.getCanSort();
                   const sorted = header.column.getIsSorted();
@@ -361,7 +436,49 @@ export function DataTable<T extends RowData>({
             )}
             {!loading &&
               table.getRowModel().rows.map((row) => (
-                <TableRow key={row.id}>
+                <TableRow
+                  key={row.id}
+                  data-row-id={row.id}
+                  className={cn(
+                    // A linha na mão fica esmaecida no lugar de origem e a de
+                    // destino se acende: são as duas pontas do gesto, e sem a
+                    // segunda não dá para saber onde a linha vai cair.
+                    draggedRow === row.id && "opacity-40",
+                    draggedRow && targetRow === row.id && draggedRow !== row.id
+                      ? "bg-accent"
+                      : undefined,
+                  )}
+                >
+                  {reorderable && (
+                    <TableCell className="w-px pr-0">
+                      <button
+                        type="button"
+                        aria-label={t("table.reorder")}
+                        title={
+                          canReorder
+                            ? t("table.reorder")
+                            : t("table.reorderSorted")
+                        }
+                        disabled={!canReorder}
+                        // `touch-none` é o que impede a página de rolar embaixo
+                        // do dedo enquanto a linha viaja.
+                        className={cn(
+                          "flex touch-none items-center text-muted-foreground",
+                          canReorder
+                            ? "cursor-grab active:cursor-grabbing hover:text-foreground"
+                            : "cursor-not-allowed opacity-30",
+                        )}
+                        onPointerDown={
+                          canReorder ? startRowDrag(row.id) : undefined
+                        }
+                        onPointerMove={canReorder ? moveRowDrag : undefined}
+                        onPointerUp={canReorder ? endRowDrag : undefined}
+                        onPointerCancel={canReorder ? endRowDrag : undefined}
+                      >
+                        <GripVertical className="h-4 w-4" />
+                      </button>
+                    </TableCell>
+                  )}
                   {row.getVisibleCells().map((cell) => (
                     <TableCell
                       key={cell.id}