Frontend completo (Etapas 11-18) e extensões de backend (Etapas 13 e 18)
Adiciona o frontend Next.js em frontend/ (setup, design system, autenticação/tema, layout/navegação, área master, área tenant completa: clientes, produtos, vendas, recebimentos, whatsapp, e-mail, alertas, equipe e perfil). Estende o backend de forma aditiva e autorizada: cookie httpOnly para refresh token (Etapa 13) e CRUD de equipe + edição de perfil do tenant (Etapa 18, módulo src/modules/equipe/ novo e PUT /tenant/perfil). Detalhes completos em Etapas/V2/*. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Claude Sonnet 5
@@ -0,0 +1,130 @@
|
||||
'use client';
|
||||
|
||||
import * as React from 'react';
|
||||
import { apiClient, authInterceptor, fetchRefreshToken } from '@/lib/api/client';
|
||||
import { clearSessionCookie, setSessionCookie } from '@/lib/auth/session-cookie';
|
||||
import { decodeJwt, type JwtPayload } from '@/lib/auth/jwt';
|
||||
|
||||
interface LoginResponse {
|
||||
access_token: string;
|
||||
}
|
||||
|
||||
type AuthStatus = 'loading' | 'authenticated' | 'unauthenticated';
|
||||
|
||||
interface AuthContextValue {
|
||||
status: AuthStatus;
|
||||
user: JwtPayload | null;
|
||||
loginMaster: (email: string, senha: string) => Promise<void>;
|
||||
loginTenant: (email: string, senha: string) => Promise<void>;
|
||||
logout: () => Promise<void>;
|
||||
}
|
||||
|
||||
const AuthContext = React.createContext<AuthContextValue | null>(null);
|
||||
|
||||
/**
|
||||
* Fonte única de sessão do app (Etapa 13). Access token só existe em
|
||||
* memória (`tokenRef`/estado do React) — nunca em `localStorage`. O
|
||||
* refresh token real vive só no cookie httpOnly do backend; este
|
||||
* Provider nunca o lê nem o guarda, só dispara `POST /auth/refresh` (que
|
||||
* o browser já anexa o cookie automaticamente) e reage ao resultado.
|
||||
*/
|
||||
export function AuthProvider({ children }: { children: React.ReactNode }) {
|
||||
const tokenRef = React.useRef<string | null>(null);
|
||||
const [status, setStatus] = React.useState<AuthStatus>('loading');
|
||||
const [user, setUser] = React.useState<JwtPayload | null>(null);
|
||||
// Deduplica chamadas concorrentes a `refreshSession` (ver comentário abaixo).
|
||||
const refreshPromiseRef = React.useRef<Promise<boolean> | null>(null);
|
||||
|
||||
const applyToken = React.useCallback((token: string | null) => {
|
||||
tokenRef.current = token;
|
||||
setUser(token ? decodeJwt(token) : null);
|
||||
setStatus(token ? 'authenticated' : 'unauthenticated');
|
||||
}, []);
|
||||
|
||||
/**
|
||||
* Duas fontes independentes podem chamar isto quase ao mesmo tempo logo
|
||||
* após um reload de página protegida: o efeito de montagem deste
|
||||
* Provider (recupera a sessão) e `authInterceptor.onUnauthorized`
|
||||
* (disparado por um 401 de uma request que saiu antes do token estar
|
||||
* pronto). Sem deduplicar, a 2ª chamada reenvia o mesmo cookie de
|
||||
* refresh que a 1ª já rotacionou — o backend trata isso como reuso de
|
||||
* token revogado e revoga a família inteira (Etapa 2), derrubando a
|
||||
* sessão que a 1ª chamada acabou de validar. Compartilhar a mesma
|
||||
* promise entre chamadas concorrentes evita a corrida.
|
||||
*/
|
||||
const refreshSession = React.useCallback((): Promise<boolean> => {
|
||||
if (refreshPromiseRef.current) return refreshPromiseRef.current;
|
||||
|
||||
const promise = (async () => {
|
||||
try {
|
||||
const result = await fetchRefreshToken();
|
||||
if (!result) {
|
||||
applyToken(null);
|
||||
clearSessionCookie();
|
||||
return false;
|
||||
}
|
||||
applyToken(result.access_token);
|
||||
return true;
|
||||
} finally {
|
||||
refreshPromiseRef.current = null;
|
||||
}
|
||||
})();
|
||||
|
||||
refreshPromiseRef.current = promise;
|
||||
return promise;
|
||||
}, [applyToken]);
|
||||
|
||||
// Gancho deixado pronto na Etapa 11: liga o client HTTP à sessão atual.
|
||||
React.useEffect(() => {
|
||||
authInterceptor.getAccessToken = () => tokenRef.current;
|
||||
authInterceptor.onUnauthorized = refreshSession;
|
||||
}, [refreshSession]);
|
||||
|
||||
// Recupera a sessão em memória após um reload de página (o access token
|
||||
// não sobrevive a isso de propósito — só o cookie httpOnly sobrevive).
|
||||
React.useEffect(() => {
|
||||
void refreshSession();
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||
}, []);
|
||||
|
||||
const loginMaster = React.useCallback(
|
||||
async (email: string, senha: string) => {
|
||||
const tokens = await apiClient.post<LoginResponse>('/auth/master/login', { email, senha });
|
||||
applyToken(tokens.access_token);
|
||||
setSessionCookie('master');
|
||||
},
|
||||
[applyToken],
|
||||
);
|
||||
|
||||
const loginTenant = React.useCallback(
|
||||
async (email: string, senha: string) => {
|
||||
const tokens = await apiClient.post<LoginResponse>('/auth/tenant/login', { email, senha });
|
||||
applyToken(tokens.access_token);
|
||||
setSessionCookie('tenant');
|
||||
},
|
||||
[applyToken],
|
||||
);
|
||||
|
||||
const logout = React.useCallback(async () => {
|
||||
try {
|
||||
await apiClient.post('/auth/logout', {});
|
||||
} catch {
|
||||
// mesmo se a chamada falhar (ex: rede), a sessão local é limpa de qualquer forma
|
||||
}
|
||||
applyToken(null);
|
||||
clearSessionCookie();
|
||||
}, [applyToken]);
|
||||
|
||||
const value = React.useMemo(
|
||||
() => ({ status, user, loginMaster, loginTenant, logout }),
|
||||
[status, user, loginMaster, loginTenant, logout],
|
||||
);
|
||||
|
||||
return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
|
||||
}
|
||||
|
||||
export function useAuth(): AuthContextValue {
|
||||
const ctx = React.useContext(AuthContext);
|
||||
if (!ctx) throw new Error('useAuth precisa estar dentro de <AuthProvider>');
|
||||
return ctx;
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
export type UserRole = 'tenant_admin' | 'vendedor' | 'financeiro' | 'visualizador';
|
||||
|
||||
export interface JwtPayload {
|
||||
sub: string;
|
||||
tipo: 'master' | 'tenant_user';
|
||||
tenant_id: string | null;
|
||||
role?: UserRole;
|
||||
exp?: number;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decodifica o payload do access token para ler identidade/papel no
|
||||
* client. **Não valida assinatura nem expiração de verdade** — isso é
|
||||
* responsabilidade exclusiva do backend em cada chamada de API; aqui é
|
||||
* só para decisões de UI (qual área mostrar, quais itens de menu).
|
||||
*/
|
||||
export function decodeJwt(token: string): JwtPayload | null {
|
||||
try {
|
||||
const payload = token.split('.')[1];
|
||||
const json = atob(payload.replace(/-/g, '+').replace(/_/g, '/'));
|
||||
return JSON.parse(json) as JwtPayload;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
export type SessionArea = 'master' | 'tenant';
|
||||
|
||||
/**
|
||||
* Cookie de sinalização para o middleware do Next.js (Etapa 13).
|
||||
*
|
||||
* O refresh token real fica em cookie httpOnly setado pelo **backend**,
|
||||
* com `Path=/auth` — ou seja, só é enviado para o próprio backend, nunca
|
||||
* para o Next.js. O middleware roda no servidor do frontend e não tem
|
||||
* acesso a esse cookie (nem deveria: são origens diferentes). Por isso
|
||||
* existe este segundo cookie, **não sensível** (só diz "há uma sessão
|
||||
* ativa, tipo master/tenant"), setado pelo próprio frontend depois de um
|
||||
* login bem-sucedido — só para o middleware decidir bloquear/redirecionar
|
||||
* *antes* de renderizar a página (evita "flash" de conteúdo protegido).
|
||||
*
|
||||
* Isso é uma verificação otimista, não uma fronteira de segurança: a
|
||||
* autorização de verdade acontece no backend, em toda chamada de API, via
|
||||
* o access token real (que nunca fica em cookie, só em memória).
|
||||
*/
|
||||
const SESSION_COOKIE = 'sc_session';
|
||||
const MAX_AGE_SECONDS = 30 * 24 * 60 * 60;
|
||||
|
||||
export function setSessionCookie(area: SessionArea): void {
|
||||
document.cookie = `${SESSION_COOKIE}=${area}; Path=/; Max-Age=${MAX_AGE_SECONDS}; SameSite=Lax`;
|
||||
}
|
||||
|
||||
export function clearSessionCookie(): void {
|
||||
document.cookie = `${SESSION_COOKIE}=; Path=/; Max-Age=0; SameSite=Lax`;
|
||||
}
|
||||
|
||||
export function readSessionCookieValue(cookieHeader: string | undefined): SessionArea | null {
|
||||
if (!cookieHeader) return null;
|
||||
const match = cookieHeader.match(new RegExp(`${SESSION_COOKIE}=(master|tenant)`));
|
||||
return (match?.[1] as SessionArea | undefined) ?? null;
|
||||
}
|
||||
|
||||
export { SESSION_COOKIE };
|
||||
Reference in New Issue
Block a user