j5ik2o/cqrs-es-example-rs

This release introduces the foundational architecture for a group chat feature, implementing a CQRS pattern with separate read and write API servers built in Rust. It establishes the command and query modules, including domain models, repository interfaces, and GraphQL endpoints for both writing events and reading models. The release also delivers comprehensive infrastructure and tooling, including Helm charts, Terraform configurations for EKS, and scripts for local development and end-to-end testing.

A new tool for setting up DynamoDB tables is now available in the tools/dynamodb-setup directory. The change introduces a Dockerfile and a shell script (create-tables.sh) that use the AWS CLI to create 'journal' and 'snapshot' tables with specific schemas, global secondary indexes, and stream specifications. A Makefile is also provided to build, run, and publish the container image, allowing users to easily deploy the table creation logic in a containerized environment.

tools/dynamodb-setup · high confidence

A new Helm chart is introduced in tools/deploy/charts/dynamodb to deploy Amazon DynamoDB Local and a DynamoDB Admin UI on a Kubernetes cluster. The chart creates a two-container pod, configures a service, ingress, and optional persistent storage, providing a quick way to run a local DynamoDB instance for development and testing.

tools/deploy/charts/dynamodb · high confidence

New GraphQL input and output types and resolvers are introduced in the command interface adaptor, exposing mutations for creating, deleting, and renaming group chats, as well as adding/removing members, and posting, editing, or deleting messages. These changes enable users to interact with group chat and messaging features through the GraphQL interface.

modules/command/interface-adaptor-impl/src/graphql · high confidence

A new \rmu\ module has been added to handle read model updates triggered by DynamoDB stream events. The implementation includes a Rust function that processes group chat events (creation, deletion, renaming, member changes, and message operations) and updates the corresponding read model via a DAO interface. A sample JSON fixture for DynamoDB events has also been added to support testing.

modules/rmu · high confidence

Added new files in the tools/e2e-test directory to support end-to-end testing of group chat functionality. This includes a Dockerfile to build a container with curl and jq, a Makefile with targets for building, running, and publishing the e2e-test container, and a verify-group-chat.sh script that executes a sequence of GraphQL mutations and queries to create a group chat, add members, post messages, and verify state, ensuring the group chat feature works as expected in an end-to-end scenario.

tools/e2e-test · high confidence

A new executable binary named export-sdl has been added to the write-api-server application. This tool, located at applications/write-api-server/bin/export-sdl.rs, allows users to generate and print the GraphQL Schema Definition Language (SDL) for the API. It initializes the GraphQL schema builder and outputs the resulting schema definition to the console.

applications/write-api-server/bin · high confidence

The Refinery tooling now includes the initial database schema for group chats, members, and messages, alongside a Dockerfile, a Makefile for container management, and a version script. This establishes the foundational data model and build environment for the service.

tools/refinery · high confidence

A new \local.rs\ file has been added to the \applications/read-model-updater/bin\ directory, providing a standalone executable for local development of the read-model-updater. This entry point initializes the application configuration, connects to MySQL and AWS DynamoDB/DynamoDB Streams, and runs a continuous loop to process stream events and update the read model, facilitating local testing and debugging of the updater's core logic outside of the Lambda environment.

applications/read-model-updater/bin · high confidence

The \modules/query\ area now includes a new \interface-adaptor\ module that exposes a GraphQL API for reading group chats, members, and messages. This includes the \controllers.rs\ file which registers routes for health checks (\/health/alive\, \/health/ready\), a root endpoint, and the main GraphQL handler at \/query\. The \gateways.rs\ file implements data access objects for \GroupChat\, \Member\, and \Message\ using \sqlx\ queries against MySQL, with corresponding JSON metadata files in \.sqlx/\ defining the static query checks. The \resolvers.rs\ file defines the GraphQL schema and query resolvers that delegate to these data access objects.

modules/query · high confidence

New Helm chart packages have been introduced to the deployment tooling, each containing standard Kubernetes templates and configuration files. These include the ALB controller Custom Resource Definitions (CRDs) for AWS load balancer management, a job-based setup for DynamoDB tables, a ClusterRoleBinding for the Kubernetes dashboard, and deployment templates for the read API server and read model updater. Each chart includes helper templates, value definitions, and specific resource definitions (such as Deployments, Services, and Ingresses) to facilitate their respective Kubernetes workloads.

(repo-wide) · high confidence

Introduced the command domain module with new domain models for group chats and user accounts. The group chat aggregate supports creating, deleting, renaming, and managing members and messages, with corresponding events for each state change. User account aggregates are also defined, though currently marked as unused in the domain layer. Error handling and ID generation utilities are included.

modules/command/domain · high confidence

Introduced the \GroupChatReadModelUpdateDaoImpl\ to handle SQL-based updates for group chat read models, including inserting, deleting, and renaming group chats, as well as managing members and messages. Additionally, a \GroupChatRepositoryImpl\ was added to manage event sourcing for group chats, supporting both in-memory mock storage for testing and a production-ready implementation that persists events and snapshots to an event store.

modules/command/interface-adaptor-impl/src/gateways · high confidence

The command interface-adaptor module now provides the \GroupChatRepository\ trait for persisting group chat events and snapshots, along with the \GroupChatReadModelUpdateDao\ trait for updating read models (group chats, members, and messages). These interfaces define the contract for the command side of the application, separating the domain logic from specific storage implementations.

modules/command/interface-adaptor-if · high confidence

A new 'infrastructure' module has been added to the codebase, providing a general technical foundation for language extensions. This includes a Rust library skeleton (lib.rs), a Rust formatting configuration (rustfmt.toml) with specific style rules, and a README file describing the module's purpose.

