rl-core-front 0.18.10 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rl-core-front",
-  "version": "0.18.10",
+  "version": "0.19.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

@@ -244,17 +244,17 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/auth/password-token/{token}": {
+    "/auth/password-token/inspect": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
-        /** Verifica a validade do link de senha sem consumi-lo */
-        get: operations["AuthController_inspectPasswordToken"];
+        get?: never;
         put?: never;
-        post?: never;
+        /** Verifica a validade do link de senha sem consumi-lo */
+        post: operations["AuthController_inspectPasswordToken"];
         delete?: never;
         options?: never;
         head?: never;
@@ -838,6 +838,38 @@ export interface paths {
         patch: operations["NotificationsController_markAsRead"];
         trace?: never;
     };
+    "/notifications/read": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete: operations["NotificationsController_dismissRead"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/notifications/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete: operations["NotificationsController_dismiss"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/exports/{handler}": {
         parameters: {
             query?: never;
@@ -1148,6 +1180,9 @@ export interface components {
         ForgotPasswordCommand: {
             email: string;
         };
+        InspectPasswordTokenCommand: {
+            token: string;
+        };
         ResetPasswordCommand: {
             token: string;
             newPassword: string;
@@ -1588,6 +1623,13 @@ export interface components {
             sortBy?: string;
             /** @enum {string} */
             sortDir?: "ASC" | "DESC";
+            /**
+             * @description Parâmetros do documento, validados pelo relatório pedido
+             * @example {
+             *       "referenceMonth": "2026-09"
+             *     }
+             */
+            params?: Record<string, never>;
         };
         ExportAcceptedResponse: {
             /** @example 184 */
@@ -2038,12 +2080,14 @@ export interface operations {
         parameters: {
             query?: never;
             header?: never;
-            path: {
-                token: string;
-            };
+            path?: never;
             cookie?: never;
         };
-        requestBody?: never;
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["InspectPasswordTokenCommand"];
+            };
+        };
         responses: {
             200: {
                 headers: {
@@ -3338,6 +3382,42 @@ export interface operations {
             };
         };
     };
+    NotificationsController_dismissRead: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    NotificationsController_dismiss: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     ExportController_request: {
         parameters: {
             query?: never;
@@ -3395,7 +3475,7 @@ export interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description A planilha */
+            /** @description O arquivo gerado */
             200: {
                 headers: {
                     [name: string]: unknown;

package/src/_services/auth/index.ts

@@ -84,10 +84,9 @@ export const authService = {
 
   /** Verifica o link de senha antes de exibir o formulário (não consome o token). */
   inspectPasswordToken(token: string): Promise<PasswordTokenCheck> {
+    // No corpo, não na URL: token em path vai parar em log de proxy.
     return api
-      .get<PasswordTokenCheck>(
-        `/auth/password-token/${encodeURIComponent(token)}`,
-      )
+      .post<PasswordTokenCheck>("/auth/password-token/inspect", { token })
       .then((r) => r.data);
   },
 

package/src/_utils/upload-url.ts

@@ -18,6 +18,11 @@ const API_ORIGIN = (process.env.NEXT_PUBLIC_API_BASE_URL ?? "").replace(
  * avatar gravado por versões anteriores e de qualquer endereço externo que
  * ainda esteja em base.
  */
+/** Imagem ainda não confirmada por um salvar — vive em `/uploads/<pasta>/pending/`. */
+export function isPendingImagePath(path?: string | null): boolean {
+  return /^\/uploads\/[^/]+\/pending\//.test(path ?? "");
+}
+
 export function uploadUrlOf(path?: string | null): string | undefined {
   if (!path) {
     return undefined;

package/src/components/app-shell.tsx

@@ -177,7 +177,9 @@ const ADMIN_CHILDREN: NavItem[] = [
     perm: anyOrTeam("users:read"),
   },
   { key: "nav.rbac", href: "/rbac", icon: ShieldCheck, perm: "roles:read:any" },
-  { key: "nav.logs", href: "/logs", icon: ScrollText, perm: "audit:read:any" },
+  // Gerente vê o log da própria equipe — a rota poda pelo mesmo alcance da
+  // listagem de usuários.
+  { key: "nav.logs", href: "/logs", icon: ScrollText, perm: anyOrTeam("audit:read") },
   // Logo abaixo do log de requisições, que é o vizinho natural: os dois contam
   // o que aconteceu no sistema, um por chamada e outro por alteração de dado.
   // Restrito a administradores — só quem tem audit:read-trail:any (só Super

package/src/components/ui/image-upload.tsx

@@ -5,7 +5,7 @@ import type { ChangeEvent, ClipboardEvent, DragEvent, JSX } from "react";
 import { useRef, useState } from "react";
 
 import { imagesService } from "#core/_services/images";
-import { uploadUrlOf } from "#core/_utils/upload-url";
+import { isPendingImagePath, uploadUrlOf } from "#core/_utils/upload-url";
 import { Button } from "#core/components/ui/button";
 import { Input } from "#core/components/ui/input";
 import { Spinner } from "#core/components/ui/spinner";
@@ -102,9 +102,13 @@ export function ImageUpload({
       return;
     }
 
-    // O arquivo sai do disco junto: caminho que ninguém mais referencia é
-    // exatamente o que a faxina não varre (a pasta definitiva não é varrida).
-    await imagesService.remove(profile, value).catch(() => undefined);
+    // Só a pendente sai do disco por aqui — é o upload desta sessão que ninguém
+    // referencia. A definitiva pertence ao registro: quem a apaga é o salvar
+    // (`discard()` no service da feature), e a API recusa o caminho por esta
+    // rota de propósito.
+    if (isPendingImagePath(value)) {
+      await imagesService.remove(profile, value).catch(() => undefined);
+    }
     onChange(null);
     clearError();
   };

package/src/middleware.ts

@@ -7,9 +7,119 @@ import { NextRequest, NextResponse } from "next/server";
  *
  * Observação: a validação forte do token é feita no backend; aqui é só
  * o "portão" de roteamento (UX), evitando flicker de telas privadas.
+ *
+ * Também é aqui que a Content-Security-Policy nasce, porque o nonce precisa
+ * ser novo a cada requisição e chegar ao `layout.tsx` antes de a página
+ * renderizar — ver `buildContentSecurityPolicy`.
  */
 const PUBLIC_PATHS = ["/login", "/forgot-password", "/reset-password"];
 
+/** Cabeçalho por onde o nonce chega ao `layout.tsx` (`headers().get("x-nonce")`). */
+export const NONCE_HEADER = "x-nonce";
+
+export interface ContentSecurityPolicyOptions {
+  /** Nonce desta requisição — vai nos scripts inline do Next e no de tema do layout. */
+  nonce: string;
+  /** Origens extras de `connect-src` (outra API, um serviço de terceiros). */
+  extraConnectSrc?: string[];
+  /** Origens extras de `img-src` (CDN de imagens, S3). */
+  extraImgSrc?: string[];
+}
+
+/**
+ * Os mesmos padrões do `axios.factory` e do `socket-context`: sem a variável, a
+ * CSP precisa liberar exatamente para onde o cliente vai cair, senão o navegador
+ * bloqueia toda chamada.
+ */
+const DEFAULT_API_BASE_URL = "http://localhost:3108/api/v1";
+const DEFAULT_SOCKET_URL = "http://localhost:3108";
+
+const originOf = (url: string): string | null => {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+};
+
+/** Origem da API (`NEXT_PUBLIC_API_BASE_URL`), sem prefixo — é de lá que vêm avatar e download. */
+const apiOrigin = (): string | null =>
+  originOf(process.env.NEXT_PUBLIC_API_BASE_URL ?? DEFAULT_API_BASE_URL);
+
+/** Origem do socket (`NEXT_PUBLIC_SOCKET_URL`) — costuma ser a da API, mas pode divergir. */
+const socketOrigin = (): string | null =>
+  originOf(process.env.NEXT_PUBLIC_SOCKET_URL ?? DEFAULT_SOCKET_URL);
+
+/**
+ * A CSP do core.
+ *
+ * Defesa em profundidade: hoje não há sink de XSS na interface, e a CSP é o
+ * que limita o estrago de um que apareça num componente de terceiro. Script só
+ * com nonce (`strict-dynamic` deixa o Next carregar os chunks dele); `img` e
+ * `connect` liberam a origem da API, porque avatar, axios e socket.io falam
+ * com ela. `style` aceita inline porque Tailwind e Radix escrevem `style=`
+ * direto no elemento — bloquear isso quebraria todo popover e menu.
+ *
+ * `unsafe-eval` só em desenvolvimento: o React o usa para reconstruir stack
+ * de erro do servidor no navegador; em produção nem React nem Next o usam.
+ *
+ * Exportada para o projeto que precisar de mais origens montar a própria: chama
+ * esta com `extraConnectSrc`/`extraImgSrc` dentro do middleware dele.
+ */
+export const buildContentSecurityPolicy = ({
+  nonce,
+  extraConnectSrc = [],
+  extraImgSrc = [],
+}: ContentSecurityPolicyOptions): string => {
+  const api = apiOrigin();
+  const socket = socketOrigin();
+  const isDev = process.env.NODE_ENV === "development";
+  // O socket.io começa por polling HTTP e sobe para WebSocket: as duas formas.
+  const connect = [
+    "'self'",
+    api,
+    socket,
+    socket?.replace(/^http/, "ws") ?? null,
+    ...extraConnectSrc,
+  ].filter(Boolean);
+  const img = ["'self'", "blob:", "data:", api, ...extraImgSrc].filter(Boolean);
+
+  return [
+    "default-src 'self'",
+    `script-src 'self' 'nonce-${nonce}' 'strict-dynamic'${isDev ? " 'unsafe-eval'" : ""}`,
+    "style-src 'self' 'unsafe-inline'",
+    `img-src ${img.join(" ")}`,
+    "font-src 'self' data:",
+    `connect-src ${connect.join(" ")}`,
+    "object-src 'none'",
+    "base-uri 'self'",
+    "form-action 'self'",
+    "frame-ancestors 'none'",
+  ].join("; ");
+};
+
+/**
+ * Devolve a resposta "segue em frente" já com o nonce e a CSP nos dois lados:
+ * no request (é de onde o Next lê o nonce para os scripts dele) e no response.
+ */
+export const nextWithSecurityHeaders = (
+  req: NextRequest,
+  options: Omit<ContentSecurityPolicyOptions, "nonce"> = {},
+): NextResponse => {
+  const nonce = Buffer.from(crypto.randomUUID()).toString("base64");
+  const csp = buildContentSecurityPolicy({ nonce, ...options });
+
+  const requestHeaders = new Headers(req.headers);
+  requestHeaders.set(NONCE_HEADER, nonce);
+  requestHeaders.set("Content-Security-Policy", csp);
+
+  const response = NextResponse.next({ request: { headers: requestHeaders } });
+  response.headers.set("Content-Security-Policy", csp);
+  response.headers.set("X-Content-Type-Options", "nosniff");
+  response.headers.set("Referrer-Policy", "strict-origin-when-cross-origin");
+  return response;
+};
+
 export function middleware(req: NextRequest): NextResponse<unknown> {
   const { pathname } = req.nextUrl;
   const hasSession =
@@ -34,7 +144,7 @@ export function middleware(req: NextRequest): NextResponse<unknown> {
     return NextResponse.redirect(url);
   }
 
-  return NextResponse.next();
+  return nextWithSecurityHeaders(req);
 }
 
 export const config = {