feat(#37): módulo de cartão de crédito com faturas mensais

- Migration 011: closing_day/due_day em accounts + tabela credit_bills
- CreditBillService: cria/atualiza fatura corrente on-demand no GET /accounts
- Widget FATURA ATUAL no dashboard com total e botão PAGAR
- AccountsView: campos closing_day/due_day para contas credit + painel fatura
- Dashboard: current_bills lista faturas não pagas de todos os cartões

Co-Authored-By: Claude Sonnet 4.6 <[email protected]>

apps/api/cmd/server/main.go

@@ -71,11 +71,14 @@ func main() {
 
 	accountRepo := repository.NewAccountRepository(pool)
 	cdiSvc := service.NewCDIYieldService(accountRepo, manualTxRepo)
-	accountSvc := service.NewAccountService(accountRepo, cdiSvc)
+	creditBillRepo := repository.NewCreditBillRepository(pool)
+	creditBillSvc := service.NewCreditBillService(creditBillRepo, accountRepo)
+	accountSvc := service.NewAccountService(accountRepo, cdiSvc, creditBillSvc)
 	accountHandler := handler.NewAccountHandler(accountSvc)
+	creditBillHandler := handler.NewCreditBillHandler(creditBillSvc)
 
 	dashboardRepo := repository.NewDashboardRepository(pool)
-	dashboardSvc := service.NewDashboardService(dashboardRepo, recurringSvc, accountRepo)
+	dashboardSvc := service.NewDashboardService(dashboardRepo, recurringSvc, accountRepo, creditBillSvc)
 	dashboardHandler := handler.NewDashboardHandler(dashboardSvc)
 
 	r.Get("/health", handler.Health)
@@ -113,6 +116,10 @@ func main() {
 		r.Post("/accounts", accountHandler.Create)
 		r.Put("/accounts/{id}", accountHandler.Update)
 		r.Delete("/accounts/{id}", accountHandler.Delete)
+		r.Get("/accounts/{id}/bills", creditBillHandler.ListByAccount)
+		r.Get("/accounts/{id}/bills/current", creditBillHandler.GetCurrent)
+		r.Post("/accounts/{id}/bills/ensure", creditBillHandler.EnsureCurrent)
+		r.Post("/bills/{id}/pay", creditBillHandler.MarkPaid)
 
 		r.Get("/dashboard", dashboardHandler.Get)
 

apps/api/internal/handler/credit_bill.go

@@ -0,0 +1,86 @@
+package handler
+
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+
+	"github.com/go-chi/chi/v5"
+
+	"financeiro-carvalho/internal/service"
+)
+
+type CreditBillHandler struct {
+	svc *service.CreditBillService
+}
+
+func NewCreditBillHandler(svc *service.CreditBillService) *CreditBillHandler {
+	return &CreditBillHandler{svc: svc}
+}
+
+func (h *CreditBillHandler) ListByAccount(w http.ResponseWriter, r *http.Request) {
+	id, err := strconv.Atoi(chi.URLParam(r, "id"))
+	if err != nil {
+		respondError(w, http.StatusBadRequest, "invalid id")
+		return
+	}
+	bills, err := h.svc.ListByAccount(r.Context(), id)
+	if err != nil {
+		respondError(w, http.StatusInternalServerError, "failed to list bills")
+		return
+	}
+	respondJSON(w, http.StatusOK, bills)
+}
+
+func (h *CreditBillHandler) GetCurrent(w http.ResponseWriter, r *http.Request) {
+	id, err := strconv.Atoi(chi.URLParam(r, "id"))
+	if err != nil {
+		respondError(w, http.StatusBadRequest, "invalid id")
+		return
+	}
+	bill, err := h.svc.GetCurrent(r.Context(), id)
+	if err != nil {
+		respondError(w, http.StatusInternalServerError, "failed to get current bill")
+		return
+	}
+	if bill == nil {
+		respondJSON(w, http.StatusOK, nil)
+		return
+	}
+	respondJSON(w, http.StatusOK, bill)
+}
+
+func (h *CreditBillHandler) EnsureCurrent(w http.ResponseWriter, r *http.Request) {
+	id, err := strconv.Atoi(chi.URLParam(r, "id"))
+	if err != nil {
+		respondError(w, http.StatusBadRequest, "invalid id")
+		return
+	}
+	var body struct {
+		ClosingDay int `json:"closing_day"`
+		DueDay     int `json:"due_day"`
+	}
+	_ = json.NewDecoder(r.Body).Decode(&body)
+	if err := h.svc.EnsureCurrentBill(r.Context(), id, body.ClosingDay, body.DueDay); err != nil {
+		respondError(w, http.StatusInternalServerError, "failed to ensure bill")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}
+
+func (h *CreditBillHandler) MarkPaid(w http.ResponseWriter, r *http.Request) {
+	id, err := strconv.Atoi(chi.URLParam(r, "id"))
+	if err != nil {
+		respondError(w, http.StatusBadRequest, "invalid id")
+		return
+	}
+	var body struct {
+		PaymentAccountID *int `json:"payment_account_id"`
+	}
+	_ = json.NewDecoder(r.Body).Decode(&body)
+	if err := h.svc.MarkPaid(r.Context(), id, body.PaymentAccountID); err != nil {
+		respondError(w, http.StatusInternalServerError, "failed to mark bill paid")
+		return
+	}
+	w.WriteHeader(http.StatusNoContent)
+}

apps/api/internal/migration/sql/011_credit_bills.sql

@@ -0,0 +1,19 @@
+-- Credit card billing period configuration per account
+ALTER TABLE accounts
+    ADD COLUMN IF NOT EXISTS closing_day   INTEGER CHECK (closing_day BETWEEN 1 AND 28),
+    ADD COLUMN IF NOT EXISTS due_day       INTEGER CHECK (due_day BETWEEN 1 AND 28);
+
+-- Materialized bill metadata (calculated from transactions)
+-- One row per (account, billing period start date)
+CREATE TABLE IF NOT EXISTS credit_bills (
+    id              SERIAL PRIMARY KEY,
+    account_id      INTEGER NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
+    period_start    DATE    NOT NULL,
+    period_end      DATE    NOT NULL,
+    due_date        DATE    NOT NULL,
+    paid            BOOLEAN NOT NULL DEFAULT FALSE,
+    paid_at         TIMESTAMP WITH TIME ZONE,
+    payment_account_id INTEGER REFERENCES accounts(id) ON DELETE SET NULL,
+    created_at      TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+    UNIQUE(account_id, period_start)
+);

apps/api/internal/model/account.go

@@ -8,6 +8,9 @@ type Account struct {
 	Balance        float64 `json:"balance"`
 	YieldType      string  `json:"yield_type"` // "none" | "cdi" | "variable"
 	LastYieldDate  *string `json:"last_yield_date,omitempty"`
+	ClosingDay     *int    `json:"closing_day,omitempty"`
+	DueDay         *int    `json:"due_day,omitempty"`
+	CurrentBill    *CreditBill `json:"current_bill,omitempty"`
 	CreatedAt      string  `json:"created_at"`
 	UpdatedAt      string  `json:"updated_at"`
 }
@@ -17,4 +20,6 @@ type AccountInput struct {
 	Type           string  `json:"type"`
 	InitialBalance float64 `json:"initial_balance"`
 	YieldType      string  `json:"yield_type"` // "none" | "cdi" | "variable"
+	ClosingDay     *int    `json:"closing_day,omitempty"`
+	DueDay         *int    `json:"due_day,omitempty"`
 }

apps/api/internal/model/credit_bill.go

@@ -0,0 +1,22 @@
+package model
+
+type CreditBill struct {
+	ID                int     `json:"id"`
+	AccountID         int     `json:"account_id"`
+	AccountName       string  `json:"account_name"`
+	PeriodStart       string  `json:"period_start"`
+	PeriodEnd         string  `json:"period_end"`
+	DueDate           string  `json:"due_date"`
+	Total             float64 `json:"total"`
+	Paid              bool    `json:"paid"`
+	PaidAt            *string `json:"paid_at,omitempty"`
+	PaymentAccountID  *int    `json:"payment_account_id,omitempty"`
+}
+
+type CreditBillInput struct {
+	AccountID         int    `json:"account_id"`
+	PeriodStart       string `json:"period_start"`
+	PeriodEnd         string `json:"period_end"`
+	DueDate           string `json:"due_date"`
+	PaymentAccountID  *int   `json:"payment_account_id,omitempty"`
+}

apps/api/internal/model/dashboard.go

@@ -34,4 +34,5 @@ type DashboardData struct {
 	RecentTransactions      []RecentTransaction `json:"recent_transactions"`
 	PendingRecurring        int                 `json:"pending_recurring"`
 	PendingIncomeRecurrings []PendingIncome     `json:"pending_income_recurrings"`
+	CurrentBills            []CreditBill        `json:"current_bills"`
 }

apps/api/internal/repository/account.go

@@ -32,6 +32,7 @@ func (r *AccountRepository) List(ctx context.Context) ([]model.Account, error) {
 		SELECT
 			a.id, a.name, a.type, a.initial_balance,
 			a.yield_type, a.last_yield_date::text,
+			a.closing_day, a.due_day,
 			a.created_at::text, a.updated_at::text,
 			a.initial_balance
 				+ COALESCE(SUM(CASE WHEN t.type = 'income'  THEN t.amount ELSE 0 END), 0)
@@ -50,7 +51,7 @@ func (r *AccountRepository) List(ctx context.Context) ([]model.Account, error) {
 	var out []model.Account
 	for rows.Next() {
 		var a model.Account
-		if err := rows.Scan(&a.ID, &a.Name, &a.Type, &a.InitialBalance, &a.YieldType, &a.LastYieldDate, &a.CreatedAt, &a.UpdatedAt, &a.Balance); err != nil {
+		if err := rows.Scan(&a.ID, &a.Name, &a.Type, &a.InitialBalance, &a.YieldType, &a.LastYieldDate, &a.ClosingDay, &a.DueDay, &a.CreatedAt, &a.UpdatedAt, &a.Balance); err != nil {
 			return nil, err
 		}
 		out = append(out, a)
@@ -64,6 +65,7 @@ func (r *AccountRepository) GetByID(ctx context.Context, id int) (*model.Account
 		SELECT
 			a.id, a.name, a.type, a.initial_balance,
 			a.yield_type, a.last_yield_date::text,
+			a.closing_day, a.due_day,
 			a.created_at::text, a.updated_at::text,
 			a.initial_balance
 				+ COALESCE(SUM(CASE WHEN t.type = 'income'  THEN t.amount ELSE 0 END), 0)
@@ -73,7 +75,7 @@ func (r *AccountRepository) GetByID(ctx context.Context, id int) (*model.Account
 		LEFT JOIN transactions t ON t.account_id = a.id
 		WHERE a.id = $1
 		GROUP BY a.id
-	`, id).Scan(&a.ID, &a.Name, &a.Type, &a.InitialBalance, &a.YieldType, &a.LastYieldDate, &a.CreatedAt, &a.UpdatedAt, &a.Balance)
+	`, id).Scan(&a.ID, &a.Name, &a.Type, &a.InitialBalance, &a.YieldType, &a.LastYieldDate, &a.ClosingDay, &a.DueDay, &a.CreatedAt, &a.UpdatedAt, &a.Balance)
 	if err != nil {
 		return nil, err
 	}
@@ -87,11 +89,11 @@ func (r *AccountRepository) Create(ctx context.Context, in model.AccountInput) (
 	}
 	var a model.Account
 	err := r.pool.QueryRow(ctx, `
-		INSERT INTO accounts (name, type, initial_balance, yield_type)
-		VALUES ($1, $2, $3, $4)
-		RETURNING id, name, type, initial_balance, yield_type, last_yield_date::text, created_at::text, updated_at::text
-	`, in.Name, in.Type, in.InitialBalance, yt).
-		Scan(&a.ID, &a.Name, &a.Type, &a.InitialBalance, &a.YieldType, &a.LastYieldDate, &a.CreatedAt, &a.UpdatedAt)
+		INSERT INTO accounts (name, type, initial_balance, yield_type, closing_day, due_day)
+		VALUES ($1, $2, $3, $4, $5, $6)
+		RETURNING id, name, type, initial_balance, yield_type, last_yield_date::text, closing_day, due_day, created_at::text, updated_at::text
+	`, in.Name, in.Type, in.InitialBalance, yt, in.ClosingDay, in.DueDay).
+		Scan(&a.ID, &a.Name, &a.Type, &a.InitialBalance, &a.YieldType, &a.LastYieldDate, &a.ClosingDay, &a.DueDay, &a.CreatedAt, &a.UpdatedAt)
 	if err != nil {
 		return nil, err
 	}
@@ -105,12 +107,12 @@ func (r *AccountRepository) Update(ctx context.Context, id int, in model.Account
 		yt = "none"
 	}
 	row := r.pool.QueryRow(ctx, `
-		UPDATE accounts SET name=$1, type=$2, initial_balance=$3, yield_type=$4, updated_at=NOW()
-		WHERE id=$5
-		RETURNING id, name, type, initial_balance, yield_type, last_yield_date::text, created_at::text, updated_at::text
-	`, in.Name, in.Type, in.InitialBalance, yt, id)
+		UPDATE accounts SET name=$1, type=$2, initial_balance=$3, yield_type=$4, closing_day=$5, due_day=$6, updated_at=NOW()
+		WHERE id=$7
+		RETURNING id, name, type, initial_balance, yield_type, last_yield_date::text, closing_day, due_day, created_at::text, updated_at::text
+	`, in.Name, in.Type, in.InitialBalance, yt, in.ClosingDay, in.DueDay, id)
 	var a model.Account
-	if err := row.Scan(&a.ID, &a.Name, &a.Type, &a.InitialBalance, &a.YieldType, &a.LastYieldDate, &a.CreatedAt, &a.UpdatedAt); err != nil {
+	if err := row.Scan(&a.ID, &a.Name, &a.Type, &a.InitialBalance, &a.YieldType, &a.LastYieldDate, &a.ClosingDay, &a.DueDay, &a.CreatedAt, &a.UpdatedAt); err != nil {
 		return nil, err
 	}
 	full, err := r.GetByID(ctx, a.ID)

apps/api/internal/repository/credit_bill.go

@@ -0,0 +1,103 @@
+package repository
+
+import (
+	"context"
+	"errors"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"financeiro-carvalho/internal/model"
+)
+
+type CreditBillRepository interface {
+	ListByAccount(ctx context.Context, accountID int) ([]model.CreditBill, error)
+	GetCurrent(ctx context.Context, accountID int) (*model.CreditBill, error)
+	Upsert(ctx context.Context, in model.CreditBillInput) (*model.CreditBill, error)
+	MarkPaid(ctx context.Context, id int, paymentAccountID *int) error
+}
+
+type creditBillRepo struct{ db *pgxpool.Pool }
+
+func NewCreditBillRepository(db *pgxpool.Pool) CreditBillRepository {
+	return &creditBillRepo{db: db}
+}
+
+func (r *creditBillRepo) ListByAccount(ctx context.Context, accountID int) ([]model.CreditBill, error) {
+	rows, err := r.db.Query(ctx, `
+		SELECT
+			cb.id, cb.account_id, a.name,
+			cb.period_start::text, cb.period_end::text, cb.due_date::text,
+			COALESCE(SUM(t.amount) FILTER (WHERE t.type = 'expense'), 0) AS total,
+			cb.paid, cb.paid_at::text, cb.payment_account_id
+		FROM credit_bills cb
+		JOIN accounts a ON a.id = cb.account_id
+		LEFT JOIN transactions t ON t.account_id = cb.account_id
+			AND t.date >= cb.period_start AND t.date <= cb.period_end
+			AND t.type = 'expense'
+		WHERE cb.account_id = $1
+		GROUP BY cb.id, a.name
+		ORDER BY cb.period_start DESC
+	`, accountID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []model.CreditBill
+	for rows.Next() {
+		var b model.CreditBill
+		if err := rows.Scan(&b.ID, &b.AccountID, &b.AccountName, &b.PeriodStart, &b.PeriodEnd, &b.DueDate, &b.Total, &b.Paid, &b.PaidAt, &b.PaymentAccountID); err != nil {
+			return nil, err
+		}
+		out = append(out, b)
+	}
+	return out, rows.Err()
+}
+
+func (r *creditBillRepo) GetCurrent(ctx context.Context, accountID int) (*model.CreditBill, error) {
+	var b model.CreditBill
+	err := r.db.QueryRow(ctx, `
+		SELECT
+			cb.id, cb.account_id, a.name,
+			cb.period_start::text, cb.period_end::text, cb.due_date::text,
+			COALESCE(SUM(t.amount) FILTER (WHERE t.type = 'expense'), 0) AS total,
+			cb.paid, cb.paid_at::text, cb.payment_account_id
+		FROM credit_bills cb
+		JOIN accounts a ON a.id = cb.account_id
+		LEFT JOIN transactions t ON t.account_id = cb.account_id
+			AND t.date >= cb.period_start AND t.date <= cb.period_end
+			AND t.type = 'expense'
+		WHERE cb.account_id = $1 AND cb.paid = FALSE
+		GROUP BY cb.id, a.name
+		ORDER BY cb.period_start DESC
+		LIMIT 1
+	`, accountID).Scan(&b.ID, &b.AccountID, &b.AccountName, &b.PeriodStart, &b.PeriodEnd, &b.DueDate, &b.Total, &b.Paid, &b.PaidAt, &b.PaymentAccountID)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return nil, nil
+	}
+	return &b, err
+}
+
+func (r *creditBillRepo) Upsert(ctx context.Context, in model.CreditBillInput) (*model.CreditBill, error) {
+	var b model.CreditBill
+	err := r.db.QueryRow(ctx, `
+		INSERT INTO credit_bills (account_id, period_start, period_end, due_date, payment_account_id)
+		VALUES ($1, $2, $3, $4, $5)
+		ON CONFLICT (account_id, period_start) DO UPDATE
+			SET period_end = EXCLUDED.period_end,
+			    due_date   = EXCLUDED.due_date,
+			    payment_account_id = EXCLUDED.payment_account_id
+		RETURNING id, account_id, period_start::text, period_end::text, due_date::text, paid, paid_at::text, payment_account_id
+	`, in.AccountID, in.PeriodStart, in.PeriodEnd, in.DueDate, in.PaymentAccountID).
+		Scan(&b.ID, &b.AccountID, &b.PeriodStart, &b.PeriodEnd, &b.DueDate, &b.Paid, &b.PaidAt, &b.PaymentAccountID)
+	return &b, err
+}
+
+func (r *creditBillRepo) MarkPaid(ctx context.Context, id int, paymentAccountID *int) error {
+	_, err := r.db.Exec(ctx, `
+		UPDATE credit_bills
+		SET paid = TRUE, paid_at = NOW(), payment_account_id = $2
+		WHERE id = $1
+	`, id, paymentAccountID)
+	return err
+}

apps/api/internal/service/account.go

@@ -27,12 +27,13 @@ type AccountRepo interface {
 }
 
 type AccountService struct {
-	repo    repository.AccountRepoWithYield
-	cdiSvc  *CDIYieldService
+	repo        repository.AccountRepoWithYield
+	cdiSvc      *CDIYieldService
+	billSvc     *CreditBillService
 }
 
-func NewAccountService(repo repository.AccountRepoWithYield, cdiSvc *CDIYieldService) *AccountService {
-	return &AccountService{repo: repo, cdiSvc: cdiSvc}
+func NewAccountService(repo repository.AccountRepoWithYield, cdiSvc *CDIYieldService, billSvc *CreditBillService) *AccountService {
+	return &AccountService{repo: repo, cdiSvc: cdiSvc, billSvc: billSvc}
 }
 
 func (s *AccountService) validate(in model.AccountInput) error {
@@ -45,22 +46,44 @@ func (s *AccountService) validate(in model.AccountInput) error {
 	return nil
 }
 
-// List returns accounts, applying CDI yield on-demand for cdi-type accounts.
+// List returns accounts, applying CDI yield on-demand and attaching current bill for credit accounts.
 func (s *AccountService) List(ctx context.Context) ([]model.Account, error) {
 	accounts, err := s.repo.List(ctx)
 	if err != nil {
 		return nil, err
 	}
 
+	yieldApplied := false
 	for i := range accounts {
 		if accounts[i].YieldType == "cdi" {
-			// Apply CDI yield — errors are non-fatal (BCB API may be unavailable)
 			_ = s.cdiSvc.ApplyYield(ctx, &accounts[i])
+			yieldApplied = true
 		}
 	}
 
-	// Re-fetch after yield transactions may have been created to get updated balances
-	return s.repo.List(ctx)
+	if yieldApplied {
+		accounts, err = s.repo.List(ctx)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	for i := range accounts {
+		if accounts[i].Type == "credit" {
+			closing, due := 1, 10
+			if accounts[i].ClosingDay != nil {
+				closing = *accounts[i].ClosingDay
+			}
+			if accounts[i].DueDay != nil {
+				due = *accounts[i].DueDay
+			}
+			_ = s.billSvc.EnsureCurrentBill(ctx, accounts[i].ID, closing, due)
+			bill, _ := s.billSvc.GetCurrent(ctx, accounts[i].ID)
+			accounts[i].CurrentBill = bill
+		}
+	}
+
+	return accounts, nil
 }
 
 func (s *AccountService) Create(ctx context.Context, in model.AccountInput) (*model.Account, error) {

apps/api/internal/service/account_test.go

@@ -41,10 +41,24 @@ func (m *mockAccountRepo) Delete(_ context.Context, _ int) error
 func (m *mockAccountRepo) TotalPatrimony(_ context.Context) (float64, error)        { return 0, nil }
 func (m *mockAccountRepo) UpdateLastYieldDate(_ context.Context, _ int, _ string) error { return nil }
 
+type mockCreditBillRepo struct{}
+
+func (m *mockCreditBillRepo) ListByAccount(_ context.Context, _ int) ([]model.CreditBill, error) {
+	return nil, nil
+}
+func (m *mockCreditBillRepo) GetCurrent(_ context.Context, _ int) (*model.CreditBill, error) {
+	return nil, nil
+}
+func (m *mockCreditBillRepo) Upsert(_ context.Context, _ model.CreditBillInput) (*model.CreditBill, error) {
+	return &model.CreditBill{}, nil
+}
+func (m *mockCreditBillRepo) MarkPaid(_ context.Context, _ int, _ *int) error { return nil }
+
 func newAccountSvc() *service.AccountService {
 	repo := &mockAccountRepo{}
 	cdiSvc := service.NewCDIYieldService(repo, &mockTxRepo{})
-	return service.NewAccountService(repo, cdiSvc)
+	billSvc := service.NewCreditBillService(&mockCreditBillRepo{}, repo)
+	return service.NewAccountService(repo, cdiSvc, billSvc)
 }
 
 func TestCreateAccount_EmptyName(t *testing.T) {

apps/api/internal/service/credit_bill.go

@@ -0,0 +1,95 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"financeiro-carvalho/internal/model"
+	"financeiro-carvalho/internal/repository"
+)
+
+var ErrBillNotCreditAccount = errors.New("account is not a credit card account")
+
+type CreditBillService struct {
+	repo        repository.CreditBillRepository
+	accountRepo repository.AccountRepoWithYield
+}
+
+func NewCreditBillService(repo repository.CreditBillRepository, accountRepo repository.AccountRepoWithYield) *CreditBillService {
+	return &CreditBillService{repo: repo, accountRepo: accountRepo}
+}
+
+func (s *CreditBillService) ListByAccount(ctx context.Context, accountID int) ([]model.CreditBill, error) {
+	bills, err := s.repo.ListByAccount(ctx, accountID)
+	if bills == nil {
+		return []model.CreditBill{}, err
+	}
+	return bills, err
+}
+
+func (s *CreditBillService) GetCurrent(ctx context.Context, accountID int) (*model.CreditBill, error) {
+	return s.repo.GetCurrent(ctx, accountID)
+}
+
+// EnsureCurrentBill creates (or refreshes) the current open bill for a credit account
+// using the account's closing_day and due_day config (defaults: closing=1, due=10).
+func (s *CreditBillService) EnsureCurrentBill(ctx context.Context, accountID int, closingDay, dueDay int) error {
+	if closingDay == 0 {
+		closingDay = 1
+	}
+	if dueDay == 0 {
+		dueDay = 10
+	}
+
+	now := time.Now()
+	// Determine the current billing period based on closing day
+	var periodStart, periodEnd time.Time
+	if now.Day() > closingDay {
+		// We're after the closing day: current period is from closingDay+1 this month to closingDay next month
+		y, m, _ := now.Date()
+		periodStart = time.Date(y, m, closingDay+1, 0, 0, 0, 0, time.UTC)
+		next := time.Date(y, m+1, closingDay, 0, 0, 0, 0, time.UTC)
+		periodEnd = next
+	} else {
+		// We're before the closing day: current period is from closingDay+1 last month to closingDay this month
+		y, m, _ := now.Date()
+		periodStart = time.Date(y, m-1, closingDay+1, 0, 0, 0, 0, time.UTC)
+		periodEnd = time.Date(y, m, closingDay, 0, 0, 0, 0, time.UTC)
+	}
+	// Due date: dueDay of the month after periodEnd
+	dueDate := time.Date(periodEnd.Year(), periodEnd.Month()+1, dueDay, 0, 0, 0, 0, time.UTC)
+
+	in := model.CreditBillInput{
+		AccountID:   accountID,
+		PeriodStart: periodStart.Format("2006-01-02"),
+		PeriodEnd:   periodEnd.Format("2006-01-02"),
+		DueDate:     dueDate.Format("2006-01-02"),
+	}
+	_, err := s.repo.Upsert(ctx, in)
+	return err
+}
+
+func (s *CreditBillService) MarkPaid(ctx context.Context, id int, paymentAccountID *int) error {
+	return s.repo.MarkPaid(ctx, id, paymentAccountID)
+}
+
+// currentBillsForDashboard returns unpaid current bills across all credit accounts.
+func (s *CreditBillService) currentBillsForDashboard(ctx context.Context) ([]model.CreditBill, error) {
+	accounts, err := s.accountRepo.List(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var bills []model.CreditBill
+	for _, a := range accounts {
+		if a.Type != "credit" {
+			continue
+		}
+		bill, err := s.repo.GetCurrent(ctx, a.ID)
+		if err != nil || bill == nil {
+			continue
+		}
+		bills = append(bills, *bill)
+	}
+	return bills, nil
+}

apps/api/internal/service/dashboard.go

@@ -21,10 +21,11 @@ type DashboardService struct {
 	repo       DashboardRepo
 	recurrSvc  *RecurringService
 	patrimony  PatrimonySource
+	billSvc    *CreditBillService
 }
 
-func NewDashboardService(repo DashboardRepo, recurrSvc *RecurringService, patrimony PatrimonySource) *DashboardService {
-	return &DashboardService{repo: repo, recurrSvc: recurrSvc, patrimony: patrimony}
+func NewDashboardService(repo DashboardRepo, recurrSvc *RecurringService, patrimony PatrimonySource, billSvc *CreditBillService) *DashboardService {
+	return &DashboardService{repo: repo, recurrSvc: recurrSvc, patrimony: patrimony, billSvc: billSvc}
 }
 
 func (s *DashboardService) Get(ctx context.Context, month string) (*model.DashboardData, error) {
@@ -95,6 +96,11 @@ func (s *DashboardService) Get(ctx context.Context, month string) (*model.Dashbo
 		return nil, err
 	}
 
+	currentBills, _ := s.billSvc.currentBillsForDashboard(ctx)
+	if currentBills == nil {
+		currentBills = []model.CreditBill{}
+	}
+
 	return &model.DashboardData{
 		Month:                   month,
 		TotalIncome:             income,
@@ -106,5 +112,6 @@ func (s *DashboardService) Get(ctx context.Context, month string) (*model.Dashbo
 		RecentTransactions:      recent,
 		PendingRecurring:        pending,
 		PendingIncomeRecurrings: pendingIncome,
+		CurrentBills:            currentBills,
 	}, nil
 }

apps/api/internal/service/dashboard_test.go

@@ -31,8 +31,10 @@ type mockPatrimony struct{}
 func (m *mockPatrimony) TotalPatrimony(_ context.Context) (float64, error) { return 0, nil }
 
 func newDashboardSvc(income, expenses float64) *service.DashboardService {
+	repo := &mockAccountRepo{}
 	recurrSvc := service.NewRecurringService(newMockRecurring(nil), &mockTxRepo{})
-	return service.NewDashboardService(&mockDashboardRepo{income: income, expenses: expenses}, recurrSvc, &mockPatrimony{})
+	billSvc := service.NewCreditBillService(&mockCreditBillRepo{}, repo)
+	return service.NewDashboardService(&mockDashboardRepo{income: income, expenses: expenses}, recurrSvc, &mockPatrimony{}, billSvc)
 }
 
 func TestDashboard_SavingsPct_40(t *testing.T) {