feat: add user authentication UI to header component

Add login and register dialogs, user dropdown menu with profile link and logout option, and integrate with session management hook. Prevent hydration mismatches by conditionally rendering auth elements after mount. Update package-lock.json with new @esbuild dependencies for build tooling.
This commit is contained in:
Evandro Fonseca Junior committed 2025-11-04 02:33:29 -03:00
1 parent e641138887
commit 55eebde0ba
55 files changed
+7353 -7

No files matched your search

+67
View File
@@ -0,0 +1,67 @@
import { NextRequest, NextResponse } from "next/server";
import { secureLogger } from "@/lib/secure-logger";
import { getUserById } from "@/lib/db/queries/users";
export async function GET(
request: NextRequest,
{ params }: { params: Promise<{ id: string }> }
) {
try {
const { id } = await params;
const userId = parseInt(id, 10);
if (isNaN(userId)) {
return NextResponse.json(
{
success: false,
error: "ID de usuário inválido",
},
{ status: 400 }
);
}
const user = await getUserById(userId);
if (!user) {
return NextResponse.json(
{
success: false,
error: "Usuário não encontrado",
},
{ status: 404 }
);
}
// Retornar apenas dados públicos (sem informações sensíveis)
return NextResponse.json(
{
success: true,
user: {
userId: user.user_id,
username: user.username,
firstName: user.first_name,
lastName: user.last_name,
accountLevel: user.account_level,
hasDonated: user.has_donated,
createdAt: user.created_at,
},
},
{ status: 200 }
);
} catch (error) {
secureLogger.error("❌ Erro ao buscar perfil público", {
error: error instanceof Error ? error.message : "Erro desconhecido",
stack: error instanceof Error ? error.stack : undefined,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: false,
error: error instanceof Error ? error.message : "Erro interno",
},
{ status: 500 }
);
}
}
+205
View File
@@ -0,0 +1,205 @@
import { NextRequest, NextResponse } from "next/server";
import { secureLogger } from "@/lib/secure-logger";
import { requireAuth } from "@/lib/auth/middleware";
import {
updateCharacter,
deleteCharacter,
getCharacterById,
} from "@/lib/db/queries/characters";
import { characterSchema } from "@/lib/validation-schemas";
export async function PUT(
request: NextRequest,
{ params }: { params: Promise<{ id: string }> }
) {
try {
// Middleware de autenticação
const authResult = await requireAuth(request);
if (authResult instanceof NextResponse) {
return authResult;
}
const auth = authResult;
const { id } = await params;
const characterId = parseInt(id, 10);
if (isNaN(characterId)) {
return NextResponse.json(
{
success: false,
error: "ID de personagem inválido",
},
{ status: 400 }
);
}
const body = await request.json();
// Validação com Zod
const validationResult = characterSchema.safeParse(body);
if (!validationResult.success) {
const errors = validationResult.error.issues.map((err) => ({
field: err.path.join("."),
message: err.message,
}));
return NextResponse.json(
{
success: false,
error: "Dados de entrada inválidos",
details: errors,
},
{ status: 400 }
);
}
const validatedData = validationResult.data;
// Atualizar personagem (verifica ownership internamente)
const updatedCharacter = await updateCharacter(
characterId,
auth.userId,
{
character_name: validatedData.characterName,
server_name: validatedData.serverName,
is_main: validatedData.isMain,
}
);
secureLogger.info("✅ Personagem atualizado com sucesso", {
userId: auth.userId,
characterId: updatedCharacter.character_id,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: true,
character: {
characterId: updatedCharacter.character_id,
characterName: updatedCharacter.character_name,
serverName: updatedCharacter.server_name,
isMain: updatedCharacter.is_main,
verified: updatedCharacter.verified,
createdAt: updatedCharacter.created_at,
},
},
{ status: 200 }
);
} catch (error) {
// Se for NextResponse (erro de autenticação), re-lançar
if (error instanceof NextResponse) {
return error;
}
// Verificar se é erro de permissão
if (
error instanceof Error &&
error.message.includes("não tem permissão")
) {
return NextResponse.json(
{
success: false,
error: error.message,
},
{ status: 403 }
);
}
secureLogger.error("❌ Erro ao atualizar personagem", {
error: error instanceof Error ? error.message : "Erro desconhecido",
stack: error instanceof Error ? error.stack : undefined,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: false,
error: error instanceof Error ? error.message : "Erro interno",
},
{ status: 500 }
);
}
}
export async function DELETE(
request: NextRequest,
{ params }: { params: Promise<{ id: string }> }
) {
try {
// Middleware de autenticação
const authResult = await requireAuth(request);
if (authResult instanceof NextResponse) {
return authResult;
}
const auth = authResult;
const { id } = await params;
const characterId = parseInt(id, 10);
if (isNaN(characterId)) {
return NextResponse.json(
{
success: false,
error: "ID de personagem inválido",
},
{ status: 400 }
);
}
// Remover personagem (verifica ownership internamente)
await deleteCharacter(characterId, auth.userId);
secureLogger.info("✅ Personagem removido com sucesso", {
userId: auth.userId,
characterId,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: true,
},
{ status: 200 }
);
} catch (error) {
// Se for NextResponse (erro de autenticação), re-lançar
if (error instanceof NextResponse) {
return error;
}
// Verificar se é erro de permissão
if (
error instanceof Error &&
error.message.includes("não tem permissão")
) {
return NextResponse.json(
{
success: false,
error: error.message,
},
{ status: 403 }
);
}
secureLogger.error("❌ Erro ao remover personagem", {
error: error instanceof Error ? error.message : "Erro desconhecido",
stack: error instanceof Error ? error.stack : undefined,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: false,
error: error instanceof Error ? error.message : "Erro interno",
},
{ status: 500 }
);
}
}
+150
View File
@@ -0,0 +1,150 @@
import { NextRequest, NextResponse } from "next/server";
import { secureLogger } from "@/lib/secure-logger";
import { requireAuth } from "@/lib/auth/middleware";
import { getUserCharacters, createCharacter } from "@/lib/db/queries/characters";
import { characterSchema } from "@/lib/validation-schemas";
export async function GET(request: NextRequest) {
try {
// Middleware de autenticação
const authResult = await requireAuth(request);
if (authResult instanceof NextResponse) {
return authResult;
}
const auth = authResult;
// Listar personagens do usuário
const characters = await getUserCharacters(auth.userId);
return NextResponse.json(
{
success: true,
characters: characters.map((char) => ({
characterId: char.character_id,
characterName: char.character_name,
serverName: char.server_name,
isMain: char.is_main,
verified: char.verified,
createdAt: char.created_at,
})),
},
{ status: 200 }
);
} catch (error) {
// Se for NextResponse (erro de autenticação), re-lançar
if (error instanceof NextResponse) {
return error;
}
secureLogger.error("❌ Erro ao listar personagens", {
error: error instanceof Error ? error.message : "Erro desconhecido",
stack: error instanceof Error ? error.stack : undefined,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: false,
error: error instanceof Error ? error.message : "Erro interno",
},
{ status: 500 }
);
}
}
export async function POST(request: NextRequest) {
try {
// Middleware de autenticação
const authResult = await requireAuth(request);
if (authResult instanceof NextResponse) {
return authResult;
}
const auth = authResult;
const body = await request.json();
// Validação com Zod
const validationResult = characterSchema.safeParse(body);
if (!validationResult.success) {
const errors = validationResult.error.issues.map((err) => ({
field: err.path.join("."),
message: err.message,
}));
return NextResponse.json(
{
success: false,
error: "Dados de entrada inválidos",
details: errors,
},
{ status: 400 }
);
}
const validatedData = validationResult.data;
// Criar personagem
const newCharacter = await createCharacter(auth.userId, {
character_name: validatedData.characterName,
server_name: validatedData.serverName,
is_main: validatedData.isMain,
});
secureLogger.info("✅ Personagem criado com sucesso", {
userId: auth.userId,
characterId: newCharacter.character_id,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: true,
character: {
characterId: newCharacter.character_id,
characterName: newCharacter.character_name,
serverName: newCharacter.server_name,
isMain: newCharacter.is_main,
verified: newCharacter.verified,
createdAt: newCharacter.created_at,
},
},
{ status: 201 }
);
} catch (error) {
// Se for NextResponse (erro de autenticação), re-lançar
if (error instanceof NextResponse) {
return error;
}
// Verificar se é erro de constraint (personagem duplicado)
if (error instanceof Error && error.message.includes("UNIQUE")) {
return NextResponse.json(
{
success: false,
error: "Este personagem já está cadastrado neste servidor",
},
{ status: 409 }
);
}
secureLogger.error("❌ Erro ao criar personagem", {
error: error instanceof Error ? error.message : "Erro desconhecido",
stack: error instanceof Error ? error.stack : undefined,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: false,
error: error instanceof Error ? error.message : "Erro interno",
},
{ status: 500 }
);
}
}
+179
View File
@@ -0,0 +1,179 @@
import { NextRequest, NextResponse } from "next/server";
import { secureLogger } from "@/lib/secure-logger";
import { requireAuth } from "@/lib/auth/middleware";
import { getUserById, updateUser } from "@/lib/db/queries/users";
import { getUserCharacters } from "@/lib/db/queries/characters";
import { updateUserSchema } from "@/lib/validation-schemas";
export async function GET(request: NextRequest) {
try {
// Middleware de autenticação
const authResult = await requireAuth(request);
if (authResult instanceof NextResponse) {
return authResult;
}
const auth = authResult;
// Buscar dados do usuário
const user = await getUserById(auth.userId);
if (!user) {
return NextResponse.json(
{
success: false,
error: "Usuário não encontrado",
},
{ status: 404 }
);
}
// Buscar personagens do usuário
const characters = await getUserCharacters(auth.userId);
return NextResponse.json(
{
success: true,
user: {
userId: user.user_id,
username: user.username,
email: user.email,
firstName: user.first_name,
lastName: user.last_name,
phone: user.phone,
cpf: user.cpf,
accountLevel: user.account_level,
hasDonated: user.has_donated,
whatsappNotifications: user.whatsapp_notifications,
createdAt: user.created_at,
updatedAt: user.updated_at,
lastLogin: user.last_login,
isActive: user.is_active,
isVerified: user.is_verified,
},
characters: characters.map((char) => ({
characterId: char.character_id,
characterName: char.character_name,
serverName: char.server_name,
isMain: char.is_main,
verified: char.verified,
createdAt: char.created_at,
})),
},
{ status: 200 }
);
} catch (error) {
// Se for NextResponse (erro de autenticação), re-lançar
if (error instanceof NextResponse) {
return error;
}
secureLogger.error("❌ Erro ao buscar perfil do usuário", {
error: error instanceof Error ? error.message : "Erro desconhecido",
stack: error instanceof Error ? error.stack : undefined,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: false,
error: error instanceof Error ? error.message : "Erro interno",
},
{ status: 500 }
);
}
}
export async function PUT(request: NextRequest) {
try {
// Middleware de autenticação
const authResult = await requireAuth(request);
if (authResult instanceof NextResponse) {
return authResult;
}
const auth = authResult;
const body = await request.json();
// Validação com Zod
const validationResult = updateUserSchema.safeParse(body);
if (!validationResult.success) {
const errors = validationResult.error.issues.map((err) => ({
field: err.path.join("."),
message: err.message,
}));
return NextResponse.json(
{
success: false,
error: "Dados de entrada inválidos",
details: errors,
},
{ status: 400 }
);
}
const validatedData = validationResult.data;
// Atualizar usuário
const updatedUser = await updateUser(auth.userId, {
first_name: validatedData.firstName,
last_name: validatedData.lastName,
phone: validatedData.phone,
whatsapp_notifications: validatedData.whatsappNotifications,
});
secureLogger.info("✅ Perfil atualizado com sucesso", {
userId: auth.userId,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: true,
user: {
userId: updatedUser.user_id,
username: updatedUser.username,
email: updatedUser.email,
firstName: updatedUser.first_name,
lastName: updatedUser.last_name,
phone: updatedUser.phone,
cpf: updatedUser.cpf,
accountLevel: updatedUser.account_level,
hasDonated: updatedUser.has_donated,
whatsappNotifications: updatedUser.whatsapp_notifications,
createdAt: updatedUser.created_at,
updatedAt: updatedUser.updated_at,
lastLogin: updatedUser.last_login,
isActive: updatedUser.is_active,
isVerified: updatedUser.is_verified,
},
},
{ status: 200 }
);
} catch (error) {
// Se for NextResponse (erro de autenticação), re-lançar
if (error instanceof NextResponse) {
return error;
}
secureLogger.error("❌ Erro ao atualizar perfil", {
error: error instanceof Error ? error.message : "Erro desconhecido",
stack: error instanceof Error ? error.stack : undefined,
timestamp: new Date().toISOString(),
});
return NextResponse.json(
{
success: false,
error: error instanceof Error ? error.message : "Erro interno",
},
{ status: 500 }
);
}
}