feat(expenses): implement responsive dialog for expense management and create expense provider

- Added ResponsiveDialog component for handling responsive dialogs in the UI.
- Created ExpensesProvider to manage state and API interactions for expenses.
- Developed ExpensesTabContent to display expenses with filtering options and dialogs for new and pay expense actions.
- Implemented ExpensesTable for rendering expense data in a tabular format with actions.
- Added dialogs for creating new expenses and paying existing ones with form validation.
- Introduced PeriodicExpenseForm for managing periodic expenses with month selection.
- Created PeriodicExpensesTabContent to manage and display periodic expenses with create/edit functionality.
- Added GenerateCurrentMonthDialog for confirming monthly expense generation.
- Implemented PeriodicExpensesTable for displaying periodic expenses with edit and delete actions.

apps/backend/src/modules/expenses/expense.job.ts

@@ -0,0 +1,16 @@
+import cron from "node-cron";
+import { logger } from "../../lib/logger";
+import { generateExpensesForCurrentMonth } from "./expenses.service";
+
+export function startExpenseJob(): void {
+  cron.schedule("0 1 1 * *", async () => {
+    logger.info("Generating monthly expenses...");
+    try {
+      const results = await generateExpensesForCurrentMonth();
+      logger.info({ results }, "Monthly expenses generated");
+    } catch (err) {
+      logger.error({ err }, "Failed to generate monthly expenses");
+    }
+  });
+  logger.info("Expense cron scheduled: 0 1 1 * *");
+}

apps/backend/src/modules/expenses/expenses.routes.ts

@@ -0,0 +1,23 @@
+import { Hono } from "hono";
+import { createPeriodicExpenseHandler } from "./handlers/createPeriodicExpense";
+import { listPeriodicExpensesHandler } from "./handlers/listPeriodicExpenses";
+import { updatePeriodicExpenseHandler } from "./handlers/updatePeriodicExpense";
+import { softDeletePeriodicExpenseHandler } from "./handlers/softDeletePeriodicExpense";
+import { generateMonthlyExpenseHandler } from "./handlers/generateMonthlyExpense";
+import { listExpensesHandler } from "./handlers/listExpenses";
+import { createNonPeriodicExpenseHandler } from "./handlers/createNonPeriodicExpense";
+import { payExpenseHandler } from "./handlers/payExpense";
+
+const app = new Hono();
+
+app.get("/periodic-expenses", listPeriodicExpensesHandler);
+app.post("/periodic-expenses", createPeriodicExpenseHandler);
+app.put("/periodic-expenses/:id", updatePeriodicExpenseHandler);
+app.delete("/periodic-expenses/:id", softDeletePeriodicExpenseHandler);
+app.post("/periodic-expenses/:id/generate-month", generateMonthlyExpenseHandler);
+
+app.get("/expenses", listExpensesHandler);
+app.post("/expenses", createNonPeriodicExpenseHandler);
+app.put("/expenses/:id/pay", payExpenseHandler);
+
+export default app;

