j5ik2o/scala-ddd-base

This system is a Domain-Driven Design (DDD) base library that provides a standardized interface for managing aggregate states across multiple storage backends. It supports hard and soft deletion, as well as single and multi-aggregate read and write operations. The library offers concrete implementations for relational databases (via Slick and Skinny), NoSQL stores (DynamoDB, Redis, Memcached), and in-memory caches, allowing developers to persist and query aggregates consistently regardless of the underlying data store.

The nosql/dynamodb module now includes a complete set of traits for DynamoDB-backed aggregate persistence. This adds the base IO feature, single and multi read/write/delete features, and the underlying DAO support for interacting with DynamoDB. Users can now implement these traits to persist aggregates to DynamoDB using the reactive-aws-dynamodb client.

nosql/dynamodb · high confidence

Added example implementations for UserAccount and UserMessage entities, providing concrete data access and repository layers for DynamoDB, Redis, Memcached, in-memory (Guava cache), Slick, and Skinny. Each backend-specific component defines the record structure and DAO, while the repository layer bridges the domain models to the underlying storage, enabling users to see how to integrate these storage options with the DDD base library.

example · high confidence

The \nosql/memory\ module now provides a complete set of in-memory aggregate features, including single and multi read, single and multi write, single and multi soft/hard delete, and a new \resolveAll\ capability. These new traits implement the core data access operations for in-memory storage, allowing users to persist and query aggregates without an external database.

nosql/memory · high confidence

Introduced new traits and implementations for Memcached and Redis backends, enabling single and multi-aggregate read, write, and delete operations. Each backend provides base features for reading and writing, as well as specific handlers for hard and soft deletes, allowing users to persist and manage aggregate states in these NoSQL stores.

nosql/memcached · high confidence

The project's build infrastructure was initialized with new files: project/build.properties sets the SBT version to 1.2.8, and project/plugins.sbt adds a suite of SBT plugins including scalastyle, scalafmt, sbt-release, sbt-sonatype, sbt-pgp, sbt-wix-embedded-mysql, sbt-dao-generator, flyway-sbt, and sbt-updates, along with a repository and library dependency. Additionally, project/Utils.scala was added to provide SBT logger conversion utilities and a helper for generating temporary server ports during build or test execution.

project · high confidence

The core library now supports multi-aggregate hard and soft deletion, as well as querying all aggregates. New traits \AggregateMultiHardDeletable\ and \AggregateSingleHardDeletable\ allow deleting multiple or single aggregates via hard delete, while \AggregateMultiSoftDeletable\ and \AggregateSingleSoftDeletable\ provide soft delete functionality. Additionally, \AggregateAllReader\ enables fetching all aggregates, and \AggregateChunkReader\ supports paginated queries with offset and limit. The return types for \store\ and \storeMulti\ in \AggregateSingleWriter\ and \AggregateMultiWriter\ have been changed from \Int\ to \Long\ to better represent the number of affected rows.

core · high confidence

The repository was initialized with essential project configuration files: a \.scalafmt.conf\ for code formatting, a \scalastyle-config.xml\ for code style enforcement, a \release.sbt\ for automated release processes, and a \version.sbt\ setting the project version to 1.0.28-SNAPSHOT. Additionally, a \LICENSE\ file (MIT) and a \README.md\ documenting the \scala-ddd-base\ library were added to the project root.

(repo-wide) · high confidence

The Slick DAO implementation in the jdbc/slick module has been refactored to use Monix's Task for all asynchronous database operations, replacing the previous RIO abstraction. This change introduces new capabilities for handling multiple aggregates, including reading all entities (resolveAll), chunked reads (resolveMultiWithOffsetLimit), and multi-writes (storeMulti). Additionally, the module now supports soft and hard deletion of multiple records, as well as single and multi-record reads and writes, providing a more comprehensive set of operations for aggregate management.

jdbc/slick · medium confidence

