How savantly-net/nexus-command works
Main Components
• Web User Interface – the default webapp that contains the front-end logic, static resources (CSS, JavaScript, HTML templates), and is responsible for interacting with the user.
• Application Server / Business Logic – the core of the application is built as an Apache Causeway application and is broken into multiple Maven modules (for example: module-organizations, module-projects, module-franchise, module-security, module-web, module-ai, etc.). Each module encapsulates a specific business domain or functionality.
• Persistence / Database Layer – the application uses an in-memory H2 database by default with support (via Flyway migrations) for production databases like Postgres or SQL Server.
• Infrastructure & DevOps – Docker Compose files, Kubernetes/Docker deployment files (the Docker, Procfile, and multiple docker-compose files) illustrate that containerized deployment is supported.
Breakdown of Architectural Layers and Zones
• Presentation / Client Layer:
• Webapp front-end (located in the “webapp” directory).
• Static assets (CSS, images, templates) and the configuration of the Apache Causeway-based UI.
• Business Logic / Application Modules:
• That these modules are enabled/disabled by configuration properties (see README’s “Common Configurations” section).
• Role of Apache Causeway as the framework that unifies domain-driven design (with attached domain classes, fixtures, and integration tests for rapid model-driven development).
• Persistence Layer:
• A database component that may represent H2 or relational databases managed via Flyway.
• A note that load-time weaving and JPA (via EclipseLink) are used.
• Integration Layer:
• Messaging components (Kafka module, webhooks module) and external REST/API integrations.
• Platform Operations:
• Container management (Docker files, Makefile commands, deployment scripts) and Continuous Integration aspects (GitHub workflows, Maven wrapper scripts).
Relationships and Interactions
• Interactions between business modules (e.g., organization management, project management, franchise management) – even if these are tightly coupled as modules within a monolithic architecture, show them as logical components connecting through a common service layer.
• Database transactions coming from business modules and DAOs/repositories.
• Integration paths from business modules to external systems like messaging (Kafka, webhooks) and authentication (OAuth2).
Highlighting Architectural Patterns
• Layered or MVC-like Pattern – separate UI, business logic, and persistence.
• Plugin/Extensibility – explain that the modules are designed to be used either within the default webapp or in a custom composable application.
• Integration Patterns – asynchronous messaging, API gateways, and external service hooks.
Relevant Technologies
• Apache Causeway (as the framework for rapid domain-driven application development)
• Java 17, Maven – indicating the build and language stack.
• Docker, Docker Compose – for containerizing the application.
• EclipseLink JPA with load-time weaving (spring-instrument)
• Messaging Systems: Kafka (module-kafka) and webhooks (module-webhooks)
• Databases: H2 (default), PostgreSQL/SQL Server (configurable via profiles)