refactor(core): move app para src e padroniza estrutura

src/features/dashboard/categories/category-breakdown.ts

@@ -0,0 +1,121 @@
+import { calculatePercentageChange } from "@/shared/utils/math";
+import { safeToNumber as toNumber } from "@/shared/utils/number";
+
+export type DashboardCategoryBreakdownItem = {
+	categoryId: string;
+	categoryName: string;
+	categoryIcon: string | null;
+	currentAmount: number;
+	previousAmount: number;
+	percentageChange: number | null;
+	percentageOfTotal: number;
+	budgetAmount: number | null;
+	budgetUsedPercentage: number | null;
+};
+
+export type DashboardCategoryBreakdownData = {
+	categories: DashboardCategoryBreakdownItem[];
+	currentTotal: number;
+	previousTotal: number;
+};
+
+type CategoryBreakdownRow = {
+	categoryId: string;
+	categoryName: string;
+	categoryIcon: string | null;
+	period: string | null;
+	total: unknown;
+};
+
+type CategoryBudgetRow = {
+	categoriaId: string | null;
+	amount: unknown;
+};
+
+export function buildCategoryBreakdownData({
+	rows,
+	budgetRows,
+	period,
+}: {
+	rows: CategoryBreakdownRow[];
+	budgetRows: CategoryBudgetRow[];
+	period: string;
+}): DashboardCategoryBreakdownData {
+	const budgetMap = new Map<string, number>();
+	for (const row of budgetRows) {
+		if (row.categoriaId) {
+			budgetMap.set(row.categoriaId, toNumber(row.amount));
+		}
+	}
+
+	const categoryMap = new Map<
+		string,
+		{
+			name: string;
+			icon: string | null;
+			current: number;
+			previous: number;
+		}
+	>();
+
+	for (const row of rows) {
+		const entry = categoryMap.get(row.categoryId) ?? {
+			name: row.categoryName,
+			icon: row.categoryIcon,
+			current: 0,
+			previous: 0,
+		};
+
+		const amount = Math.abs(toNumber(row.total));
+		if (row.period === period) {
+			entry.current = amount;
+		} else {
+			entry.previous = amount;
+		}
+
+		categoryMap.set(row.categoryId, entry);
+	}
+
+	let currentTotal = 0;
+	let previousTotal = 0;
+	for (const entry of categoryMap.values()) {
+		currentTotal += entry.current;
+		previousTotal += entry.previous;
+	}
+
+	const categories: DashboardCategoryBreakdownItem[] = [];
+	for (const [categoryId, entry] of categoryMap) {
+		const percentageChange = calculatePercentageChange(
+			entry.current,
+			entry.previous,
+		);
+		const percentageOfTotal =
+			currentTotal > 0 ? (entry.current / currentTotal) * 100 : 0;
+
+		const budgetAmount = budgetMap.get(categoryId) ?? null;
+		const budgetUsedPercentage =
+			budgetAmount && budgetAmount > 0
+				? (entry.current / budgetAmount) * 100
+				: null;
+
+		categories.push({
+			categoryId,
+			categoryName: entry.name,
+			categoryIcon: entry.icon,
+			currentAmount: entry.current,
+			previousAmount: entry.previous,
+			percentageChange,
+			percentageOfTotal,
+			budgetAmount,
+			budgetUsedPercentage,
+		});
+	}
+
+	categories.sort((a, b) => b.currentAmount - a.currentAmount);
+
+	return {
+		categories,
+		currentTotal,
+		previousTotal,
+	};
+}

src/features/dashboard/categories/category-details-queries.ts

