4lessandrodev/finance-project-ddd

This is a financial management system that allows users to create and manage 'budget boxes' for tracking expenses and income. It supports creating, updating, and deleting budget boxes and transactions, as well as transferring balances between them. The system also handles user authentication, account creation, and secure account deletion.

Users can now transfer balances between two budget boxes. The new balance-transference use case validates the transfer amount, source and destination box IDs, and optional reason, note, and attachment, then creates corresponding entry and exit transactions to update the respective box balances.

src/modules/transaction/application/use-cases/balance-transference · medium confidence

Introduces a new use case for deleting a budget box, which validates that the box has a zero balance before proceeding with deletion. The implementation includes a domain event (BudgetBoxDeletedEvent) and a corresponding subscription handler (AfterBudgetBoxDeleted) that logs the deletion. The change also adds a DTO for the use case inputs and a comprehensive test suite covering success, not found, non-zero balance, and error scenarios.

src/modules/budget-box/application/use-cases/delete-budget-box, src/modules/budget-box/domain/events, src/modules/budget-box/domain/subscription · high confidence

The application now exposes a new /health-check endpoint that returns the server status, current time, and client IP address. The default root controller and service have been removed, and the app module has been restructured to import feature-specific modules (User, BudgetBox, Transaction) alongside a new HealthCheckModule. Additionally, the bootstrap process now configures EJS templating, static assets, GraphQL Voyager, and Helmet for security headers.

src · high confidence

Added the ChangeBudgetBoxPercentageUseCase, which allows users to update the percentage value of a budget box. The implementation includes the use case logic, its corresponding DTO, and comprehensive unit tests covering success, validation, and error scenarios.

src/modules/budget-box/application/use-cases/change-budget-box-percentage · high confidence

Users can now update the description of a reason within a budget box and remove reasons from a budget box. This change introduces the \ChangeReasonDescriptionUseCase\ and \RemoveReasonFromBudgetBoxUseCase\ application logic, along with their corresponding DTOs and comprehensive unit tests covering success paths, validation errors, and repository failure scenarios.

src/modules/budget-box/application/use-cases/remove-reason-from-budget-box · high confidence

Users can now delete their own accounts. This change introduces a new DeleteAccountUseCase that validates the user's password before removing the account from the repository and firing a UserAccountDeletedEvent. The implementation includes the use-case logic, the corresponding DTO, the domain event, and a full suite of unit tests covering success, not-found, invalid credentials, and internal server error scenarios.

src/modules/user/application/use-cases/delete-account, src/modules/user/domain/events · high confidence

The user module now includes infrastructure for retrieving user data and validating access. A new UserQueryService allows fetching a user by ID from the database, while a JwtStrategy and JwtAuthGuard enforce authentication using JWT tokens. Additionally, new decorators (GetUserIp, GetUserAgent, GetUserId) are available to extract client and session information from GraphQL contexts.

src/modules/user/infra/services · high confidence

Users can now authenticate via email and password to receive a JWT token, and retrieve user details by ID. The sign-in flow validates credentials, checks the user repository, and generates a JWT token. The get-user-by-id flow queries the user service and returns the user or a 404/500 error. Both use cases are implemented with corresponding DTOs, use-case classes, and unit tests.

src/modules/user/application/use-cases/signin · high confidence

The signup flow is now implemented in the application layer. A new SignUpUseCase validates email, password, and term acceptance, checks for existing users, and persists new accounts. A corresponding SignUpDto defines the input structure including term and user agent details. Tests verify success, conflict, and validation scenarios.

src/modules/user/application/use-cases/signup · high confidence

A new utility function, CheckResultInterceptor, has been added to src/utils. It takes a Domain-Driven Design Result object and, if the result indicates a failure, throws the corresponding NestJS HTTP exception (such as ForbiddenException, ConflictException, or NotFoundException) based on the specific status code. This provides a standardized way to translate internal domain errors into appropriate HTTP responses.

src/utils · high confidence