modules/infrastructure · high confidence

Added a suite of shell scripts in tools/scripts to support building, running, and deploying the read-model-updater Lambda function and the read/write API servers. This includes scripts for building the Lambda binary and packaging it for local deployment to LocalStack (deploy-read-model-updater-localstack.sh), building and pushing Docker images to Amazon ECR (docker-ecr-push-\.sh), and managing Kubernetes ingress DNS records via AWS Route53 (aws-route53-upsert-external-dns-of-\.sh). The changes also introduce scripts for running the API servers and the Refinery migration tool, and update the docker-compose workflow to automatically build and deploy the Lambda function when starting the local development environment.

tools/scripts · high confidence

The repository is initialized with essential configuration files that establish the development environment and build workflow. This includes a Cargo workspace structure with Rust tooling (rustfmt.toml, rust-toolchain.toml), a Makefile.toml to standardize build, test, and formatting commands, and a Renovate configuration to automate dependency updates. The project also introduces a .tool-versions file to pin specific versions for Terraform, Helm, kubectl, Python, and other infrastructure tools, ensuring consistent local and CI environments.

(repo-wide) · high confidence

The \interface-adaptor-impl\ module now exposes a new GraphQL-based interface for handling commands. This includes a \controllers.rs\ file that registers HTTP routes for health checks and the GraphQL endpoint, a \gateways.rs\ file defining the \EventPersistenceGateway\ trait and key resolution logic, and a \graphql.rs\ file that constructs the GraphQL schema and service context. These changes add the necessary adapter-layer components to support event-store interactions and GraphQL query/mutation execution for group chat commands.

modules/command/interface-adaptor-impl/src · high confidence

A new command processor for group chats has been added, enabling users to create, rename, add or remove members, and delete group chats. This implementation handles the associated domain logic and repository interactions, exposing a clean interface for managing group chat state changes.

modules/command/processor · high confidence

Added the \read-model-updater\ application, a Rust-based service that processes domain events to update read models. The implementation includes a Dockerfile for AWS Lambda deployment and a local development Dockerfile for LocalStack integration, along with configuration structures for AWS and database settings. The application connects to a MySQL database and a DynamoDB stream to perform read model updates, supporting both production Lambda execution and local development workflows.

applications/read-model-updater · high confidence

A new write-api-server application is introduced, providing a Rust-based API server for updating aggregates. The server is built using the Axum framework and connects to a DynamoDB-backed event store via the AWS SDK. It exposes a REST-like API for managing group chats, with configuration managed through environment variables and a local config file, and includes a Dockerfile for containerized deployment.

applications/write-api-server · high confidence

Added comprehensive Terraform modules and Helmfile configurations to deploy the CEER application stack on EKS. This includes infrastructure for the AWS Load Balancer Controller, Cluster Autoscaler, and Datadog monitoring. The deployment now provisions ECR repositories for the refinery, write-api-server, read-model-updater, and read-api-server images. Additionally, environment-specific configuration files and Helmfile templates are introduced for managing MySQL, LocalStack, DynamoDB, and the write/read API servers, enabling full-stack deployment of the application's microservices and supporting infrastructure.

tools/deploy · high confidence

A new read-api-server application has been added, providing an API server that returns lead models via GraphQL queries. The server is built with Rust, using the axum framework, and includes a Dockerfile for containerization. The implementation features configuration loading from environment variables and a config file, database connection pooling with MySQL, and CORS support for cross-origin requests.

applications/read-api-server · high confidence

Added integration tests for group chat domain; Added integration tests for the command processor.

The project's Rust dependencies have been updated across 12 manifests, including crates such as \serde\_json\, \event-store-adapter-rs\, \anyhow\, \openssl\, \aws-sdk\ packages, and \testcontainers\. A new \Cargo.lock\ file has been added to the repository to pin the resolved dependency tree, ensuring reproducible builds.

(dependencies) · medium confidence

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

• CAI 62 → 65 (+3.1)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 99 (-0.7)
• Architecture 100 → 88 (-11.5)
• Maturity 72 → 64 (-8.5)
• Readiness 69 → 73 (+3.5)
• Security 41 → 53 (+11.7)
• Domain Modelling 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High IaC: KSV-0014 (tools/deploy/charts/dynamodb/templates/deployment.yaml)
• High vulnerability: [GHSA redacted] (Cargo.lock)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 39 more

• Critical IaC: AWS-0104 (tools/deploy/terraform/security-groups/main.tf)
• Documentation: hard to navigate (docs/FAQ.ja.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (modules/command/interface-adaptor-impl/src/gateways/group_chat_read_model_dao_impl.rs)
• Duplicated block (11 lines × 2) (modules/command/interface-adaptor-impl/src/gateways/group_chat_read_model_dao_impl.rs)
• Duplicated block (12 lines × 2) (applications/read-api-server/src/main.rs)
• Duplicated block (12 lines × 2) (modules/command/domain/src/group_chat.rs)
• Duplicated block (6 lines × 2) (applications/read-api-server/src/main.rs)
• Duplicated block (8 lines × 5) (modules/command/processor/src/group_chat_command_processor.rs)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• High IaC: KSV-0014 (tools/deploy/charts/dynamodb/templates/deployment.yaml)
• High IaC: KSV-0014 (tools/deploy/charts/dynamodb/templates/deployment.yaml)
• High IaC: WD-COMPOSE-0001 (tools/docker-compose/docker-compose-databases.yml)
• …and 144 more

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

j5ik2o/cqrs-es-example-rs 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.