@@ -0,0 +1,136 @@
+import { and, desc, eq, isNull, ne, or, sql } from "drizzle-orm";
+import { categorias, contas, lancamentos, pagadores } from "@/db/schema";
+import { mapLancamentosData } from "@/features/transactions/page-helpers";
+import {
+	ACCOUNT_AUTO_INVOICE_NOTE_PREFIX,
+	INITIAL_BALANCE_NOTE,
+} from "@/shared/lib/accounts/constants";
+import type { CategoryType } from "@/shared/lib/categories/constants";
+import { db } from "@/shared/lib/db";
+import { PAGADOR_ROLE_ADMIN } from "@/shared/lib/payers/constants";
+import { calculatePercentageChange } from "@/shared/utils/math";
+import { safeToNumber as toNumber } from "@/shared/utils/number";
+import { getPreviousPeriod } from "@/shared/utils/period";
+
+type MappedLancamentos = ReturnType<typeof mapLancamentosData>;
+
+export type CategoryDetailData = {
+	category: {
+		id: string;
+		name: string;
+		icon: string | null;
+		type: CategoryType;
+	};
+	period: string;
+	previousPeriod: string;
+	currentTotal: number;
+	previousTotal: number;
+	percentageChange: number | null;
+	transactions: MappedLancamentos;
+};
+
+export async function fetchCategoryDetails(
+	userId: string,
+	categoryId: string,
+	period: string,
+): Promise<CategoryDetailData | null> {
+	const category = await db.query.categorias.findFirst({
+		where: and(eq(categorias.userId, userId), eq(categorias.id, categoryId)),
+	});
+
+	if (!category) {
+		return null;
+	}
+
+	const previousPeriod = getPreviousPeriod(period);
+	const transactionType = category.type === "receita" ? "Receita" : "Despesa";
+
+	const sanitizedNote = or(
+		isNull(lancamentos.note),
+		sql`${lancamentos.note} NOT LIKE ${`${ACCOUNT_AUTO_INVOICE_NOTE_PREFIX}%`}`,
+	);
+
+	const currentRows = await db.query.lancamentos.findMany({
+		where: and(
+			eq(lancamentos.userId, userId),
+			eq(lancamentos.categoriaId, categoryId),
+			eq(lancamentos.transactionType, transactionType),
+			eq(lancamentos.period, period),
+			sanitizedNote,
+		),
+		with: {
+			pagador: true,
+			conta: true,
+			cartao: true,
+			categoria: true,
+		},
+		orderBy: [desc(lancamentos.purchaseDate), desc(lancamentos.createdAt)],
+	});
+
+	const filteredRows = currentRows.filter((row) => {
+		// Filtrar apenas pagadores admin
+		if (row.pagador?.role !== PAGADOR_ROLE_ADMIN) return false;
+
+		// Excluir saldos iniciais se a conta tiver o flag ativo
+		if (
+			row.note === INITIAL_BALANCE_NOTE &&
+			row.conta?.excludeInitialBalanceFromIncome
+		) {
+			return false;
+		}
+
+		return true;
+	});
+
+	const transactions = mapLancamentosData(filteredRows);
+
+	const currentTotal = transactions.reduce(
+		(total, transaction) => total + Math.abs(toNumber(transaction.amount)),
+		0,
+	);
+
+	const [previousTotalRow] = await db
+		.select({
+			total: sql<number>`coalesce(sum(${lancamentos.amount}), 0)`,
+		})
+		.from(lancamentos)
+		.innerJoin(pagadores, eq(lancamentos.pagadorId, pagadores.id))
+		.leftJoin(contas, eq(lancamentos.contaId, contas.id))
+		.where(
+			and(
+				eq(lancamentos.userId, userId),
+				eq(lancamentos.categoriaId, categoryId),
+				eq(lancamentos.transactionType, transactionType),
+				eq(pagadores.role, PAGADOR_ROLE_ADMIN),
+				sanitizedNote,
+				eq(lancamentos.period, previousPeriod),
+				// Excluir saldos iniciais se a conta tiver o flag ativo
+				or(
+					ne(lancamentos.note, INITIAL_BALANCE_NOTE),
+					isNull(contas.excludeInitialBalanceFromIncome),
+					eq(contas.excludeInitialBalanceFromIncome, false),
+				),
+			),
+		);
+
+	const previousTotal = Math.abs(toNumber(previousTotalRow?.total ?? 0));
+	const percentageChange = calculatePercentageChange(
+		currentTotal,
+		previousTotal,
+	);
+
+	return {
+		category: {
+			id: category.id,
+			name: category.name,
+			icon: category.icon,
+			type: category.type as CategoryType,
+		},
+		period,
+		previousPeriod,
+		currentTotal,
+		previousTotal,
+		percentageChange,
+		transactions,
+	};
+}