New GraphQL input classes have been introduced to support user account operations. SigninInput and SignupInput define the data structures for user authentication and registration, with SignupInput also capturing terms acceptance. Additionally, DeleteUserAccountInput was added to handle the data required for account deletion, exposing these capabilities through the API.

src/modules/user/infra/inputs · high confidence

New GraphQL object types have been introduced to support user authentication and identity management. Specifically, the system now exposes JwtPayloadType for handling JWT tokens, UserAgentType to track browser and OS details, TermType to record user consent with IP and timestamp, and UserType to represent the user entity with associated terms. These types enable the GraphQL API to properly serialize and query user-related data.

src/modules/user/infra/types · medium confidence

A new use case and supporting files have been introduced to fetch transactions for a specific user. The implementation includes a DTO accepting a userId and an optional beforeDate filter, and the use case delegates to a transaction query service to retrieve the data, with tests confirming successful retrieval and error handling.

src/modules/transaction/application/use-cases/get-transaction-by-user-id · high confidence

A new utility class, CalculateValueToUpdate, was added to src/modules/shared/utils/calculate.ts to handle budget box balance updates. It accepts a list of budget boxes and a list of DTOs, then applies either a SUM or SUBTRACT operation to update each box's available balance. Alongside this, a new file, src/modules/shared/utils/error-messages/messages.ts, was introduced to centralize validation error messages for budget descriptions, reasons, transactions, and other fields. A corresponding test file, src/modules/shared/utils/tests/calculate.spec.ts, was also added to verify the calculation logic.

src/modules/shared/utils · high confidence

Users can now create, retrieve, and manage budget boxes through new GraphQL mutations and queries. This change introduces the infrastructure layer for the budget-box module, including a NestJS module, service, and resolver that expose endpoints for creating budget boxes, adding or removing reasons, changing descriptions and percentages, and deleting budget boxes. The implementation includes a MongoDB schema, repository, and mappers to handle data persistence and domain mapping, along with integration tests to verify the create and list operations.

src/modules/budget-box/infra · high confidence

The application layer now includes a new CreateBudgetBoxUseCase and its corresponding CreateBudgetBoxDto, enabling users to create a new budget box with a description, owner ID, percentage flag, and budget percentage. The use case validates inputs (e.g., percentage must be ≤ 100) and persists the new budget box via the repository. Added tests verify successful creation, validation failures, and error handling.

src/modules/budget-box/application/use-cases/create-budget-box · high confidence

Users can now have their transactions calculated and validated before execution. New domain services compute transaction values for single budget boxes and distribute amounts across percentage-based budget boxes. Additionally, new proxy services validate whether a user can create a benefit, create an expense, or transfer funds between budget boxes, ensuring sufficient balance and correct box types before proceeding.

src/modules/transaction/domain/services · high confidence

The shared domain layer now includes new domain services and interfaces to support budget box and transaction operations. Specifically, the system introduces a CanCreateTransactionDomainService that validates whether a user has allocated 100% of their budget across their budget boxes before allowing new transactions. Additionally, new services DeleteBudgetBoxByUserIdDomainService and DeleteTransactionsByUserIdDomainService are added to handle the deletion of all budget boxes and transactions for a specific user. The UpdateBudgetBoxBalanceDomainService is also introduced to update budget box balances using a specified operation type (SUM, SUBTRACT, or NONE). These changes are supported by new connection interfaces (IBudgetBoxConnection, ITransactionConnection) that define the data access contracts for these operations.

src/modules/shared/domain · high confidence

A new \CreateExpenseUseCase\ has been introduced in the transaction module, accepting a \CreateExpenseDto\ to process expense creation requests. The implementation validates input fields (such as payment date, reason, status, and total), interacts with a domain service for calculations, and persists the resulting transaction aggregate via the repository. A corresponding test suite has been added to verify successful creation, validation failures, and error handling.

src/modules/transaction/application/use-cases/create-expense · high confidence

A new public-facing documentation page has been added, providing an interactive interface for exploring the API. The page includes a sidebar for navigating between Queries, Mutations, and Types, and utilizes SpectaQL to render the API reference. This allows users to view available operations such as getBudgetBoxById, createBudgetBox, and signup, along with their respective input types and parameters.