apps/backend/src/modules/expenses/expenses.service.ts

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { prisma } from "../../lib/prisma";
+import { PaymentStatus } from "../../generated/prisma/client";
+
+export const createPeriodicExpenseSchema = z.object({
+  description: z.string().min(1).max(50),
+  defaultDueDay: z.number().int().min(1).max(31),
+  defaultAmount: z.number().positive(),
+  periods: z.array(z.number().int().min(1).max(12)).min(1),
+});
+
+export const updatePeriodicExpenseSchema = createPeriodicExpenseSchema;
+
+export const createNonPeriodicExpenseSchema = z.object({
+  description: z.string().min(1).max(50),
+  amount: z.number().positive(),
+  dueDate: z.string().datetime(),
+});
+
+export const payExpenseSchema = z.object({
+  amountPayed: z.number().positive(),
+  paymentDate: z.string().datetime().optional(),
+});
+
+function lastDayOfMonth(year: number, month: number): number {
+  return new Date(year, month, 0).getDate();
+}
+
+export function buildDueDate(year: number, month: number, dueDay: number): Date {
+  const clampedDay = Math.min(dueDay, lastDayOfMonth(year, month));
+  return new Date(Date.UTC(year, month - 1, clampedDay, 0, 0, 0, 0));
+}
+
+export function getCurrentYearMonthUTC(): { year: number; month: number } {
+  const now = new Date();
+  return { year: now.getUTCFullYear(), month: now.getUTCMonth() + 1 };
+}
+
+export async function listPeriodicExpenses() {
+  return prisma.periodicExpense.findMany({
+    where: { isDeleted: false },
+    orderBy: { createdAt: "desc" },
+  });
+}
+
+export async function createPeriodicExpense(data: z.infer<typeof createPeriodicExpenseSchema>) {
+  const result = await prisma.periodicExpense.create({ data });
+  const { year, month } = getCurrentYearMonthUTC();
+  const currentMonthApplicable = data.periods.includes(month);
+  return { ...result, currentMonthApplicable };
+}
+
+export async function updatePeriodicExpense(id: number, data: z.infer<typeof updatePeriodicExpenseSchema>) {
+  return prisma.periodicExpense.update({ where: { id }, data });
+}
+
+export async function softDeletePeriodicExpense(id: number) {
+  return prisma.periodicExpense.update({
+    where: { id },
+    data: { isDeleted: true },
+  });
+}
+
+export async function generateMonthlyExpense(id: number) {
+  const periodic = await prisma.periodicExpense.findUniqueOrThrow({ where: { id } });
+  const { year, month } = getCurrentYearMonthUTC();
+
+  const existing = await prisma.expense.findFirst({
+    where: { periodicExpenseId: id, year, month },
+  });
+  if (existing) return existing;
+
+  const dueDate = buildDueDate(year, month, periodic.defaultDueDay);
+  return prisma.expense.create({
+    data: {
+      description: periodic.description,
+      periodicExpenseId: id,
+      year,
+      month,
+      amount: periodic.defaultAmount,
+      dueDate,
+      status: PaymentStatus.PENDING,
+    },
+  });
+}
+
+export async function listExpenses(status?: string) {
+  const where: Record<string, unknown> = {};
+  if (status === "PENDING" || status === "PAYED") {
+    where.status = status;
+  }
+  return prisma.expense.findMany({
+    where,
+    include: { periodicExpense: true },
+    orderBy: { dueDate: "asc" },
+  });
+}
+
+export async function createNonPeriodicExpense(data: z.infer<typeof createNonPeriodicExpenseSchema>) {
+  const dueDate = new Date(data.dueDate);
+  const year = dueDate.getUTCFullYear();
+  const month = dueDate.getUTCMonth() + 1;
+  return prisma.expense.create({
+    data: {
+      description: data.description,
+      amount: data.amount,
+      amountPayed: data.amount,
+      dueDate,
+      paymentDate: dueDate,
+      year,
+      month,
+      status: PaymentStatus.PAYED,
+    },
+  });
+}
+
+export async function payExpense(id: number, data: z.infer<typeof payExpenseSchema>) {
+  const paymentDate = data.paymentDate ? new Date(data.paymentDate) : new Date();
+  return prisma.expense.update({
+    where: { id },
+    data: {
+      status: PaymentStatus.PAYED,
+      amountPayed: data.amountPayed,
+      paymentDate,
+    },
+  });
+}
+
+export async function generateExpensesForCurrentMonth() {
+  const { year, month } = getCurrentYearMonthUTC();
+
+  const periodics = await prisma.periodicExpense.findMany({
+    where: { isDeleted: false, periods: { has: month } },
+  });
+
+  const results: Array<{ id: number; status: string }> = [];
+  for (const periodic of periodics) {
+    const existing = await prisma.expense.findFirst({
+      where: { periodicExpenseId: periodic.id, year, month },
+    });
+    if (existing) {
+      results.push({ id: periodic.id, status: "already_exists" });
+      continue;
+    }
+    const dueDate = buildDueDate(year, month, periodic.defaultDueDay);
+    await prisma.expense.create({
+      data: {
+        description: periodic.description,
+        periodicExpenseId: periodic.id,
+        year,
+        month,
+        amount: periodic.defaultAmount,
+        dueDate,
+        status: PaymentStatus.PENDING,
+      },
+    });
+    results.push({ id: periodic.id, status: "created" });
+  }
+  return results;
+}