src/features/dashboard/categories/category-history-queries.ts

@@ -0,0 +1,208 @@
+import { and, eq, inArray, isNull, or, sql } from "drizzle-orm";
+import { categorias, lancamentos, pagadores } from "@/db/schema";
+import { ACCOUNT_AUTO_INVOICE_NOTE_PREFIX } from "@/shared/lib/accounts/constants";
+import { db } from "@/shared/lib/db";
+import { PAGADOR_ROLE_ADMIN } from "@/shared/lib/payers/constants";
+import { CATEGORY_COLORS } from "@/shared/utils/category-colors";
+import { safeToNumber as toNumber } from "@/shared/utils/number";
+import {
+	addMonthsToPeriod,
+	buildPeriodWindow,
+	formatPeriodMonthShort,
+} from "@/shared/utils/period";
+
+export type CategoryOption = {
+	id: string;
+	name: string;
+	icon: string | null;
+	type: "receita" | "despesa";
+};
+
+export type CategoryHistoryItem = {
+	id: string;
+	name: string;
+	icon: string | null;
+	color: string;
+	data: Record<string, number>;
+};
+
+export type CategoryHistoryData = {
+	months: string[]; // ["NOV", "DEZ", "JAN", ...]
+	categories: CategoryHistoryItem[];
+	chartData: Array<{
+		month: string;
+		[categoryName: string]: number | string;
+	}>;
+	allCategories: CategoryOption[];
+};
+
+const CHART_COLORS = CATEGORY_COLORS;
+type MonthlyCategoryRow = {
+	categoryId: string;
+	categoryName: string;
+	categoryIcon: string | null;
+	period: string;
+	totalAmount: unknown;
+};
+
+type UniqueCategory = {
+	id: string;
+	name: string;
+	icon: string | null;
+};
+
+export async function fetchAllCategories(
+	userId: string,
+): Promise<CategoryOption[]> {
+	const result = await db
+		.select({
+			id: categorias.id,
+			name: categorias.name,
+			icon: categorias.icon,
+			type: categorias.type,
+		})
+		.from(categorias)
+		.where(eq(categorias.userId, userId))
+		.orderBy(categorias.type, categorias.name);
+
+	return result as CategoryOption[];
+}
+
+/**
+ * Fetches category expense/income history for all categories with transactions
+ * Widget will allow user to select up to 5 to display
+ */
+export async function fetchCategoryHistory(
+	userId: string,
+	currentPeriod: string,
+): Promise<CategoryHistoryData> {
+	// Generate last 8 months, current month, and next month (10 total)
+	const periods = buildPeriodWindow(addMonthsToPeriod(currentPeriod, 1), 10);
+	const monthLabels = periods.map((period) =>
+		formatPeriodMonthShort(period).toUpperCase(),
+	);
+
+	// Fetch all categories for the selector
+	const allCategories = await fetchAllCategories(userId);
+
+	// Fetch monthly data for ALL categories with transactions
+	const monthlyDataQuery = (await db
+		.select({
+			categoryId: categorias.id,
+			categoryName: categorias.name,
+			categoryIcon: categorias.icon,
+			period: lancamentos.period,
+			totalAmount: sql<string>`SUM(ABS(${lancamentos.amount}))`.as(
+				"total_amount",
+			),
+		})
+		.from(lancamentos)
+		.innerJoin(categorias, eq(lancamentos.categoriaId, categorias.id))
+		.innerJoin(pagadores, eq(lancamentos.pagadorId, pagadores.id))
+		.where(
+			and(
+				eq(lancamentos.userId, userId),
+				eq(categorias.userId, userId),
+				inArray(lancamentos.period, periods),
+				eq(pagadores.role, PAGADOR_ROLE_ADMIN),
+				or(
+					isNull(lancamentos.note),
+					sql`${
+						lancamentos.note
+					} NOT LIKE ${`${ACCOUNT_AUTO_INVOICE_NOTE_PREFIX}%`}`,
+				),
+			),
+		)
+		.groupBy(
+			categorias.id,
+			categorias.name,
+			categorias.icon,
+			lancamentos.period,
+		)) as MonthlyCategoryRow[];
+
+	if (monthlyDataQuery.length === 0) {
+		return {
+			months: monthLabels,
+			categories: [],
+			chartData: monthLabels.map((month) => ({ month })),
+			allCategories,
+		};
+	}
+
+	// Get unique categories from query results
+	const uniqueCategories: UniqueCategory[] = Array.from(
+		new Map<string, UniqueCategory>(
+			monthlyDataQuery.map((row) => [
+				row.categoryId,
+				{
+					id: row.categoryId,
+					name: row.categoryName,
+					icon: row.categoryIcon,
+				},
+			]),
+		).values(),
+	);
+
+	// Transform data into chart-ready format
+	const categoriesMap = new Map<
+		string,
+		{
+			id: string;
+			name: string;
+			icon: string | null;
+			color: string;
+			data: Record<string, number>;
+		}
+	>();
+
+	// Initialize ALL categories with transactions with all months set to 0
+	uniqueCategories.forEach((cat, index) => {
+		const monthData: Record<string, number> = {};
+		periods.forEach((_period, periodIndex) => {
+			monthData[monthLabels[periodIndex]] = 0;
+		});
+
+		categoriesMap.set(cat.id, {
+			id: cat.id,
+			name: cat.name,
+			icon: cat.icon,
+			color: CHART_COLORS[index % CHART_COLORS.length],
+			data: monthData,
+		});
+	});
+
+	// Fill in actual values from monthly data
+	monthlyDataQuery.forEach((row) => {
+		const category = categoriesMap.get(row.categoryId);
+		if (category) {
+			const periodIndex = periods.indexOf(row.period);
+			if (periodIndex !== -1) {
+				const monthLabel = monthLabels[periodIndex];
+				category.data[monthLabel] = toNumber(row.totalAmount);
+			}
+		}
+	});
+
+	// Convert to chart data format
+	const chartData: CategoryHistoryData["chartData"] = monthLabels.map(
+		(month) => {
+			const dataPoint: {
+				month: string;
+				[categoryName: string]: number | string;
+			} = { month };
+
+			categoriesMap.forEach((category) => {
+				dataPoint[category.name] = category.data[month];
+			});
+
+			return dataPoint;
+		},
+	);
+
+	return {
+		months: monthLabels,
+		categories: Array.from(categoriesMap.values()),
+		chartData,
+		allCategories,
+	};
+}