public · high confidence

A new index view (views/index.ejs) has been added to serve as the main landing page for the API documentation. This page provides users with two primary navigation options: accessing the 'Organograma' (organogram) to view schema relationships and available queries, and accessing the main documentation to explore mutations, schemas, and entity structures. The page uses Bootstrap 5.1.3 for styling and includes a favicon and theme color configuration.

views · high confidence

Introduced a new use case for posting percentage capital inflow transactions. The implementation includes the core logic in \percentage-capital-inflow-posting.use-case.ts\, which handles validation, domain service invocation, and transaction creation, alongside its corresponding Data Transfer Object in \percentage-capital-inflow-posting.dto.ts\. Comprehensive unit tests have been added in \percentage-capital-inflow-posting-use-case.spec.ts\ to verify success scenarios, validation failures, and error handling.

src/modules/transaction/application/use-cases/percentage-capital-inflow-posting · high confidence

Users can now create and query transactions through new GraphQL mutations and queries. The system supports creating expenses, posting to benefits, transferring balances, and retrieving transaction details by ID or user. The implementation includes a new Mongoose schema for transactions, repository and mapper classes for data persistence, and a resolver layer that exposes these operations to the API.

src/modules/transaction/infra · high confidence

Users can now retrieve their budget boxes through a new application use case. This change introduces the logic to fetch budget boxes associated with the authenticated user's ID, including handling empty results and internal server errors.

src/modules/budget-box/application/use-cases/get-budget-boxes-for-auth-user · high confidence

Users can now retrieve a budget box by its ID and add reasons to it. This change introduces the \GetBudgetBoxById\ and \AddReasonToBudgetBox\ application use cases, along with their corresponding DTOs and unit tests. The \GetBudgetBoxById\ use case fetches a budget box via a query service, while \AddReasonToBudgetBox\ allows adding a reason to an existing budget box, handling validation and repository interactions.

src/modules/budget-box/application/use-cases/add-reason-to-budget-box · high confidence

Introduced the \PostingToBenefitUseCase\ and its associated DTO, enabling the system to process and save new transactions categorized as benefits. The implementation includes the core use-case logic and a corresponding test suite to verify successful creation, validation failures, and error handling.

src/modules/transaction/application/use-cases/posting-to-benefit · high confidence

Users can now authenticate and manage their accounts through new GraphQL endpoints. The API exposes a 'whoAmI' query to retrieve the current user's profile, mutations for 'signup' and 'signin' to handle registration and login, and a 'deleteUserAccount' mutation to allow users to permanently remove their accounts.

src/modules/user/infra/resolver · high confidence

Introduced the user repository and mapper components to handle the conversion between domain models and persistence structures. The new \UserRepository\ implements \IUserRepository\ and uses \UserToDomainMapper\ to map database documents to \UserAggregate\ domain objects, while the corresponding test suite validates the bidirectional mapping logic.

src/modules/user/infra/repo · high confidence

The code generation tool has been configured to produce TypeScript types from the GraphQL schema, resulting in the addition of \src/types/code-gen.types.ts\ and \src/types/schema.gql\. These files define the data structures for managing budget boxes (including currency support for BRL, USD, EUR, JPY), transactions (with status, type, and calculation details), and user account operations (signup, signin, delete). This change introduces the foundational type definitions and schema for these features, enabling the rest of the application to interact with the GraphQL API using strongly typed interfaces.

src/types · high confidence

Adds the core domain classes for the Budget Box feature, including the BudgetBoxAggregate root, ReasonDomainEntity, and supporting value objects (BudgetDescriptionValueObject, ReasonDescriptionValueObject, PercentageValueObject). Users can now define budget boxes with descriptions, optional percentage-based allocation rules, and associated reasons. The aggregate enforces percentage ranges (0–100), description length limits, and provides methods to add, update, and remove reasons, as well as change descriptions and percentages.

src/modules/budget-box/domain · medium confidence