apps/backend/src/modules/expenses/handlers/createNonPeriodicExpense.ts

@@ -0,0 +1,9 @@
+import type { Context } from "hono";
+import { createNonPeriodicExpense, createNonPeriodicExpenseSchema } from "../expenses.service";
+
+export async function createNonPeriodicExpenseHandler(c: Context) {
+  const body = await c.req.json();
+  const parsed = createNonPeriodicExpenseSchema.parse(body);
+  const result = await createNonPeriodicExpense(parsed);
+  return c.json(result, 201);
+}

apps/backend/src/modules/expenses/handlers/createPeriodicExpense.ts

@@ -0,0 +1,9 @@
+import type { Context } from "hono";
+import { createPeriodicExpense, createPeriodicExpenseSchema } from "../expenses.service";
+
+export async function createPeriodicExpenseHandler(c: Context) {
+  const body = await c.req.json();
+  const parsed = createPeriodicExpenseSchema.parse(body);
+  const result = await createPeriodicExpense(parsed);
+  return c.json(result, 201);
+}

apps/backend/src/modules/expenses/handlers/generateMonthlyExpense.ts

@@ -0,0 +1,8 @@
+import type { Context } from "hono";
+import { generateMonthlyExpense } from "../expenses.service";
+
+export async function generateMonthlyExpenseHandler(c: Context) {
+  const id = Number(c.req.param("id"));
+  const result = await generateMonthlyExpense(id);
+  return c.json(result);
+}

apps/backend/src/modules/expenses/handlers/listExpenses.ts

@@ -0,0 +1,8 @@
+import type { Context } from "hono";
+import { listExpenses } from "../expenses.service";
+
+export async function listExpensesHandler(c: Context) {
+  const status = c.req.query("status");
+  const expenses = await listExpenses(status);
+  return c.json(expenses);
+}

apps/backend/src/modules/expenses/handlers/listPeriodicExpenses.ts

@@ -0,0 +1,7 @@
+import type { Context } from "hono";
+import { listPeriodicExpenses } from "../expenses.service";
+
+export async function listPeriodicExpensesHandler(c: Context) {
+  const expenses = await listPeriodicExpenses();
+  return c.json(expenses);
+}

apps/backend/src/modules/expenses/handlers/payExpense.ts

@@ -0,0 +1,10 @@
+import type { Context } from "hono";
+import { payExpense, payExpenseSchema } from "../expenses.service";
+
+export async function payExpenseHandler(c: Context) {
+  const id = Number(c.req.param("id"));
+  const body = await c.req.json();
+  const parsed = payExpenseSchema.parse(body);
+  const result = await payExpense(id, parsed);
+  return c.json(result);
+}

apps/backend/src/modules/expenses/handlers/softDeletePeriodicExpense.ts

@@ -0,0 +1,8 @@
+import type { Context } from "hono";
+import { softDeletePeriodicExpense } from "../expenses.service";
+
+export async function softDeletePeriodicExpenseHandler(c: Context) {
+  const id = Number(c.req.param("id"));
+  await softDeletePeriodicExpense(id);
+  return c.json({ success: true });
+}

apps/backend/src/modules/expenses/handlers/updatePeriodicExpense.ts

@@ -0,0 +1,10 @@
+import type { Context } from "hono";
+import { updatePeriodicExpense, updatePeriodicExpenseSchema } from "../expenses.service";
+
+export async function updatePeriodicExpenseHandler(c: Context) {
+  const id = Number(c.req.param("id"));
+  const body = await c.req.json();
+  const parsed = updatePeriodicExpenseSchema.parse(body);
+  const result = await updatePeriodicExpense(id, parsed);
+  return c.json(result);
+}