src/features/dashboard/categories/expenses-by-category-queries.ts

@@ -0,0 +1,71 @@
+import { and, eq, inArray, sql } from "drizzle-orm";
+import { categorias, lancamentos, orcamentos } from "@/db/schema";
+import {
+	buildCategoryBreakdownData,
+	type DashboardCategoryBreakdownData,
+	type DashboardCategoryBreakdownItem,
+} from "@/features/dashboard/categories/category-breakdown";
+import {
+	buildDashboardAdminFilters,
+	excludeAutoInvoiceEntries,
+} from "@/features/dashboard/lancamento-filters";
+import { db } from "@/shared/lib/db";
+import { getAdminPagadorId } from "@/shared/lib/payers/get-admin-id";
+import { getPreviousPeriod } from "@/shared/utils/period";
+
+export type CategoryExpenseItem = DashboardCategoryBreakdownItem;
+export type ExpensesByCategoryData = DashboardCategoryBreakdownData;
+
+export async function fetchExpensesByCategory(
+	userId: string,
+	period: string,
+): Promise<ExpensesByCategoryData> {
+	const previousPeriod = getPreviousPeriod(period);
+
+	const adminPagadorId = await getAdminPagadorId(userId);
+	if (!adminPagadorId) {
+		return { categories: [], currentTotal: 0, previousTotal: 0 };
+	}
+
+	// Single query: GROUP BY categoriaId + period for both current and previous periods
+	const [rows, budgetRows] = await Promise.all([
+		db
+			.select({
+				categoryId: categorias.id,
+				categoryName: categorias.name,
+				categoryIcon: categorias.icon,
+				period: lancamentos.period,
+				total: sql<number>`coalesce(sum(${lancamentos.amount}), 0)`,
+			})
+			.from(lancamentos)
+			.innerJoin(categorias, eq(lancamentos.categoriaId, categorias.id))
+			.where(
+				and(
+					...buildDashboardAdminFilters({ userId, adminPagadorId }),
+					inArray(lancamentos.period, [period, previousPeriod]),
+					eq(lancamentos.transactionType, "Despesa"),
+					eq(categorias.type, "despesa"),
+					excludeAutoInvoiceEntries(),
+				),
+			)
+			.groupBy(
+				categorias.id,
+				categorias.name,
+				categorias.icon,
+				lancamentos.period,
+			),
+		db
+			.select({
+				categoriaId: orcamentos.categoriaId,
+				amount: orcamentos.amount,
+			})
+			.from(orcamentos)
+			.where(and(eq(orcamentos.userId, userId), eq(orcamentos.period, period))),
+	]);
+
+	return buildCategoryBreakdownData({
+		rows,
+		budgetRows,
+		period,
+	});
+}