The transaction module now includes a complete domain model for managing financial entries. This includes the \TransactionAggregate\ which tracks user ID, reason, payment date, type, status, and optional notes or attachments. The model enforces that every transaction must have at least one calculation (e.g., budget box allocation), automatically calculating the total value as the sum of all calculations. Additionally, new value objects are introduced for transaction types (Entrada, Saida, Estorno, Transferencia) and statuses (Pendente, Concluido, Estornado), each with specific validation rules such as length limits and character constraints.

src/modules/transaction/domain · high confidence

The user module's infrastructure layer is now fully wired. A new NestJS module registers Mongoose for the User entity, configures JWT-based authentication via Passport, and provides the core services (UserService) that expose sign-up, sign-in, get-user-by-id, and delete-account capabilities to the rest of the application.

src/modules/user/infra · medium confidence

The user domain module now includes a UserAggregate and associated value objects (Email, Password, IP, and Term) that validate inputs and manage user state. A key addition is the deleteAccount method on the aggregate, which marks the user as deleted and publishes a domain event, enabling the platform to handle user account removal.

src/modules/user/domain · high confidence

A new shared infrastructure module has been added to the application, registering and exporting key domain services and database connections. This includes the \BaseConnection\ for MongoDB, specific connections for \BudgetBox\ and \Transaction\ data, and domain services such as \UpdateBudgetBoxBalanceDomainService\, \CanCreateTransactionDomainService\, \DeleteTransactionsByUserIdDomainService\, and \DeleteBudgetBoxByUserIdDomainService\, along with the \CalculateValueToUpdate\ utility. This change centralizes the wiring of these components, making them available for use across the application.

src/modules/shared/infra · medium confidence

A new interface defining the repository contract for the BudgetBox domain, extending the base repository pattern for the BudgetBox aggregate.

src/modules/budget-box/domain/interfaces · high confidence

Users can now have their budget box percentage allocations and changes validated against a 100% total limit. New domain services, CanAllocatePercentageToBudgetBoxDomainService and CanChangeBudgetBoxPercentageDomainService, enforce that the sum of all percentage-based budget boxes does not exceed 100% when allocating or modifying percentages. This ensures that users cannot over-allocate their budget across different boxes.

src/modules/budget-box/domain/services · high confidence

A new domain subscription, AfterTransactionCreated, has been introduced to automatically update budget box balances whenever a new transaction is created. The subscription listens for the TransactionCreatedEvent and, depending on the transaction type (e.g., SUM for 'ENTRADA', SUBTRACT for 'SAIDA'), calls the UpdateBudgetBoxBalanceDomainService to adjust the relevant budget boxes. This ensures that budget box balances are kept in sync with transaction activity without manual intervention.

src/modules/transaction/domain/subscriptions · medium confidence

When a user account is deleted, the system now automatically removes all associated transactions and budget boxes. This is handled by a new subscription that listens for the UserAccountDeletedEvent and triggers the deletion of related data, ensuring a complete user removal.

src/modules/user/domain/subscriptions · high confidence

The application now uses a centralized configuration system in src/config to manage environment variables and database connections. Environment variables for JWT secrets, database credentials (MongoDB host, port, user, password), and application settings (port, currency) are explicitly defined with defaults and validation rules. A new env-logger provides structured logging for environment variables, and the MongoDB connection is configured using these variables, supporting both production (MongoDB Atlas) and development (local) setups.

src/config · high confidence

The shared module now provides a single entry point for all shared resources, including error messages, various model and interface definitions (budget-box, entity, reason, transaction, user, domain-service), infrastructure connections, and the base proxy. This allows consumers to import all shared utilities and types from one location.

src/modules/shared · high confidence

A new Mongoose schema for the User entity has been introduced, mapping fields such as email, password, terms, and deletion status. The schema implements the IUser interface and includes a post-remove hook that triggers domain events for the user's aggregate, ensuring that account deletion is properly propagated through the domain layer.

src/modules/user/infra/entities · high confidence

