feat: upload yaba srcHEADmaster

Signed-off-by: Lucas Faria Mendes <lucas.fariamo08@gmail.com>

26 files changed, 1678 insertions, 0 deletions

diff --git a/api/src/db/client.ts b/api/src/db/client.ts
new file mode 100644
index 0000000..5e9673f
--- /dev/null
+++ b/api/src/db/client.ts
@@ -0,0 +1,23 @@
+import { Database } from 'bun:sqlite';
+import { drizzle } from 'drizzle-orm/bun-sqlite';
+import * as schema from './schema';
+
+/**
+ * Instância única do banco de dados SQLite via Drizzle ORM.
+ * Utiliza o driver nativo do Bun para máxima performance.
+ *
+ * O caminho do arquivo pode ser configurado via variável de ambiente DATABASE_URL.
+ * Quando não definida, usa 'yaba.db' na raiz do projeto.
+ */
+const sqlite = new Database(process.env.DATABASE_URL ?? 'yaba.db');
+
+/**
+ * Habilita WAL mode para melhor performance em leituras concorrentes.
+ * @see https://www.sqlite.org/wal.html
+ */
+sqlite.exec('PRAGMA journal_mode = WAL;');
+sqlite.exec('PRAGMA foreign_keys = ON;');
+
+export const db = drizzle(sqlite, { schema });
+
+export type DB = typeof db;
diff --git a/api/src/db/schema/incomes.ts b/api/src/db/schema/incomes.ts
new file mode 100644
index 0000000..f502cb9
--- /dev/null
+++ b/api/src/db/schema/incomes.ts
@@ -0,0 +1,51 @@
+import { sql } from 'drizzle-orm';
+import { integer, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { users } from './users';
+
+/**
+ * Tabela de rendas/salários.
+ * Armazena o histórico de salários por mês/ano, permitindo que o usuário
+ * tenha registros diferentes para cada período (ex: aumento de salário em julho).
+ */
+export const incomes = sqliteTable('incomes', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+
+  user_id: integer('user_id')
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+
+  /** Salário bruto do período (em R$) */
+  gross_salary: real('gross_salary').notNull(),
+
+  /**
+   * Salário líquido calculado automaticamente pelo app (INSS + IRRF).
+   * Armazenado para fins de histórico e auditoria.
+   */
+  calculated_net_salary: real('calculated_net_salary').notNull(),
+
+  /**
+   * Salário líquido efetivo usado no cálculo do saldo.
+   * Pode diferir do calculado caso o usuário tenha feito um override manual.
+   */
+  effective_net_salary: real('effective_net_salary').notNull(),
+
+  /** Mês de referência (1-12) */
+  reference_month: integer('reference_month').notNull(),
+
+  /** Ano de referência (ex: 2025) */
+  reference_year: integer('reference_year').notNull(),
+
+  /** Observações opcionais (ex: "13º salário", "PLR") */
+  description: text('description'),
+
+  created_at: text('created_at')
+    .notNull()
+    .default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`),
+
+  updated_at: text('updated_at')
+    .notNull()
+    .default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`),
+});
+
+export type Income = typeof incomes.$inferSelect;
+export type NewIncome = typeof incomes.$inferInsert;
diff --git a/api/src/db/schema/index.ts b/api/src/db/schema/index.ts
new file mode 100644
index 0000000..72cf261
--- /dev/null
+++ b/api/src/db/schema/index.ts
@@ -0,0 +1,11 @@
+/**
+ * Ponto central de exportação de todos os schemas do Drizzle.
+ * Importe sempre a partir deste arquivo para evitar imports circulares.
+ *
+ * Uso:
+ *   import { users, incomes, recurringExpenses, oneTimeExpenses } from '@/db/schema';
+ */
+export * from './users';
+export * from './incomes';
+export * from './recurring-expenses';
+export * from './one-time-expenses';
diff --git a/api/src/db/schema/one-time-expenses.ts b/api/src/db/schema/one-time-expenses.ts
new file mode 100644
index 0000000..10c9c01
--- /dev/null
+++ b/api/src/db/schema/one-time-expenses.ts
@@ -0,0 +1,53 @@
+import { sql } from 'drizzle-orm';
+import { integer, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { users } from './users';
+
+/**
+ * Tabela de gastos avulsos (despesas pontuais).
+ * Ex: Cinema, iFood, Uber, Farmácia.
+ * Cada registro representa um gasto único em uma data específica.
+ * O valor é subtraído do saldo disponível do mês em que a despesa ocorreu.
+ */
+export const oneTimeExpenses = sqliteTable('one_time_expenses', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+
+  user_id: integer('user_id')
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+
+  /** Nome/descrição do gasto (ex: "Cinema com a família", "iFood jantar") */
+  name: text('name').notNull(),
+
+  /** Valor do gasto (em R$) */
+  amount: real('amount').notNull(),
+
+  /**
+   * Categoria do gasto para organização e futuros relatórios.
+   * Ex: "alimentação", "lazer", "saúde", "transporte", "educação", "outros"
+   */
+  category: text('category').notNull().default('outros'),
+
+  /** Tipo do lançamento: 'expense' (despesa) ou 'income' (receita) */
+  type: text('type').notNull().default('expense'),
+
+  /**
+   * Data em que o gasto ocorreu.
+   * Formato ISO 8601 (YYYY-MM-DD). Usado para atribuir o gasto ao mês correto.
+   * Default: data atual no momento da inserção.
+   */
+  expense_date: text('expense_date').notNull().default(sql`(date('now'))`),
+
+  /** Observações opcionais (ex: "Split 50/50 com João") */
+  notes: text('notes'),
+
+  created_at: text('created_at')
+    .notNull()
+    .default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`),
+
+  updated_at: text('updated_at')
+    .notNull()
+    .default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`),
+});
+
+export type OneTimeExpense = typeof oneTimeExpenses.$inferSelect;
+export type NewOneTimeExpense = typeof oneTimeExpenses.$inferInsert;
diff --git a/api/src/db/schema/recurring-expenses.ts b/api/src/db/schema/recurring-expenses.ts
new file mode 100644
index 0000000..8a0a1df
--- /dev/null
+++ b/api/src/db/schema/recurring-expenses.ts
@@ -0,0 +1,69 @@
+import { sql } from 'drizzle-orm';
+import { integer, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { users } from './users';
+
+/**
+ * Tabela de gastos recorrentes (despesas fixas mensais).
+ * Ex: Aluguel, Internet, Streaming, Academia.
+ * Estes gastos são deduzidos automaticamente do saldo todo mês,
+ * sem precisar recadastrar.
+ */
+export const recurringExpenses = sqliteTable('recurring_expenses', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+
+  user_id: integer('user_id')
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+
+  /** Nome/descrição do gasto (ex: "Aluguel", "Netflix") */
+  name: text('name').notNull(),
+
+  /** Valor mensal do gasto (em R$) */
+  amount: real('amount').notNull(),
+
+  /**
+   * Categoria do gasto para organização e futuros relatórios.
+   * Ex: "moradia", "alimentação", "lazer", "saúde", "transporte", "educação", "outros"
+   */
+  category: text('category').notNull().default('outros'),
+
+  /** Tipo do lançamento: 'expense' (despesa) ou 'income' (receita) */
+  type: text('type').notNull().default('expense'),
+
+  /**
+   * Dia do mês em que a despesa costuma vencer (1-31).
+   * Opcional — usado apenas para informação ao usuário.
+   */
+  due_day: integer('due_day'),
+
+  /**
+   * Indica se o gasto está ativo.
+   * Quando false, não é deduzido do saldo (útil para pausar sem deletar).
+   * Armazenado como integer (0 = false, 1 = true) por limitação do SQLite.
+   */
+  is_active: integer('is_active', { mode: 'boolean' }).notNull().default(true),
+
+  /**
+   * Data a partir da qual este gasto passa a ser contabilizado.
+   * Formato ISO 8601 (YYYY-MM-DD).
+   */
+  starts_at: text('starts_at').notNull().default(sql`(date('now'))`),
+
+  /**
+   * Data em que este gasto deixa de ser contabilizado (opcional).
+   * Útil para despesas com prazo definido (ex: parcelamento de 12x).
+   * Formato ISO 8601 (YYYY-MM-DD).
+   */
+  ends_at: text('ends_at'),
+
+  created_at: text('created_at')
+    .notNull()
+    .default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`),
+
+  updated_at: text('updated_at')
+    .notNull()
+    .default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`),
+});
+
+export type RecurringExpense = typeof recurringExpenses.$inferSelect;
+export type NewRecurringExpense = typeof recurringExpenses.$inferInsert;
diff --git a/api/src/db/schema/users.ts b/api/src/db/schema/users.ts
new file mode 100644
index 0000000..636ad2d
--- /dev/null
+++ b/api/src/db/schema/users.ts
@@ -0,0 +1,37 @@
+import { sql } from 'drizzle-orm';
+import { integer, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+/**
+ * Tabela de usuários.
+ * Por ora, suporta um único usuário local (single-user app).
+ * O campo `net_salary_override` permite que o usuário edite manualmente
+ * o salário líquido calculado, para cobrir descontos extras (plano de saúde, VT, etc.).
+ */
+export const users = sqliteTable('users', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+
+  name: text('name').notNull(),
+  email: text('email').unique().notNull(),
+  password_hash: text('password_hash').notNull(),
+
+  /** Salário bruto informado pelo usuário (em R$) */
+  gross_salary: real('gross_salary').notNull().default(0),
+
+  /**
+   * Override manual do salário líquido.
+   * Quando NULL, o app usa o valor calculado automaticamente (INSS + IRRF).
+   * Quando preenchido, este valor é usado como base para o saldo disponível.
+   */
+  net_salary_override: real('net_salary_override'),
+
+  created_at: text('created_at')
+    .notNull()
+    .default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`),
+
+  updated_at: text('updated_at')
+    .notNull()
+    .default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`),
+});
+
+export type User = typeof users.$inferSelect;
+export type NewUser = typeof users.$inferInsert;
diff --git a/api/src/modules/auth/auth.routes.ts b/api/src/modules/auth/auth.routes.ts
new file mode 100644
index 0000000..d388694
--- /dev/null
+++ b/api/src/modules/auth/auth.routes.ts
@@ -0,0 +1,40 @@
+import type { FastifyPluginAsync } from 'fastify';
+import { ZodError } from 'zod';
+import { loginSchema, registerSchema } from './auth.schema';
+import * as authService from './auth.service';
+
+const authRoutes: FastifyPluginAsync = async (fastify) => {
+  fastify.post('/auth/register', async (request, reply) => {
+    try {
+      const body = registerSchema.parse(request.body);
+      const user = await authService.registerUser(body);
+      
+      const token = fastify.jwt.sign({ sub: user.id });
+      
+      return reply.status(201).send({ data: { user, token } });
+    } catch (err: any) {
+      if (err instanceof ZodError) {
+        return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+      }
+      return reply.status(400).send({ error: err.message });
+    }
+  });
+
+  fastify.post('/auth/login', async (request, reply) => {
+    try {
+      const body = loginSchema.parse(request.body);
+      const user = await authService.loginUser(body);
+      
+      const token = fastify.jwt.sign({ sub: user.id });
+      
+      return reply.send({ data: { user, token } });
+    } catch (err: any) {
+      if (err instanceof ZodError) {
+        return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+      }
+      return reply.status(401).send({ error: err.message });
+    }
+  });
+};
+
+export default authRoutes;
diff --git a/api/src/modules/auth/auth.schema.ts b/api/src/modules/auth/auth.schema.ts
new file mode 100644
index 0000000..550c670
--- /dev/null
+++ b/api/src/modules/auth/auth.schema.ts
@@ -0,0 +1,16 @@
+import { z } from 'zod';
+
+export const registerSchema = z.object({
+  name: z.string().min(2, 'Nome deve ter pelo menos 2 caracteres'),
+  email: z.string().email('Email inválido'),
+  password: z.string().min(6, 'Senha deve ter pelo menos 6 caracteres'),
+  gross_salary: z.coerce.number().min(0).optional(),
+});
+
+export const loginSchema = z.object({
+  email: z.string().email('Email inválido'),
+  password: z.string().min(6, 'Senha inválida'),
+});
+
+export type RegisterData = z.infer<typeof registerSchema>;
+export type LoginData = z.infer<typeof loginSchema>;
diff --git a/api/src/modules/auth/auth.service.ts b/api/src/modules/auth/auth.service.ts
new file mode 100644
index 0000000..c874b05
--- /dev/null
+++ b/api/src/modules/auth/auth.service.ts
@@ -0,0 +1,41 @@
+import bcrypt from 'bcryptjs';
+import { eq } from 'drizzle-orm';
+import { db } from '../../db/client';
+import { users } from '../../db/schema/users';
+import type { LoginData, RegisterData } from './auth.schema';
+
+export async function registerUser(data: RegisterData) {
+  const existingUser = await db.select().from(users).where(eq(users.email, data.email)).limit(1);
+  if (existingUser.length > 0) {
+    throw new Error('Email já está em uso.');
+  }
+
+  const salt = await bcrypt.genSalt(10);
+  const passwordHash = await bcrypt.hash(data.password, salt);
+
+  const [newUser] = await db.insert(users).values({
+    name: data.name,
+    email: data.email,
+    password_hash: passwordHash,
+    gross_salary: data.gross_salary || 0,
+  }).returning();
+
+  const { password_hash, ...userWithoutPassword } = newUser;
+  return userWithoutPassword;
+}
+
+export async function loginUser(data: LoginData) {
+  const [user] = await db.select().from(users).where(eq(users.email, data.email)).limit(1);
+  
+  if (!user) {
+    throw new Error('Email ou senha inválidos.');
+  }
+
+  const isValid = await bcrypt.compare(data.password, user.password_hash);
+  if (!isValid) {
+    throw new Error('Email ou senha inválidos.');
+  }
+
+  const { password_hash, ...userWithoutPassword } = user;
+  return userWithoutPassword;
+}
diff --git a/api/src/modules/dashboard/dashboard.routes.ts b/api/src/modules/dashboard/dashboard.routes.ts
new file mode 100644
index 0000000..d579ef2
--- /dev/null
+++ b/api/src/modules/dashboard/dashboard.routes.ts
@@ -0,0 +1,50 @@
+import type { FastifyPluginAsync } from 'fastify';
+import { z } from 'zod';
+import * as dashboardService from './dashboard.service';
+
+const dashboardQuerySchema = z.object({
+  month: z.coerce.number().int().min(1).max(12).optional(),
+  year: z.coerce.number().int().min(2020).optional(),
+});
+
+const dashboardParamsSchema = z.object({
+  userId: z.coerce.number().int().positive(),
+});
+
+const dashboardRoutes: FastifyPluginAsync = async (fastify) => {
+  /**
+   * GET /users/:userId/dashboard
+   * Retorna o resumo financeiro completo do mês.
+   *
+   * Query params (opcionais):
+   *   ?month=6&year=2025  → mês/ano específico
+   *   Sem params           → mês/ano atual
+   *
+   * Resposta:
+   *   - Dados do usuário e salário
+   *   - Lista de gastos recorrentes ativos
+   *   - Lista de gastos avulsos do mês
+   *   - Saldo disponível e percentual comprometido
+   */
+  fastify.get<{ Params: { userId: string }; Querystring: Record<string, string> }>(
+    '/users/:userId/dashboard',
+    async (request, reply) => {
+      const { userId } = dashboardParamsSchema.parse(request.params);
+      const query = dashboardQuerySchema.parse(request.query);
+
+      const now = new Date();
+      const month = query.month ?? now.getMonth() + 1;
+      const year = query.year ?? now.getFullYear();
+
+      const data = await dashboardService.getDashboard(userId, month, year);
+
+      if (!data) {
+        return reply.status(404).send({ error: 'Usuário não encontrado.' });
+      }
+
+      return reply.send({ data });
+    },
+  );
+};
+
+export default dashboardRoutes;
diff --git a/api/src/modules/dashboard/dashboard.service.ts b/api/src/modules/dashboard/dashboard.service.ts
new file mode 100644
index 0000000..78b1d1b
--- /dev/null
+++ b/api/src/modules/dashboard/dashboard.service.ts
@@ -0,0 +1,177 @@
+import { and, eq, gte, lte, sql } from 'drizzle-orm';
+import { db } from '@/db/client';
+import { incomes, oneTimeExpenses, recurringExpenses, users } from '@/db/schema';
+import { calcularSalarioLiquido } from '@/utils/tax-calculator';
+
+export interface DashboardData {
+  user: {
+    id: number;
+    name: string;
+    gross_salary: number;
+    net_salary_override: number | null;
+  };
+  period: {
+    month: number;
+    year: number;
+  };
+  salary: {
+    gross: number;
+    calculated_net: number;
+    effective_net: number;
+    inss_discount: number;
+    irrf_discount: number;
+    has_override: boolean;
+  };
+  expenses: {
+    recurring_total: number;
+    one_time_total: number;
+    total: number;
+    recurring_list: { id: number; name: string; amount: number; category: string }[];
+    one_time_list: {
+      id: number;
+      name: string;
+      amount: number;
+      category: string;
+      expense_date: string;
+    }[];
+  };
+  balance: {
+    available: number;
+    /** Percentual do salário líquido comprometido com despesas (0-100) */
+    expense_ratio: number;
+  };
+}
+
+export async function getDashboard(
+  userId: number,
+  referenceMonth: number,
+  referenceYear: number,
+): Promise<DashboardData | null> {
+  // 1. Busca o usuário
+  const [user] = await db
+    .select()
+    .from(users)
+    .where(eq(users.id, userId))
+    .limit(1);
+
+  if (!user) return null;
+
+  // 2. Calcula o salário via tabela INSS/IRRF
+  const taxResult = calcularSalarioLiquido(user.gross_salary);
+
+  // 3. Salário efetivo: usa override do usuário ou o calculado
+  const effectiveNet = user.net_salary_override ?? taxResult.salarioLiquidoCalculado;
+
+  // 4. Tenta encontrar um registro de renda para o mês/ano pedido
+  const [incomeRecord] = await db
+    .select()
+    .from(incomes)
+    .where(
+      and(
+        eq(incomes.user_id, userId),
+        eq(incomes.reference_month, referenceMonth),
+        eq(incomes.reference_year, referenceYear),
+      ),
+    )
+    .limit(1);
+
+  // Se existir registro de renda para o mês, usa os valores dele
+  const salaryData = incomeRecord
+    ? {
+        gross: incomeRecord.gross_salary,
+        calculated_net: incomeRecord.calculated_net_salary,
+        effective_net: incomeRecord.effective_net_salary,
+        inss_discount:
+          incomeRecord.gross_salary - incomeRecord.calculated_net_salary - 0, // simplificado
+        irrf_discount: 0,
+        has_override: incomeRecord.effective_net_salary !== incomeRecord.calculated_net_salary,
+      }
+    : {
+        gross: user.gross_salary,
+        calculated_net: taxResult.salarioLiquidoCalculado,
+        effective_net: effectiveNet,
+        inss_discount: taxResult.descontoINSS,
+        irrf_discount: taxResult.descontoIRRF,
+        has_override: user.net_salary_override !== null,
+      };
+
+  // 5. Busca gastos recorrentes ATIVOS e vigentes no mês/ano pedido
+  const refDateStr = `${referenceYear}-${String(referenceMonth).padStart(2, '0')}-01`;
+  const lastDay = new Date(referenceYear, referenceMonth, 0).getDate();
+  const refDateEndStr = `${referenceYear}-${String(referenceMonth).padStart(2, '0')}-${String(lastDay).padStart(2, '0')}`;
+
+  const recurringList = await db
+    .select()
+    .from(recurringExpenses)
+    .where(
+      and(
+        eq(recurringExpenses.user_id, userId),
+        eq(recurringExpenses.is_active, true),
+        lte(recurringExpenses.starts_at, refDateEndStr),
+        // ends_at IS NULL ou ends_at >= início do mês
+        sql`(${recurringExpenses.ends_at} IS NULL OR ${recurringExpenses.ends_at} >= ${refDateStr})`,
+      ),
+    );
+
+  // 6. Busca gastos avulsos do mês/ano pedido
+  const oneTimeList = await db
+    .select()
+    .from(oneTimeExpenses)
+    .where(
+      and(
+        eq(oneTimeExpenses.user_id, userId),
+        gte(oneTimeExpenses.expense_date, refDateStr),
+        lte(oneTimeExpenses.expense_date, refDateEndStr),
+      ),
+    )
+    .orderBy(oneTimeExpenses.expense_date);
+
+  // 7. Calcula totais
+  const recurringTotal = recurringList.reduce((sum, e) => {
+    return sum + (e.type === 'income' ? -e.amount : e.amount);
+  }, 0);
+  const oneTimeTotal = oneTimeList.reduce((sum, e) => {
+    return sum + (e.type === 'income' ? -e.amount : e.amount);
+  }, 0);
+  const totalExpenses = parseFloat((recurringTotal + oneTimeTotal).toFixed(2));
+  const available = parseFloat((salaryData.effective_net - totalExpenses).toFixed(2));
+  const expenseRatio =
+    salaryData.effective_net > 0
+      ? parseFloat(((totalExpenses / salaryData.effective_net) * 100).toFixed(1))
+      : 0;
+
+  return {
+    user: {
+      id: user.id,
+      name: user.name,
+      gross_salary: user.gross_salary,
+      net_salary_override: user.net_salary_override,
+    },
+    period: { month: referenceMonth, year: referenceYear },
+    salary: salaryData,
+    expenses: {
+      recurring_total: parseFloat(recurringTotal.toFixed(2)),
+      one_time_total: parseFloat(oneTimeTotal.toFixed(2)),
+      total: totalExpenses,
+      recurring_list: recurringList.map((e) => ({
+        id: e.id,
+        name: e.name,
+        amount: e.amount,
+        category: e.category,
+        type: e.type,
+      })),
+      one_time_list: oneTimeList.map((e) => ({
+        id: e.id,
+        name: e.name,
+        amount: e.amount,
+        category: e.category,
+        type: e.type,
+        expense_date: e.expense_date,
+      })),
+    },
+    balance: {
+      available,
+      expense_ratio: expenseRatio,
+    },
+  };
+}
diff --git a/api/src/modules/incomes/incomes.routes.ts b/api/src/modules/incomes/incomes.routes.ts
new file mode 100644
index 0000000..7932d18
--- /dev/null
+++ b/api/src/modules/incomes/incomes.routes.ts
@@ -0,0 +1,97 @@
+import type { FastifyPluginAsync } from 'fastify';
+import { ZodError } from 'zod';
+import {
+  createIncomeSchema,
+  incomeParamsSchema,
+  incomeQuerySchema,
+  incomeUserParamsSchema,
+  updateIncomeSchema,
+} from './incomes.schema';
+import * as incomesService from './incomes.service';
+
+const incomesRoutes: FastifyPluginAsync = async (fastify) => {
+  /**
+   * GET /users/:userId/incomes
+   * Lista todas as rendas de um usuário.
+   * Query params: ?month=6&year=2025
+   */
+  fastify.get<{ Params: { userId: string }; Querystring: Record<string, string> }>(
+    '/users/:userId/incomes',
+    async (request, reply) => {
+      const { userId } = incomeUserParamsSchema.parse(request.params);
+      const query = incomeQuerySchema.parse(request.query);
+      const result = await incomesService.findIncomesByUser(userId, query);
+      return reply.send({ data: result });
+    },
+  );
+
+  /** GET /users/:userId/incomes/:id — Busca uma renda específica */
+  fastify.get<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/incomes/:id',
+    async (request, reply) => {
+      const { userId, id } = incomeParamsSchema.parse(request.params);
+      const income = await incomesService.findIncomeById(userId, id);
+
+      if (!income) {
+        return reply.status(404).send({ error: 'Renda não encontrada.' });
+      }
+      return reply.send({ data: income });
+    },
+  );
+
+  /** POST /users/:userId/incomes — Registra a renda de um mês */
+  fastify.post<{ Params: { userId: string } }>(
+    '/users/:userId/incomes',
+    async (request, reply) => {
+      try {
+        const { userId } = incomeUserParamsSchema.parse(request.params);
+        const body = createIncomeSchema.parse(request.body);
+        const income = await incomesService.createIncome(userId, body);
+        return reply.status(201).send({ data: income });
+      } catch (err) {
+        if (err instanceof ZodError) {
+          return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+        }
+        throw err;
+      }
+    },
+  );
+
+  /** PUT /users/:userId/incomes/:id — Atualiza uma renda */
+  fastify.put<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/incomes/:id',
+    async (request, reply) => {
+      try {
+        const { userId, id } = incomeParamsSchema.parse(request.params);
+        const body = updateIncomeSchema.parse(request.body);
+        const income = await incomesService.updateIncome(userId, id, body);
+
+        if (!income) {
+          return reply.status(404).send({ error: 'Renda não encontrada.' });
+        }
+        return reply.send({ data: income });
+      } catch (err) {
+        if (err instanceof ZodError) {
+          return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+        }
+        throw err;
+      }
+    },
+  );
+
+  /** DELETE /users/:userId/incomes/:id — Remove uma renda */
+  fastify.delete<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/incomes/:id',
+    async (request, reply) => {
+      const { userId, id } = incomeParamsSchema.parse(request.params);
+      const deleted = await incomesService.deleteIncome(userId, id);
+
+      if (!deleted) {
+        return reply.status(404).send({ error: 'Renda não encontrada.' });
+      }
+      return reply.status(200).send({ data: deleted, message: 'Renda removida com sucesso.' });
+    },
+  );
+};
+
+export default incomesRoutes;
diff --git a/api/src/modules/incomes/incomes.schema.ts b/api/src/modules/incomes/incomes.schema.ts
new file mode 100644
index 0000000..cc661fd
--- /dev/null
+++ b/api/src/modules/incomes/incomes.schema.ts
@@ -0,0 +1,38 @@
+import { z } from 'zod';
+
+export const createIncomeSchema = z.object({
+  gross_salary: z.number().positive('Salário bruto deve ser positivo'),
+  /**
+   * Salário líquido efetivo (após override do usuário).
+   * Deve ser enviado pelo app após o cálculo de INSS/IRRF.
+   */
+  calculated_net_salary: z.number().nonnegative(),
+  effective_net_salary: z.number().nonnegative(),
+  reference_month: z.number().int().min(1).max(12),
+  reference_year: z.number().int().min(2020).max(2100),
+  description: z.string().max(255).nullable().optional(),
+});
+
+export const updateIncomeSchema = z.object({
+  gross_salary: z.number().positive().optional(),
+  calculated_net_salary: z.number().nonnegative().optional(),
+  effective_net_salary: z.number().nonnegative().optional(),
+  description: z.string().max(255).nullable().optional(),
+});
+
+export const incomeParamsSchema = z.object({
+  userId: z.coerce.number().int().positive(),
+  id: z.coerce.number().int().positive(),
+});
+
+export const incomeUserParamsSchema = z.object({
+  userId: z.coerce.number().int().positive(),
+});
+
+export const incomeQuerySchema = z.object({
+  month: z.coerce.number().int().min(1).max(12).optional(),
+  year: z.coerce.number().int().min(2020).optional(),
+});
+
+export type CreateIncomeInput = z.infer<typeof createIncomeSchema>;
+export type UpdateIncomeInput = z.infer<typeof updateIncomeSchema>;
diff --git a/api/src/modules/incomes/incomes.service.ts b/api/src/modules/incomes/incomes.service.ts
new file mode 100644
index 0000000..0a9ea84
--- /dev/null
+++ b/api/src/modules/incomes/incomes.service.ts
@@ -0,0 +1,83 @@
+import { and, eq } from 'drizzle-orm';
+import { db } from '@/db/client';
+import { incomes } from '@/db/schema';
+import type { CreateIncomeInput, UpdateIncomeInput } from './incomes.schema';
+
+export async function findIncomesByUser(
+  userId: number,
+  filters?: { month?: number; year?: number },
+) {
+  const conditions = [eq(incomes.user_id, userId)];
+
+  if (filters?.month !== undefined) {
+    conditions.push(eq(incomes.reference_month, filters.month));
+  }
+  if (filters?.year !== undefined) {
+    conditions.push(eq(incomes.reference_year, filters.year));
+  }
+
+  return db
+    .select()
+    .from(incomes)
+    .where(and(...conditions))
+    .orderBy(incomes.reference_year, incomes.reference_month);
+}
+
+export async function findIncomeById(userId: number, id: number) {
+  const result = await db
+    .select()
+    .from(incomes)
+    .where(and(eq(incomes.user_id, userId), eq(incomes.id, id)))
+    .limit(1);
+  return result[0] ?? null;
+}
+
+export async function createIncome(userId: number, data: CreateIncomeInput) {
+  const [created] = await db
+    .insert(incomes)
+    .values({
+      user_id: userId,
+      gross_salary: data.gross_salary,
+      calculated_net_salary: data.calculated_net_salary,
+      effective_net_salary: data.effective_net_salary,
+      reference_month: data.reference_month,
+      reference_year: data.reference_year,
+      description: data.description ?? null,
+    })
+    .returning();
+  return created;
+}
+
+export async function updateIncome(
+  userId: number,
+  id: number,
+  data: UpdateIncomeInput,
+) {
+  const now = new Date().toISOString();
+
+  const [updated] = await db
+    .update(incomes)
+    .set({
+      ...(data.gross_salary !== undefined && { gross_salary: data.gross_salary }),
+      ...(data.calculated_net_salary !== undefined && {
+        calculated_net_salary: data.calculated_net_salary,
+      }),
+      ...(data.effective_net_salary !== undefined && {
+        effective_net_salary: data.effective_net_salary,
+      }),
+      ...(data.description !== undefined && { description: data.description }),
+      updated_at: now,
+    })
+    .where(and(eq(incomes.user_id, userId), eq(incomes.id, id)))
+    .returning();
+
+  return updated ?? null;
+}
+
+export async function deleteIncome(userId: number, id: number) {
+  const [deleted] = await db
+    .delete(incomes)
+    .where(and(eq(incomes.user_id, userId), eq(incomes.id, id)))
+    .returning();
+  return deleted ?? null;
+}
diff --git a/api/src/modules/one-time-expenses/one-time-expenses.routes.ts b/api/src/modules/one-time-expenses/one-time-expenses.routes.ts
new file mode 100644
index 0000000..0658cfc
--- /dev/null
+++ b/api/src/modules/one-time-expenses/one-time-expenses.routes.ts
@@ -0,0 +1,97 @@
+import type { FastifyPluginAsync } from 'fastify';
+import { ZodError } from 'zod';
+import {
+  createOneTimeExpenseSchema,
+  oneTimeExpenseParamsSchema,
+  oneTimeExpenseQuerySchema,
+  oneTimeExpenseUserParamsSchema,
+  updateOneTimeExpenseSchema,
+} from './one-time-expenses.schema';
+import * as oneTimeService from './one-time-expenses.service';
+
+const oneTimeExpensesRoutes: FastifyPluginAsync = async (fastify) => {
+  /**
+   * GET /users/:userId/one-time-expenses
+   * Lista gastos avulsos do usuário.
+   * Query params: ?month=6&year=2025
+   */
+  fastify.get<{ Params: { userId: string }; Querystring: Record<string, string> }>(
+    '/users/:userId/one-time-expenses',
+    async (request, reply) => {
+      const { userId } = oneTimeExpenseUserParamsSchema.parse(request.params);
+      const query = oneTimeExpenseQuerySchema.parse(request.query);
+      const result = await oneTimeService.findOneTimeExpensesByUser(userId, query);
+      return reply.send({ data: result });
+    },
+  );
+
+  /** GET /users/:userId/one-time-expenses/:id — Busca um gasto avulso específico */
+  fastify.get<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/one-time-expenses/:id',
+    async (request, reply) => {
+      const { userId, id } = oneTimeExpenseParamsSchema.parse(request.params);
+      const expense = await oneTimeService.findOneTimeExpenseById(userId, id);
+
+      if (!expense) {
+        return reply.status(404).send({ error: 'Gasto avulso não encontrado.' });
+      }
+      return reply.send({ data: expense });
+    },
+  );
+
+  /** POST /users/:userId/one-time-expenses — Adiciona um gasto avulso */
+  fastify.post<{ Params: { userId: string } }>(
+    '/users/:userId/one-time-expenses',
+    async (request, reply) => {
+      try {
+        const { userId } = oneTimeExpenseUserParamsSchema.parse(request.params);
+        const body = createOneTimeExpenseSchema.parse(request.body);
+        const expense = await oneTimeService.createOneTimeExpense(userId, body);
+        return reply.status(201).send({ data: expense });
+      } catch (err) {
+        if (err instanceof ZodError) {
+          return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+        }
+        throw err;
+      }
+    },
+  );
+
+  /** PUT /users/:userId/one-time-expenses/:id — Atualiza um gasto avulso */
+  fastify.put<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/one-time-expenses/:id',
+    async (request, reply) => {
+      try {
+        const { userId, id } = oneTimeExpenseParamsSchema.parse(request.params);
+        const body = updateOneTimeExpenseSchema.parse(request.body);
+        const expense = await oneTimeService.updateOneTimeExpense(userId, id, body);
+
+        if (!expense) {
+          return reply.status(404).send({ error: 'Gasto avulso não encontrado.' });
+        }
+        return reply.send({ data: expense });
+      } catch (err) {
+        if (err instanceof ZodError) {
+          return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+        }
+        throw err;
+      }
+    },
+  );
+
+  /** DELETE /users/:userId/one-time-expenses/:id — Remove um gasto avulso */
+  fastify.delete<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/one-time-expenses/:id',
+    async (request, reply) => {
+      const { userId, id } = oneTimeExpenseParamsSchema.parse(request.params);
+      const deleted = await oneTimeService.deleteOneTimeExpense(userId, id);
+
+      if (!deleted) {
+        return reply.status(404).send({ error: 'Gasto avulso não encontrado.' });
+      }
+      return reply.status(200).send({ data: deleted, message: 'Gasto avulso removido com sucesso.' });
+    },
+  );
+};
+
+export default oneTimeExpensesRoutes;
diff --git a/api/src/modules/one-time-expenses/one-time-expenses.schema.ts b/api/src/modules/one-time-expenses/one-time-expenses.schema.ts
new file mode 100644
index 0000000..9e32c8d
--- /dev/null
+++ b/api/src/modules/one-time-expenses/one-time-expenses.schema.ts
@@ -0,0 +1,54 @@
+import { z } from 'zod';
+
+const CATEGORIES = [
+  'moradia',
+  'alimentação',
+  'transporte',
+  'saúde',
+  'educação',
+  'lazer',
+  'serviços',
+  'outros',
+] as const;
+
+export const categoryEnum = z.enum(CATEGORIES);
+export const typeEnum = z.enum(['expense', 'income']);
+
+export const createOneTimeExpenseSchema = z.object({
+  name: z.string().min(1, 'Nome é obrigatório').max(100),
+  amount: z.number().positive('Valor deve ser positivo'),
+  category: categoryEnum.default('outros'),
+  type: typeEnum.default('expense'),
+  /** Data do gasto no formato YYYY-MM-DD. Default: hoje. */
+  expense_date: z
+    .string()
+    .regex(/^\d{4}-\d{2}-\d{2}$/, 'Formato: YYYY-MM-DD')
+    .optional(),
+  notes: z.string().max(500).nullable().optional(),
+});
+
+export const updateOneTimeExpenseSchema = z.object({
+  name: z.string().min(1).max(100).optional(),
+  amount: z.number().positive().optional(),
+  category: categoryEnum.optional(),
+  type: typeEnum.optional(),
+  expense_date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  notes: z.string().max(500).nullable().optional(),
+});
+
+export const oneTimeExpenseParamsSchema = z.object({
+  userId: z.coerce.number().int().positive(),
+  id: z.coerce.number().int().positive(),
+});
+
+export const oneTimeExpenseUserParamsSchema = z.object({
+  userId: z.coerce.number().int().positive(),
+});
+
+export const oneTimeExpenseQuerySchema = z.object({
+  month: z.coerce.number().int().min(1).max(12).optional(),
+  year: z.coerce.number().int().min(2020).optional(),
+});
+
+export type CreateOneTimeExpenseInput = z.infer<typeof createOneTimeExpenseSchema>;
+export type UpdateOneTimeExpenseInput = z.infer<typeof updateOneTimeExpenseSchema>;
diff --git a/api/src/modules/one-time-expenses/one-time-expenses.service.ts b/api/src/modules/one-time-expenses/one-time-expenses.service.ts
new file mode 100644
index 0000000..c55640d
--- /dev/null
+++ b/api/src/modules/one-time-expenses/one-time-expenses.service.ts
@@ -0,0 +1,102 @@
+import { and, between, eq } from 'drizzle-orm';
+import { db } from '@/db/client';
+import { oneTimeExpenses } from '@/db/schema';
+import type {
+  CreateOneTimeExpenseInput,
+  UpdateOneTimeExpenseInput,
+} from './one-time-expenses.schema';
+
+export async function findOneTimeExpensesByUser(
+  userId: number,
+  filters?: { month?: number; year?: number },
+) {
+  const conditions = [eq(oneTimeExpenses.user_id, userId)];
+
+  // Filtra pelo mês/ano usando range de datas no formato YYYY-MM-DD
+  if (filters?.month !== undefined && filters?.year !== undefined) {
+    const year = filters.year;
+    const month = filters.month;
+    const startDate = `${year}-${String(month).padStart(2, '0')}-01`;
+    // Último dia do mês: pega o dia 0 do mês seguinte
+    const lastDay = new Date(year, month, 0).getDate();
+    const endDate = `${year}-${String(month).padStart(2, '0')}-${String(lastDay).padStart(2, '0')}`;
+    conditions.push(between(oneTimeExpenses.expense_date, startDate, endDate));
+  } else if (filters?.year !== undefined) {
+    const year = filters.year;
+    conditions.push(
+      between(oneTimeExpenses.expense_date, `${year}-01-01`, `${year}-12-31`),
+    );
+  }
+
+  return db
+    .select()
+    .from(oneTimeExpenses)
+    .where(and(...conditions))
+    .orderBy(oneTimeExpenses.expense_date);
+}
+
+export async function findOneTimeExpenseById(userId: number, id: number) {
+  const result = await db
+    .select()
+    .from(oneTimeExpenses)
+    .where(
+      and(eq(oneTimeExpenses.user_id, userId), eq(oneTimeExpenses.id, id)),
+    )
+    .limit(1);
+  return result[0] ?? null;
+}
+
+export async function createOneTimeExpense(
+  userId: number,
+  data: CreateOneTimeExpenseInput,
+) {
+  const [created] = await db
+    .insert(oneTimeExpenses)
+    .values({
+      user_id: userId,
+      name: data.name,
+      amount: data.amount,
+      category: data.category,
+      type: data.type,
+      expense_date: data.expense_date,
+      notes: data.notes ?? null,
+    })
+    .returning();
+  return created;
+}
+
+export async function updateOneTimeExpense(
+  userId: number,
+  id: number,
+  data: UpdateOneTimeExpenseInput,
+) {
+  const now = new Date().toISOString();
+
+  const [updated] = await db
+    .update(oneTimeExpenses)
+    .set({
+      ...(data.name !== undefined && { name: data.name }),
+      ...(data.amount !== undefined && { amount: data.amount }),
+      ...(data.category !== undefined && { category: data.category }),
+      ...(data.type !== undefined && { type: data.type }),
+      ...(data.expense_date !== undefined && { expense_date: data.expense_date }),
+      ...(data.notes !== undefined && { notes: data.notes }),
+      updated_at: now,
+    })
+    .where(
+      and(eq(oneTimeExpenses.user_id, userId), eq(oneTimeExpenses.id, id)),
+    )
+    .returning();
+
+  return updated ?? null;
+}
+
+export async function deleteOneTimeExpense(userId: number, id: number) {
+  const [deleted] = await db
+    .delete(oneTimeExpenses)
+    .where(
+      and(eq(oneTimeExpenses.user_id, userId), eq(oneTimeExpenses.id, id)),
+    )
+    .returning();
+  return deleted ?? null;
+}
diff --git a/api/src/modules/recurring-expenses/recurring-expenses.routes.ts b/api/src/modules/recurring-expenses/recurring-expenses.routes.ts
new file mode 100644
index 0000000..73594e8
--- /dev/null
+++ b/api/src/modules/recurring-expenses/recurring-expenses.routes.ts
@@ -0,0 +1,108 @@
+import type { FastifyPluginAsync } from 'fastify';
+import { ZodError } from 'zod';
+import {
+  createRecurringExpenseSchema,
+  recurringExpenseParamsSchema,
+  recurringExpenseUserParamsSchema,
+  updateRecurringExpenseSchema,
+} from './recurring-expenses.schema';
+import * as recurringService from './recurring-expenses.service';
+
+const recurringExpensesRoutes: FastifyPluginAsync = async (fastify) => {
+  /** GET /users/:userId/recurring-expenses — Lista todos os gastos recorrentes */
+  fastify.get<{ Params: { userId: string } }>(
+    '/users/:userId/recurring-expenses',
+    async (request, reply) => {
+      const { userId } = recurringExpenseUserParamsSchema.parse(request.params);
+      const result = await recurringService.findRecurringExpensesByUser(userId);
+      return reply.send({ data: result });
+    },
+  );
+
+  /** GET /users/:userId/recurring-expenses/:id — Busca um gasto recorrente específico */
+  fastify.get<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/recurring-expenses/:id',
+    async (request, reply) => {
+      const { userId, id } = recurringExpenseParamsSchema.parse(request.params);
+      const expense = await recurringService.findRecurringExpenseById(userId, id);
+
+      if (!expense) {
+        return reply.status(404).send({ error: 'Gasto recorrente não encontrado.' });
+      }
+      return reply.send({ data: expense });
+    },
+  );
+
+  /** POST /users/:userId/recurring-expenses — Cadastra um novo gasto fixo */
+  fastify.post<{ Params: { userId: string } }>(
+    '/users/:userId/recurring-expenses',
+    async (request, reply) => {
+      try {
+        const { userId } = recurringExpenseUserParamsSchema.parse(request.params);
+        const body = createRecurringExpenseSchema.parse(request.body);
+        const expense = await recurringService.createRecurringExpense(userId, body);
+        return reply.status(201).send({ data: expense });
+      } catch (err) {
+        if (err instanceof ZodError) {
+          return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+        }
+        throw err;
+      }
+    },
+  );
+
+  /** PUT /users/:userId/recurring-expenses/:id — Atualiza um gasto recorrente */
+  fastify.put<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/recurring-expenses/:id',
+    async (request, reply) => {
+      try {
+        const { userId, id } = recurringExpenseParamsSchema.parse(request.params);
+        const body = updateRecurringExpenseSchema.parse(request.body);
+        const expense = await recurringService.updateRecurringExpense(userId, id, body);
+
+        if (!expense) {
+          return reply.status(404).send({ error: 'Gasto recorrente não encontrado.' });
+        }
+        return reply.send({ data: expense });
+      } catch (err) {
+        if (err instanceof ZodError) {
+          return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+        }
+        throw err;
+      }
+    },
+  );
+
+  /**
+   * PATCH /users/:userId/recurring-expenses/:id/toggle
+   * Ativa ou desativa um gasto recorrente sem precisar deletar.
+   */
+  fastify.patch<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/recurring-expenses/:id/toggle',
+    async (request, reply) => {
+      const { userId, id } = recurringExpenseParamsSchema.parse(request.params);
+      const expense = await recurringService.toggleRecurringExpense(userId, id);
+
+      if (!expense) {
+        return reply.status(404).send({ error: 'Gasto recorrente não encontrado.' });
+      }
+      return reply.send({ data: expense });
+    },
+  );
+
+  /** DELETE /users/:userId/recurring-expenses/:id — Remove um gasto recorrente */
+  fastify.delete<{ Params: { userId: string; id: string } }>(
+    '/users/:userId/recurring-expenses/:id',
+    async (request, reply) => {
+      const { userId, id } = recurringExpenseParamsSchema.parse(request.params);
+      const deleted = await recurringService.deleteRecurringExpense(userId, id);
+
+      if (!deleted) {
+        return reply.status(404).send({ error: 'Gasto recorrente não encontrado.' });
+      }
+      return reply.status(200).send({ data: deleted, message: 'Gasto recorrente removido com sucesso.' });
+    },
+  );
+};
+
+export default recurringExpensesRoutes;
diff --git a/api/src/modules/recurring-expenses/recurring-expenses.schema.ts b/api/src/modules/recurring-expenses/recurring-expenses.schema.ts
new file mode 100644
index 0000000..8f9d473
--- /dev/null
+++ b/api/src/modules/recurring-expenses/recurring-expenses.schema.ts
@@ -0,0 +1,49 @@
+import { z } from 'zod';
+
+const CATEGORIES = [
+  'moradia',
+  'alimentação',
+  'transporte',
+  'saúde',
+  'educação',
+  'lazer',
+  'serviços',
+  'outros',
+] as const;
+
+export const categoryEnum = z.enum(CATEGORIES);
+export const typeEnum = z.enum(['expense', 'income']);
+
+export const createRecurringExpenseSchema = z.object({
+  name: z.string().min(1, 'Nome é obrigatório').max(100),
+  amount: z.number().positive('Valor deve ser positivo'),
+  category: categoryEnum.default('outros'),
+  type: typeEnum.default('expense'),
+  due_day: z.number().int().min(1).max(31).nullable().optional(),
+  is_active: z.boolean().default(true),
+  starts_at: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Formato: YYYY-MM-DD').optional(),
+  ends_at: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Formato: YYYY-MM-DD').nullable().optional(),
+});
+
+export const updateRecurringExpenseSchema = z.object({
+  name: z.string().min(1).max(100).optional(),
+  amount: z.number().positive().optional(),
+  category: categoryEnum.optional(),
+  type: typeEnum.optional(),
+  due_day: z.number().int().min(1).max(31).nullable().optional(),
+  is_active: z.boolean().optional(),
+  starts_at: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  ends_at: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().optional(),
+});
+
+export const recurringExpenseParamsSchema = z.object({
+  userId: z.coerce.number().int().positive(),
+  id: z.coerce.number().int().positive(),
+});
+
+export const recurringExpenseUserParamsSchema = z.object({
+  userId: z.coerce.number().int().positive(),
+});
+
+export type CreateRecurringExpenseInput = z.infer<typeof createRecurringExpenseSchema>;
+export type UpdateRecurringExpenseInput = z.infer<typeof updateRecurringExpenseSchema>;
diff --git a/api/src/modules/recurring-expenses/recurring-expenses.service.ts b/api/src/modules/recurring-expenses/recurring-expenses.service.ts
new file mode 100644
index 0000000..2bb9720
--- /dev/null
+++ b/api/src/modules/recurring-expenses/recurring-expenses.service.ts
@@ -0,0 +1,115 @@
+import { and, eq } from 'drizzle-orm';
+import { db } from '@/db/client';
+import { recurringExpenses } from '@/db/schema';
+import type {
+  CreateRecurringExpenseInput,
+  UpdateRecurringExpenseInput,
+} from './recurring-expenses.schema';
+
+export async function findRecurringExpensesByUser(userId: number) {
+  return db
+    .select()
+    .from(recurringExpenses)
+    .where(eq(recurringExpenses.user_id, userId))
+    .orderBy(recurringExpenses.name);
+}
+
+export async function findRecurringExpenseById(userId: number, id: number) {
+  const result = await db
+    .select()
+    .from(recurringExpenses)
+    .where(
+      and(
+        eq(recurringExpenses.user_id, userId),
+        eq(recurringExpenses.id, id),
+      ),
+    )
+    .limit(1);
+  return result[0] ?? null;
+}
+
+export async function createRecurringExpense(
+  userId: number,
+  data: CreateRecurringExpenseInput,
+) {
+  const [created] = await db
+    .insert(recurringExpenses)
+    .values({
+      user_id: userId,
+      name: data.name,
+      amount: data.amount,
+      category: data.category,
+      type: data.type,
+      due_day: data.due_day ?? null,
+      is_active: data.is_active,
+      starts_at: data.starts_at,
+      ends_at: data.ends_at ?? null,
+    })
+    .returning();
+  return created;
+}
+
+export async function updateRecurringExpense(
+  userId: number,
+  id: number,
+  data: UpdateRecurringExpenseInput,
+) {
+  const now = new Date().toISOString();
+
+  const [updated] = await db
+    .update(recurringExpenses)
+    .set({
+      ...(data.name !== undefined && { name: data.name }),
+      ...(data.amount !== undefined && { amount: data.amount }),
+      ...(data.category !== undefined && { category: data.category }),
+      ...(data.type !== undefined && { type: data.type }),
+      ...(data.due_day !== undefined && { due_day: data.due_day }),
+      ...(data.is_active !== undefined && { is_active: data.is_active }),
+      ...(data.starts_at !== undefined && { starts_at: data.starts_at }),
+      ...(data.ends_at !== undefined && { ends_at: data.ends_at }),
+      updated_at: now,
+    })
+    .where(
+      and(
+        eq(recurringExpenses.user_id, userId),
+        eq(recurringExpenses.id, id),
+      ),
+    )
+    .returning();
+
+  return updated ?? null;
+}
+
+export async function toggleRecurringExpense(userId: number, id: number) {
+  const expense = await findRecurringExpenseById(userId, id);
+  if (!expense) return null;
+
+  const [updated] = await db
+    .update(recurringExpenses)
+    .set({
+      is_active: !expense.is_active,
+      updated_at: new Date().toISOString(),
+    })
+    .where(
+      and(
+        eq(recurringExpenses.user_id, userId),
+        eq(recurringExpenses.id, id),
+      ),
+    )
+    .returning();
+
+  return updated ?? null;
+}
+
+export async function deleteRecurringExpense(userId: number, id: number) {
+  const [deleted] = await db
+    .delete(recurringExpenses)
+    .where(
+      and(
+        eq(recurringExpenses.user_id, userId),
+        eq(recurringExpenses.id, id),
+      ),
+    )
+    .returning();
+  return deleted ?? null;
+}
diff --git a/api/src/modules/users/users.routes.ts b/api/src/modules/users/users.routes.ts
new file mode 100644
index 0000000..28cf584
--- /dev/null
+++ b/api/src/modules/users/users.routes.ts
@@ -0,0 +1,73 @@
+import type { FastifyPluginAsync } from 'fastify';
+import { ZodError } from 'zod';
+import {
+  createUserSchema,
+  updateUserSchema,
+  userParamsSchema,
+} from './users.schema';
+import * as usersService from './users.service';
+
+const usersRoutes: FastifyPluginAsync = async (fastify) => {
+  /** GET /users — Lista todos os usuários */
+  fastify.get('/users', async (_request, reply) => {
+    const result = await usersService.findAllUsers();
+    return reply.send({ data: result });
+  });
+
+  /** GET /users/:id — Busca um usuário pelo ID */
+  fastify.get<{ Params: { id: string } }>('/users/:id', async (request, reply) => {
+    const { id } = userParamsSchema.parse(request.params);
+    const user = await usersService.findUserById(id);
+
+    if (!user) {
+      return reply.status(404).send({ error: 'Usuário não encontrado.' });
+    }
+    return reply.send({ data: user });
+  });
+
+  /** POST /users — Cria um novo usuário */
+  fastify.post('/users', async (request, reply) => {
+    try {
+      const body = createUserSchema.parse(request.body);
+      const user = await usersService.createUser(body);
+      return reply.status(201).send({ data: user });
+    } catch (err) {
+      if (err instanceof ZodError) {
+        return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+      }
+      throw err;
+    }
+  });
+
+  /** PUT /users/:id — Atualiza um usuário (incluindo salário e override) */
+  fastify.put<{ Params: { id: string } }>('/users/:id', async (request, reply) => {
+    try {
+      const { id } = userParamsSchema.parse(request.params);
+      const body = updateUserSchema.parse(request.body);
+      const user = await usersService.updateUser(id, body);
+
+      if (!user) {
+        return reply.status(404).send({ error: 'Usuário não encontrado.' });
+      }
+      return reply.send({ data: user });
+    } catch (err) {
+      if (err instanceof ZodError) {
+        return reply.status(400).send({ error: 'Dados inválidos.', details: err.errors });
+      }
+      throw err;
+    }
+  });
+
+  /** DELETE /users/:id — Remove um usuário (cascade nos gastos) */
+  fastify.delete<{ Params: { id: string } }>('/users/:id', async (request, reply) => {
+    const { id } = userParamsSchema.parse(request.params);
+    const deleted = await usersService.deleteUser(id);
+
+    if (!deleted) {
+      return reply.status(404).send({ error: 'Usuário não encontrado.' });
+    }
+    return reply.status(200).send({ data: deleted, message: 'Usuário removido com sucesso.' });
+  });
+};
+
+export default usersRoutes;
diff --git a/api/src/modules/users/users.schema.ts b/api/src/modules/users/users.schema.ts
new file mode 100644
index 0000000..62ab514
--- /dev/null
+++ b/api/src/modules/users/users.schema.ts
@@ -0,0 +1,23 @@
+import { z } from 'zod';
+
+export const createUserSchema = z.object({
+  name: z.string().min(1, 'Nome é obrigatório').max(100),
+  gross_salary: z.number().nonnegative('Salário bruto deve ser >= 0'),
+  net_salary_override: z.number().nonnegative().nullable().optional(),
+});
+
+export const updateUserSchema = z.object({
+  name: z.string().min(1).max(100).optional(),
+  gross_salary: z.number().nonnegative().optional(),
+  /**
+   * Envia `null` para limpar o override e voltar ao valor calculado automaticamente.
+   */
+  net_salary_override: z.number().nonnegative().nullable().optional(),
+});
+
+export const userParamsSchema = z.object({
+  id: z.coerce.number().int().positive(),
+});
+
+export type CreateUserInput = z.infer<typeof createUserSchema>;
+export type UpdateUserInput = z.infer<typeof updateUserSchema>;
diff --git a/api/src/modules/users/users.service.ts b/api/src/modules/users/users.service.ts
new file mode 100644
index 0000000..a0fda40
--- /dev/null
+++ b/api/src/modules/users/users.service.ts
@@ -0,0 +1,53 @@
+import { eq } from 'drizzle-orm';
+import { db } from '@/db/client';
+import { users } from '@/db/schema';
+import type { CreateUserInput, UpdateUserInput } from './users.schema';
+
+export async function findAllUsers() {
+  return db.select().from(users);
+}
+
+export async function findUserById(id: number) {
+  const result = await db.select().from(users).where(eq(users.id, id)).limit(1);
+  return result[0] ?? null;
+}
+
+export async function createUser(data: CreateUserInput) {
+  const [created] = await db
+    .insert(users)
+    .values({
+      name: data.name,
+      gross_salary: data.gross_salary,
+      net_salary_override: data.net_salary_override ?? null,
+    })
+    .returning();
+  return created;
+}
+
+export async function updateUser(id: number, data: UpdateUserInput) {
+  const now = new Date().toISOString();
+
+  const [updated] = await db
+    .update(users)
+    .set({
+      ...(data.name !== undefined && { name: data.name }),
+      ...(data.gross_salary !== undefined && { gross_salary: data.gross_salary }),
+      // Permite setar null explicitamente (para remover o override)
+      ...(data.net_salary_override !== undefined && {
+        net_salary_override: data.net_salary_override,
+      }),
+      updated_at: now,
+    })
+    .where(eq(users.id, id))
+    .returning();
+
+  return updated ?? null;
+}
+
+export async function deleteUser(id: number) {
+  const [deleted] = await db
+    .delete(users)
+    .where(eq(users.id, id))
+    .returning();
+  return deleted ?? null;
+}
diff --git a/api/src/plugins/cors.ts b/api/src/plugins/cors.ts
new file mode 100644
index 0000000..5398e39
--- /dev/null
+++ b/api/src/plugins/cors.ts
@@ -0,0 +1,18 @@
+import cors from '@fastify/cors';
+import type { FastifyPluginAsync } from 'fastify';
+
+/**
+ * Plugin de CORS para o Fastify.
+ * Em produção, substitua o `origin: true` pelo domínio/IP do seu app mobile
+ * ou pelo endereço da sua VPS.
+ */
+const corsPlugin: FastifyPluginAsync = async (fastify) => {
+  fastify.register(cors, {
+    // Em dev: aceita qualquer origem
+    // Em prod: restrinja para o IP/domínio conhecido
+    origin: process.env.CORS_ORIGIN ?? true,
+    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+  });
+};
+
+export default corsPlugin;
diff --git a/api/src/server.ts b/api/src/server.ts
new file mode 100644
index 0000000..6b3fd46
--- /dev/null
+++ b/api/src/server.ts
@@ -0,0 +1,89 @@
+import Fastify from 'fastify';
+import corsPlugin from './plugins/cors';
+import fastifyJwt from '@fastify/jwt';
+import authRoutes from './modules/auth/auth.routes';
+import dashboardRoutes from './modules/dashboard/dashboard.routes';
+import incomesRoutes from './modules/incomes/incomes.routes';
+import oneTimeExpensesRoutes from './modules/one-time-expenses/one-time-expenses.routes';
+import recurringExpensesRoutes from './modules/recurring-expenses/recurring-expenses.routes';
+import usersRoutes from './modules/users/users.routes';
+
+const PORT = Number(process.env.PORT) || 3333;
+const HOST = process.env.HOST ?? '0.0.0.0';
+
+const fastify = Fastify({
+  logger: {
+    transport:
+      process.env.NODE_ENV === 'development'
+        ? { target: 'pino-pretty', options: { colorize: true } }
+        : undefined,
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Plugins globais
+// ---------------------------------------------------------------------------
+fastify.register(corsPlugin);
+
+fastify.register(fastifyJwt, {
+  secret: process.env.JWT_SECRET || 'super-secret-yaba-jwt-key-2026',
+});
+
+// ---------------------------------------------------------------------------
+// JWT Middleware
+// ---------------------------------------------------------------------------
+fastify.addHook('onRequest', async (request, reply) => {
+  if (request.url.includes('/api/v1/auth') || request.url.startsWith('/health')) {
+    return; // Pula autenticação para rotas públicas
+  }
+  try {
+    await request.jwtVerify();
+  } catch (err) {
+    return reply.status(401).send({ error: 'Não autorizado.' });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Rotas com prefixo /api/v1
+// ---------------------------------------------------------------------------
+const API_PREFIX = '/api/v1';
+
+fastify.register(authRoutes, { prefix: API_PREFIX });
+fastify.register(usersRoutes, { prefix: API_PREFIX });
+fastify.register(incomesRoutes, { prefix: API_PREFIX });
+fastify.register(recurringExpensesRoutes, { prefix: API_PREFIX });
+fastify.register(oneTimeExpensesRoutes, { prefix: API_PREFIX });
+fastify.register(dashboardRoutes, { prefix: API_PREFIX });
+
+// ---------------------------------------------------------------------------
+// Health check
+// ---------------------------------------------------------------------------
+fastify.get('/health', async () => ({
+  status: 'ok',
+  timestamp: new Date().toISOString(),
+  version: '1.0.0',
+}));
+
+// ---------------------------------------------------------------------------
+// Handler de erros global
+// ---------------------------------------------------------------------------
+fastify.setErrorHandler((error, _request, reply) => {
+  fastify.log.error(error);
+  const statusCode = error.statusCode ?? 500;
+  reply.status(statusCode).send({
+    error: statusCode >= 500 ? 'Erro interno do servidor.' : error.message,
+    ...(process.env.NODE_ENV === 'development' && { stack: error.stack }),
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+try {
+  await fastify.listen({ port: PORT, host: HOST });
+  console.log(`🚀 YABA API rodando em http://${HOST}:${PORT}`);
+  console.log(`📖 Health check: http://${HOST}:${PORT}/health`);
+} catch (err) {
+  fastify.log.error(err);
+  process.exit(1);
+}
diff --git a/api/src/utils/tax-calculator.ts b/api/src/utils/tax-calculator.ts
new file mode 100644
index 0000000..36ffc7e
--- /dev/null
+++ b/api/src/utils/tax-calculator.ts
@@ -0,0 +1,111 @@
+/**
+ * Calculadora de impostos brasileiros (INSS + IRRF).
+ * Tabelas vigentes: 2025.
+ *
+ * IMPORTANTE: As alíquotas e faixas mudam anualmente por decreto.
+ * Verifique a legislação vigente a cada ano fiscal.
+ *
+ * Fonte: Portaria MPS / IN RFB 2.141/2023 e atualizações.
+ */
+
+// ---------------------------------------------------------------------------
+// INSS — Tabela Progressiva 2025
+// ---------------------------------------------------------------------------
+const INSS_TABLE = [
+  { upTo: 1_518.0, rate: 0.075 },
+  { upTo: 2_793.88, rate: 0.09 },
+  { upTo: 4_190.83, rate: 0.12 },
+  { upTo: 8_157.41, rate: 0.14 },
+] as const;
+
+const INSS_TETO = 908.86; // Valor máximo de desconto do INSS
+
+/**
+ * Calcula o desconto do INSS com a tabela progressiva.
+ * Cada faixa incide apenas sobre a parte do salário dentro dela.
+ */
+export function calcularINSS(salarioBruto: number): number {
+  if (salarioBruto <= 0) return 0;
+  if (salarioBruto > INSS_TABLE[INSS_TABLE.length - 1].upTo) return INSS_TETO;
+
+  let inss = 0;
+  let salarioRestante = salarioBruto;
+  let limiteAnterior = 0;
+
+  for (const faixa of INSS_TABLE) {
+    if (salarioRestante <= 0) break;
+
+    const baseNaFaixa = Math.min(salarioBruto, faixa.upTo) - limiteAnterior;
+    inss += baseNaFaixa * faixa.rate;
+
+    salarioRestante -= baseNaFaixa;
+    limiteAnterior = faixa.upTo;
+  }
+
+  return parseFloat(inss.toFixed(2));
+}
+
+// ---------------------------------------------------------------------------
+// IRRF — Tabela Progressiva 2025
+// ---------------------------------------------------------------------------
+interface FaixaIRRF {
+  upTo: number | null; // null = sem limite superior
+  rate: number;
+  deduction: number;
+}
+
+const IRRF_TABLE: FaixaIRRF[] = [
+  { upTo: 2_259.2, rate: 0, deduction: 0 },
+  { upTo: 2_826.65, rate: 0.075, deduction: 169.44 },
+  { upTo: 3_751.05, rate: 0.15, deduction: 381.44 },
+  { upTo: 4_664.68, rate: 0.225, deduction: 662.77 },
+  { upTo: null, rate: 0.275, deduction: 896.0 },
+];
+
+/**
+ * Calcula o desconto do IRRF.
+ * Base de cálculo: Salário Bruto − INSS (sem considerar dependentes).
+ */
+export function calcularIRRF(salarioBruto: number, inss: number): number {
+  const baseCalculo = salarioBruto - inss;
+  if (baseCalculo <= 0) return 0;
+
+  const faixa = IRRF_TABLE.find(
+    (f) => f.upTo === null || baseCalculo <= f.upTo,
+  )!;
+
+  const irrf = baseCalculo * faixa.rate - faixa.deduction;
+  return parseFloat(Math.max(0, irrf).toFixed(2));
+}
+
+// ---------------------------------------------------------------------------
+// Resultado consolidado
+// ---------------------------------------------------------------------------
+export interface ResultadoCalculo {
+  salarioBruto: number;
+  descontoINSS: number;
+  descontoIRRF: number;
+  totalDescontos: number;
+  salarioLiquidoCalculado: number;
+}
+
+/**
+ * Calcula o salário líquido completo a partir do salário bruto.
+ * Retorna um objeto com o detalhamento de cada desconto.
+ */
+export function calcularSalarioLiquido(salarioBruto: number): ResultadoCalculo {
+  const descontoINSS = calcularINSS(salarioBruto);
+  const descontoIRRF = calcularIRRF(salarioBruto, descontoINSS);
+  const totalDescontos = parseFloat((descontoINSS + descontoIRRF).toFixed(2));
+  const salarioLiquidoCalculado = parseFloat(
+    (salarioBruto - totalDescontos).toFixed(2),
+  );
+
+  return {
+    salarioBruto,
+    descontoINSS,
+    descontoIRRF,
+    totalDescontos,
+    salarioLiquidoCalculado,
+  };
+}