src/features/dashboard/categories/income-by-category-queries.ts

@@ -0,0 +1,74 @@
+import { and, eq, inArray, sql } from "drizzle-orm";
+import { categorias, contas, lancamentos, orcamentos } from "@/db/schema";
+import {
+	buildCategoryBreakdownData,
+	type DashboardCategoryBreakdownData,
+	type DashboardCategoryBreakdownItem,
+} from "@/features/dashboard/categories/category-breakdown";
+import {
+	buildDashboardAdminFilters,
+	excludeAutoInvoiceEntries,
+	excludeInitialBalanceWhenConfigured,
+} from "@/features/dashboard/lancamento-filters";
+import { db } from "@/shared/lib/db";
+import { getAdminPagadorId } from "@/shared/lib/payers/get-admin-id";
+import { getPreviousPeriod } from "@/shared/utils/period";
+
+export type CategoryIncomeItem = DashboardCategoryBreakdownItem;
+export type IncomeByCategoryData = DashboardCategoryBreakdownData;
+
+export async function fetchIncomeByCategory(
+	userId: string,
+	period: string,
+): Promise<IncomeByCategoryData> {
+	const previousPeriod = getPreviousPeriod(period);
+
+	const adminPagadorId = await getAdminPagadorId(userId);
+	if (!adminPagadorId) {
+		return { categories: [], currentTotal: 0, previousTotal: 0 };
+	}
+
+	// Single query: GROUP BY categoriaId + period for both current and previous periods
+	const [rows, budgetRows] = await Promise.all([
+		db
+			.select({
+				categoryId: categorias.id,
+				categoryName: categorias.name,
+				categoryIcon: categorias.icon,
+				period: lancamentos.period,
+				total: sql<number>`coalesce(sum(${lancamentos.amount}), 0)`,
+			})
+			.from(lancamentos)
+			.innerJoin(categorias, eq(lancamentos.categoriaId, categorias.id))
+			.leftJoin(contas, eq(lancamentos.contaId, contas.id))
+			.where(
+				and(
+					...buildDashboardAdminFilters({ userId, adminPagadorId }),
+					inArray(lancamentos.period, [period, previousPeriod]),
+					eq(lancamentos.transactionType, "Receita"),
+					eq(categorias.type, "receita"),
+					excludeAutoInvoiceEntries(),
+					excludeInitialBalanceWhenConfigured(),
+				),
+			)
+			.groupBy(
+				categorias.id,
+				categorias.name,
+				categorias.icon,
+				lancamentos.period,
+			),
+		db
+			.select({
+				categoriaId: orcamentos.categoriaId,
+				amount: orcamentos.amount,
+			})
+			.from(orcamentos)
+			.where(and(eq(orcamentos.userId, userId), eq(orcamentos.period, period))),
+	]);
+
+	return buildCategoryBreakdownData({
+		rows,
+		budgetRows,
+		period,
+	});
+}