Added a new \jdbc/skinny\ module that provides a set of Scala traits to integrate the Skinny ORM with the DDD base library. This includes \SkinnyDaoSupport\ which defines the \SkinnyDao\ interface for CRUD operations, and feature traits like \AggregateSingleReadFeature\, \AggregateMultiReadFeature\, \AggregateSingleWriteFeature\, and various delete features (hard/soft) that map DDD aggregates to database records using Monix \Task\ and Cats \ReaderT\ for asynchronous database sessions.

jdbc/skinny · high confidence

The Slick-based repository layer for aggregates has been removed. Specifically, the traits for single and multi-read/write operations (AggregateBaseReadFeature, AggregateMultiReadFeature, AggregateMultiWriteFeature, AggregateSingleWriteFeature, and AggregateSoftDeleteFeature) have been deleted from the codebase. This eliminates the previous implementation of aggregate persistence using Slick and Monix, indicating a shift away from this specific data access pattern.

slick · high confidence

Updated the test database migration script to include a new \user\_message\ table with a composite primary key on \user\_id\ and \message\_id\, along with a corresponding sequence table, to support testing scenarios involving multiple primary keys.

flyway · high confidence

The build.sbt file has been updated to upgrade the versions of several reactive client libraries. Specifically, the versions for reactive-aws-client, reactive-redis, and reactive-dynamodb have been updated to their latest releases. This ensures the project uses the most recent stable versions of these dependencies, which may include bug fixes, performance improvements, or new features provided by the upstream libraries.

(dependencies) · high confidence

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

• CAI 67 → 61 (-6.2)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 97 (-3.1)
• Architecture 100 → 87 (-13.4)
• Maturity 54 → 49 (-5.5)
• Readiness 70 → 61 (-9.0)
• Security 78 → 78 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• No exposed public API
• Test reliability not included
• complexity unreadable for .scala — churn × complexity hotspots could not be measured
• no production source files with tracked history to analyse
• no production source files with tracked history to analyse

• Documentation: no installation or build instructions (README.md)
• Duplicated block (10 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/dynamodb/UserAccountComponent.scala)
• Duplicated block (10 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/memcached/UserAccountComponent.scala)
• Duplicated block (10–11 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/dynamodb/UserAccountComponent.scala)
• Duplicated block (13 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/dynamodb/UserAccountComponent.scala)
• Duplicated block (13 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/dynamodb/UserAccountComponent.scala)
• Duplicated block (13 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/repository/skinny/UserAccountRepositoryBySkinny.scala)
• Duplicated block (13 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/repository/skinny/UserAccountRepositoryBySkinny.scala)
• Duplicated block (13 lines × 4) (example/src/main/scala/com/github/j5ik2o/dddbase/example/repository/dynamodb/UserAccountRepositoryOnDynamoDB.scala)
• Duplicated block (13 lines × 4) (example/src/main/scala/com/github/j5ik2o/dddbase/example/repository/dynamodb/UserAccountRepositoryOnDynamoDB.scala)
• Duplicated block (15–16 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/dynamodb/UserAccountComponent.scala)
• Duplicated block (16 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/dynamodb/UserAccountComponent.scala)
• Duplicated block (16 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/repository/memcached/UserAccountRepositoryOnMemcached.scala)
• Duplicated block (16 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/repository/memcached/UserAccountRepositoryOnMemcached.scala)
• Duplicated block (5–6 lines × 4) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/dynamodb/UserAccountComponent.scala)
• Duplicated block (7 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/dynamodb/UserMesssageComponent.scala)
• Duplicated block (7 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/memcached/UserAccountComponent.scala)
• Duplicated block (7 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/memcached/UserAccountComponent.scala)
• Duplicated block (7 lines × 2) (nosql/memcached/src/main/scala/com/github/j5ik2o/dddbase/memcached/AggregateSingleReadFeature.scala)
• Duplicated block (7–8 lines × 2) (example/src/main/scala/com/github/j5ik2o/dddbase/example/dao/dynamodb/UserMesssageComponent.scala)
• …and 6 more

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

j5ik2o/scala-ddd-base 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.