loom/loom-java

Loom is a Java-based framework that provides abstractions for event sourcing, message handling, and JSON serialization. It enables developers to manage domain events and commands through a structured event store and rehydration process, while offering pluggable strategies for type resolution and JSON processing. The system also supports distributed messaging via Azure Event Hubs, allowing for robust integration with cloud-based event streams.

11 changes.

This period covers the initial setup of the Loom project, establishing the Gradle build system and multi-module architecture. It includes the implementation of core abstractions for JSON processing and messaging, alongside the creation of corresponding unit tests and configuration files.

6 changes.

This period focused on establishing the foundational abstractions for event sourcing and type resolution, introducing key interfaces like CommandExecutor, EventHandler, and Rehydrator. Concurrently, the codebase expanded its messaging capabilities by integrating Azure Event Hubs support and implementing type strategies for stream-based commands and events.

Added the loom.messaging.azure module, introducing EventConverter and EventProcessor classes to handle serialization and deserialization of messages for Azure Event Hubs. The EventConverter manages conversion between internal Message objects and Azure EventData, while the EventProcessor coordinates processing incoming events by restoring messages and routing them to a MessageHandler.

loom.messaging.azure · high confidence

A new Message class has been added to the loom.messaging.contract module. This class serves as a data carrier for messaging operations, containing fields for id, processId, initiator, predecessorId, and a generic data payload.

loom.messaging.contract · high confidence

The codebase now includes new type strategies for handling stream-based domain events and commands. Specifically, \StreamEventTypeStrategy\ and \StreamCommandTypeStrategy\ have been added to the \loom.eventsourcing.type\ package. These classes implement the \TypeStrategy\ interface to format and resolve types for \StreamEvent\ and \StreamCommand\ instances, utilizing a configurable prefix and a payload type strategy to construct and parse their type representations.

loom.eventsourcing.type · high confidence

The project now includes a Gradle wrapper configuration file (gradle-wrapper.properties) that specifies the use of Gradle version 6.4.1. This ensures consistent build environments by automatically downloading and using the correct Gradle distribution, removing the need for users to have Gradle installed locally.

gradle · high confidence

The repository has been initialized with essential project configuration files, including an .editorconfig for consistent code formatting, a .gitignore to exclude build artifacts and IDE files, and a .gitattributes for line-ending normalization. A Gradle wrapper (gradlew/gradlew.bat) has been added to manage the build environment, alongside a lombok.config to enable constructor property generation. The project is named 'Loom' and is licensed under the MIT license (updated copyright year to 2023).

(repo-wide) · high confidence

The loom.json.abstraction module now provides a new set of classes and interfaces for handling JSON data. This includes a JsonData model, a JsonProcessor that coordinates type resolution and serialization/deserialization, and strategy interfaces (JsonStrategy, JsonSerializer, JsonDeserializer) that allow pluggable JSON handling implementations.

loom.json.abstraction · medium confidence

A new JacksonJsonStrategy class has been added to the loom.json.jackson module, implementing the JsonStrategy interface to provide JSON serialization and deserialization capabilities using the Jackson library. This enables users to leverage Jackson for JSON processing within the loom.json framework.

loom.json.jackson · high confidence

Added the MessageHandler interface defining canHandle and handle methods, a CompositeMessageHandler implementation that delegates to multiple handlers and aggregates errors, and a MessageBus interface with a default send method for single messages.

loom.messaging.abstraction · high confidence

Added new abstractions for handling Java types, including the TypeFormatter and TypeResolver interfaces, along with concrete implementations like ClassNameTypeResolver and TypeNameFormatter. The system now supports resolving types from their string representations and formatting types into strings, with a delegating strategy that combines both capabilities.

loom.type · medium confidence

The \loom.eventsourcing.abstraction\ module introduces a set of new interfaces and classes that define the core architecture for event sourcing. This includes the \CommandExecutor\ and \EventHandler\ interfaces, which standardize how commands produce events and how state is updated by events. The \EventStore\ interface now extends \EventCollector\ and \EventReader\ to manage event persistence and retrieval. A \Rehydrator\ class handles the logic for reconstructing state from the event stream, and the \Headspring\ class provides a concrete implementation that integrates command execution, event handling, and message handling. Additionally, a \Snapshot\ class is added to encapsulate the current state, version, and stream ID.

loom.eventsourcing.abstraction · medium confidence

Corrected package name errors in the loom.eventsourcing.contract module by introducing the StreamCommand and StreamEvent classes. These new classes, located in the loom.eventsourcing package, define the structure for stream-based commands and events, each carrying a stream identifier, payload, and relevant metadata such as version and timestamp.

loom.eventsourcing.contract · medium confidence

Added test fixtures and specifications for the loom module; Added unit tests for Azure messaging components; Added unit tests for JacksonJsonStrategy and JsonProcessor; Added unit tests for the eventsourcing module; Added unit tests for type resolution and formatting components.

The project has been initialized with a Gradle build system, establishing a multi-module structure for components including loom.type, loom.json.abstraction, loom.json.jackson, loom.messaging.contract, loom.messaging.abstraction, loom.messaging.azure, loom.eventsourcing.contract, loom.eventsourcing.abstraction, and loom.eventsourcing.type. The configuration includes standard Java 1.8 compatibility, checkstyle enforcement, and Maven publishing to OSSRH. External dependencies such as Jackson 2.13.0, JUnit 5.9.0, and Azure Event Hubs 5.15.0 are explicitly defined.

(dependencies) · medium confidence

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

• CAI 48 → 51 (+2.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 99 (-0.3)
• Architecture 69 → 92 (+22.7)
• Maturity 38 → 38 (+0.0)
• Readiness 41 → 41 (+0.0)
• Security 65 → 72 (+6.5)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (7 lines × 2) (loom.eventsourcing.type/src/main/java/loom/eventsourcing/StreamCommandTypeStrategy.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• No installation or dependency requirements section; a user cannot install Loom without this. (README.md)
• No usage example showing how to create a publisher/subscriber or read events from a stream. (README.md)
• Test reliability not included
• dormant codebase — no living knowledge left to concentrate

• Coverage not measured — no coverage collector is wired up
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (17 lines × 2) (loom.type/src/main/java/loom/type/ClassNameTypeResolver.java)
• Duplicated block (6 lines × 2) (loom.eventsourcing.type/src/main/java/loom/eventsourcing/StreamCommandTypeStrategy.java)
• Duplicated block (8 lines × 2) (loom.eventsourcing.type/src/main/java/loom/eventsourcing/StreamCommandTypeStrategy.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No dependency advisory monitoring

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

loom/loom-java 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.