Build and environment management logic has been moved from package.json and inline commands into dedicated shell scripts. A new post-install script now handles environment-specific setup (e.g., generating GraphQL code in dev vs. production). Pre-start logic for development (killing existing processes on port 3000) and dependency checks (for both dependencies and devDependencies against yarn.lock) have been extracted into separate executable scripts (pre-start-dev.sh, check-deps.sh, check-dev-deps.sh, post-install.sh).

scripts · high confidence

A new TypeScript interface, IUserRepository, is introduced to define the contract for the user repository. This interface extends IBaseRepository and is typed with UserAggregate and IUser, establishing the domain layer's contract for user data access.

src/modules/user/domain/interfaces · medium confidence

The application now includes new infrastructure classes for interacting with MongoDB. A base connection class manages the shared MongoDB client instance, while specific connection classes handle data operations for budget boxes (including updates, lookups, and deletions) and transactions (specifically user-based deletion). These changes provide the underlying data access layer for the domain models.

src/modules/shared/infra/connections · high confidence

The shared interfaces module now defines the data models for key domain entities, including IBudgetBox, IReason, ITransaction, and IUser. These interfaces standardize the structure of budget boxes (with balance, percentage, and reasons), transactions (including currency, status, and calculations), users (with terms and user agent details), and reasons. Additionally, generic interfaces for domain services and entity mocking are provided to support testing and service execution.

src/modules/shared/interfaces · high confidence

The domain event handling system has been removed from the shared folder. Specifically, the \IDomainEvent\ interface, the \DomainEvents\ class responsible for managing event dispatching and registration, and the \IHandle\ interface for event handlers have all been deleted. This eliminates the ability to register event handlers or dispatch domain events through this shared utility.

domain/shared/events · high confidence

The following shared domain components have been removed from the codebase: the generic Identifier class, the Result class for handling success/failure states, the ValueObject abstract class, the Entity and AggregateRoot base classes, the IUseCase interface, and the associated index and base-domain-entity files. This eliminates the shared infrastructure layer that previously provided these reusable domain building blocks.

domain/shared · high confidence

The project's TypeScript configuration (tsconfig.json) was updated to enable strict mode, add path aliases for modules and shared code, and exclude test files from the build. Additionally, new configuration files were added to the repository: an environment variable template (.env.example), ESLint and Prettier configuration files (.eslintrc.js, .prettierrc), Jest test configurations (jest.e2e.config.js, jest.unit.config.js), a GraphQL code generation config (code-gen.yml), a Docker Compose file for the database, and a Spectacle YAML file for API documentation.

(repo-wide) · high confidence

Add domain-level tests for the budget-box module; Add integration tests for user authentication; Added domain tests for transaction value objects and aggregate; Added mock implementations for BudgetBox and Reason domain entities; Added mock implementations for budget and transaction connections; Added shared mock implementations for transaction services; Added snapshot for user aggregate validation; Added snapshot tests for the budget-box aggregate; Added tests for changing a budget box's name; Added tests for the GetTransactionById use case; Added unit tests for domain services; Added user domain mock for testing; Removed e2e test suite and Jest configuration.

The project has been significantly updated, upgrading NestJS from version 7 to 8 and RxJS from 6 to 7. New dependencies have been added including Apollo Gateway, GraphQL tools, MongoDB/Mongoose, bcrypt, and Helmet, while dev dependencies like Jest and ESLint have also been updated to their latest compatible versions.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 52 → 52 (-0.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 89 → 90 (+0.5)
• Architecture 57 → 62 (+4.6)
• Maturity 64 → 66 (+2.8)
• Readiness 49 → 44 (-4.9)
• Security 56 → 76 (+19.2)
• Accessibility 47 → 48 (+1.1)

• Change coupling: budget-box.aggregate.ts ↔ budget-box.resolver.ts (src/modules/budget-box/domain/budget-box.aggregate.ts)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• …and 41 more

• Banned license: ua-parser-js
• Change-coupling hub: budget-box.aggregate.ts → budget-box.module.ts, budget-box.service.ts, budget-box.resolver.ts (src/modules/budget-box/domain/budget-box.aggregate.ts)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• …and 142 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

4lessandrodev/finance-project-ddd was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.