dogganidhal/noddde

Noddde is a TypeScript framework for building Domain-Driven Design applications using CQRS, Event Sourcing, and Event-Driven architectures. It provides a core engine for managing aggregates, sagas, and projections, supported by pluggable adapters for various databases (Prisma, Drizzle, TypeORM) and message brokers (Kafka, NATS, RabbitMQ). The system emphasizes reliability through features like transactional outboxes, idempotency stores, and concurrency control, while offering a CLI for scaffolding and a NestJS integration for seamless deployment.

Introduces a new RabbitMQ implementation of the EventBus interface, allowing users to publish and consume domain events via RabbitMQ exchanges and queues. The adapter supports configurable exchange types (topic or fanout), queue prefixes for consumer isolation, prefetch-based backpressure, and manual acknowledgment for at-least-once delivery. It includes built-in resilience with exponential backoff reconnection, dead-letter queue support for failed messages, and OpenTelemetry instrumentation for tracing.

packages/adapters/rabbitmq/src · high confidence

This change introduces the core domain logic for a hotel booking reference application within the \samples/sample-hotel-booking\ directory. It defines the event model for Room, Booking, and Inventory aggregates, and implements three process-model sagas: \BookingFulfillment\ (orchestrating payment and room reservation), \CheckoutReminder\ (sending SMS notifications), and \PaymentProcessing\ (handling gateway charges). Additionally, it provides read-model projections for Room Availability, Guest History, and Revenue, along with the necessary query handlers to support these views.

samples/sample-hotel-booking/src/domain · high confidence

Introduces the \sample-hotel-booking\ project, a full-stack reference application demonstrating the framework's Domain-Driven Design, CQRS, and Event Sourcing capabilities. The sample models a hotel booking domain with aggregates for Rooms, Bookings, and Inventory, coordinated by sagas for automated fulfillment and payment processing. It utilizes Drizzle with PostgreSQL for state-stored entities and views, and supports both RabbitMQ and in-memory event buses. The package includes configuration for ESLint, TypeScript, and Vitest, along with a \docker-compose.yml\ for local infrastructure setup.

samples/sample-hotel-booking · high confidence

The \@noddde/core\ package is now fully configured for development and distribution. It ships with a \tsup\ build setup that emits dual CommonJS and ESM bundles, alongside dedicated TypeScript configurations for linting, testing, and type-system stress testing. The package includes an ESLint configuration, a CHANGELOG documenting the v1.0.0-rc.2 API freeze (including breaking changes to \SagaPersistence\ and \IdempotencyStore\), and a README detailing the core DDD/CQRS abstractions. Additionally, scripts for generating synthetic type-system stress fixtures have been added to measure compiler performance against the public API surface.

packages/core · high confidence

The engine runtime now provides built-in support for optimistic and pessimistic concurrency strategies, allowing users to configure per-aggregate retry or locking behavior to handle concurrent command dispatch. It also implements a transactional outbox pattern via the OutboxRelay, ensuring at-least-once event delivery by persisting events to an outbox store and polling for unpublished entries. Additionally, a new Projection Rebuild API enables administrators to truncate and replay events for specific projections, with progress tracking and support for view deletion sentinels. These changes are supported by a new structured logger (NodddeLogger) that auto-detects environment for pretty vs. JSON output, and native OpenTelemetry instrumentation for trace context propagation.

packages/engine/src · high confidence

The flash-sale sample now includes two distinct entry points, main-optimistic.ts and main-pessimistic.ts, which demonstrate how to handle concurrent purchase attempts using either optimistic concurrency (with configurable retries) or pessimistic concurrency (using PostgreSQL advisory locks). Both examples wire the domain with TypeORM for event-sourced persistence and support switching between an in-memory event bus and a NATS-based distributed event bus via the EVENT\_BUS environment variable.

samples/sample-flash-sale/src · high confidence

The sample flash-sale application now includes a complete domain model for managing limited-stock items. This adds the FlashSaleItem aggregate, which tracks stock levels, sales counts, and buyer history. It defines commands to create a sale and purchase items, and handles the logic for rejecting purchases when stock is depleted by emitting a PurchaseRejected event. The model also specifies the resulting domain events (FlashSaleCreated, ItemPurchased, PurchaseRejected) and their payloads.

samples/sample-flash-sale/src/domain · high confidence

The engine now ships with a suite of in-memory implementations for core runtime components, enabling local development and testing without external infrastructure. This includes an EventEmitter-based EventBus for in-process event dispatch, in-memory stores for command and query buses, and persistence backings for aggregates (both event-sourced and state-stored), sagas, snapshots, and projection views. It also provides in-memory support for idempotency (commands and events), a unit of work for transactional buffering, an outbox store for at-least-once delivery, and an aggregate locker for concurrency control.

packages/engine/src/implementations · high confidence

The Auction sample is now available as a standalone project in the samples directory, demonstrating core noddde patterns including event-sourced aggregates, CQRS projections, and event upcasting. The sample uses Prisma with SQLite for persistence and includes a comprehensive test suite, ESLint configuration, and a detailed README explaining the domain model and framework features.

samples/sample-auction · high confidence

The new @noddde/cli package provides command-line tools to scaffold and extend Domain-Driven Design modules, including commands, queries, event handlers, aggregates, projections, and sagas. It features a 'noddde new' workflow to generate full projects or individual components, and a 'noddde add' workflow to extend existing modules with automatic wiring. Additionally, the 'noddde diagram' command visualizes domain flows by introspecting aggregates, projections, and sagas, outputting Mermaid diagrams by default. The CLI is built with tsup to emit dual CJS and ESM bundles, includes specific ESLint rules to allow console output, and has increased Vitest timeouts for diagram tests to accommodate the TypeScript compiler's runtime overhead.

packages/cli · high confidence

The new @noddde/nestjs package provides a NestJS integration that bridges the noddde domain model to NestJS dependency injection and lifecycle management. It registers the Domain as a global injectable, supports static and async configuration via NodddeModule.forRoot/forRootAsync, and automatically handles domain shutdown and outbox relay lifecycle. A key behavioral addition is the NodddeMetadataInterceptor, which propagates correlation and user metadata through the AsyncLocalStorage scope for the entire request lifecycle, ensuring commands dispatched from controllers inherit request context. The package is built with tsup to emit dual CJS and ESM bundles, and relies on peer dependencies for NestJS, rxjs, and reflect-metadata.

packages/integrations/nestjs, packages/integrations/nestjs/src · high confidence

The new @noddde/testing package provides in-memory test utilities for noddde domains, eliminating the need for database or message-broker setup during testing. It includes specific harnesses for unit testing aggregates (testAggregate, evolveAggregate), projections (testProjection), and sagas (testSaga), as well as a testDomain function for full integration testing of command dispatch and event flow. The package ships with dual CJS/ESM bundles, TypeScript definitions, and is configured with Vitest for running the included test suite.

packages/testing · high confidence

Adds a new KafkaEventBus implementation for the event bus system, enabling domain events to be published to and consumed from Kafka topics. The adapter supports configurable consumer groups, automatic topic provisioning with customizable partitions and replication factors, and dead-letter queue (DLQ) handling for failed messages. It includes resilience features such as bounded retry attempts for handler failures to prevent poison messages from crashing the consumer, and optional warmup functionality to verify broker connectivity and reduce cold-start latency.

packages/adapters/kafka/src, packages/adapters/nats/src · high confidence

The Prisma adapter now includes a schema defining tables for event-sourced aggregates (NodddeEvent, NodddeAggregateState), saga states (NodddeSagaState), snapshots (NodddeSnapshot), and a transactional outbox (NodddeOutboxEntry). This schema supports the new OutboxStore and EventIdempotencyStore implementations, enabling reliable event publishing and deduplication. It also includes a test fixture for typed-column state mapping. The schema is configured for SQLite by default but includes documentation warnings for MySQL deployments regarding column sizing for large text fields.

packages/adapters/prisma/prisma · high confidence

This change establishes the foundational command handling layer within the CQRS module. It defines the \Command\ interface, distinguishing between \AggregateCommand\ (routed to specific aggregates via \targetAggregateId\) and \StandaloneCommand\ (handled by infrastructure-aware handlers for sagas or notifications). The \CommandBus\ interface and its optional \CommandHandlerRegistry\ sub-interface are introduced to manage command dispatch and local registration. A key behavioral addition is support for idempotent command processing: commands can now include an optional \commandId\ (typed as \ID\), which the engine uses to skip duplicates if an \IdempotencyStore\ is configured, while also serving as the causation ID for resulting events. The \DefineCommands\ utility type is provided to easily create discriminated unions of command types from a payload map.

packages/core/src/cqrs/command · high confidence

The persistence layer now uses a unified \PersistenceAdapter\ interface to manage database interactions, replacing previous wiring mechanisms. This adapter acts as a central registry for optional capabilities—including event sourcing, state storage, sagas, snapshots, the transactional outbox, idempotency, pessimistic locking, and global event reading—while mandating a \UnitOfWorkFactory\ for transactional boundaries. By implementing this interface, database adapters can now provide these features to the engine, enabling stronger consistency guarantees and more flexible storage strategies.

packages/core/src/persistence · high confidence

This change adds the foundational types and interfaces for the CQRS query side within the core package. It defines the \Query\ interface with a branded symbol to carry phantom result types, enabling the \QueryResult\ utility to extract return types automatically. A new \DefineQueries\ utility allows users to generate discriminated unions of query types from a definition map, simplifying the creation of strongly-typed queries. The \QueryBus\ interface provides the primary method for dispatching queries and retrieving typed results, while the \QueryHandler\ type specifies the signature for handler functions, which receive the query payload and infrastructure dependencies. These files establish the contract for reading data from projections and read models.

packages/core/src/cqrs/query · high confidence

This change adds the infrastructure layer for the new sample-hotel-booking application, providing a complete HTTP interface via Fastify and PostgreSQL persistence using Drizzle ORM. The HTTP layer exposes REST endpoints for managing rooms and bookings (including atomic group bookings), querying availability and guest history, and handling payments, while wiring in domain commands and queries. Persistence is implemented with a dedicated typed table for Room aggregate state and a generic JSONB-backed view store for projections, supporting both transactional and eventual consistency patterns. The sample also includes configurable service implementations for email, SMS, and payments (console/in-memory variants) and a standalone nightly audit command handler to demonstrate cross-aggregate coordination.

samples/sample-hotel-booking/src/infrastructure · high confidence

The core package now exports a new \ID\ type that allows aggregate, saga, and entity identifiers to be defined as \string\, \number\, or \bigint\ (including branded variants), replacing the previous implicit or restricted identifier handling. This change enables domains to choose the most appropriate identifier strategy for their data models, such as using numeric auto-increment IDs or 64-bit database IDs, while maintaining type safety through the unified \ID\ union type exported from the main entry point.

packages/core/src · high confidence

This change introduces the foundational types and utilities for the new Event-Driven Domain (EDD) core API. It defines the core Event interface and a DefineEvents utility for creating discriminated unions, along with an EventMetadata envelope that carries audit, tracing (OpenTelemetry), and sequencing information. The EventBus interface establishes the contract for publishing events and handling late subscriptions, while the EventHandler type enables side-effecting logic with infrastructure access. To support reliable processing, an EventIdempotencyStore and withIdempotency wrapper are provided to deduplicate redelivered events. Finally, a type-safe Upcaster API (defineEventUpcasterChain, defineUpcasters, upcastEvent) is added to handle event schema versioning and evolution.

packages/core/src/edd · high confidence

Added a new \sample-flash-sale\ project that serves as a reference implementation for handling high-contention scenarios in event-sourced applications. The sample demonstrates both optimistic concurrency (with automatic retries) and pessimistic locking (using PostgreSQL advisory locks via TypeORM) for a flash-sale domain where limited stock is sold concurrently. It includes production-grade infrastructure patterns such as snapshots, idempotency, and a distributed event bus backed by NATS JetStream, alongside a comprehensive test suite using Vitest and in-memory harnesses.

samples/sample-flash-sale · high confidence

A new full-stack reference project has been added to the samples directory, demonstrating over 90% of the framework's capabilities. This sample implements a hotel booking system using Domain-Driven Design, CQRS, and Event Sourcing, featuring event-sourced and state-stored aggregates, snapshots, multiple projections with wired view stores, cross-aggregate sagas, and standalone handlers. It utilizes Fastify for the HTTP layer and Drizzle with PostgreSQL for persistence, including specific schema creation for events, aggregate states, saga states, snapshots, and typed view tables.

samples/sample-hotel-booking/src · high confidence

The core infrastructure layer now exposes standardized interfaces to manage component lifecycles and external dependencies: \Closeable\ and \BackgroundProcess\ enable graceful shutdown with resource draining, while \Connectable\ and \BrokerResilience\ define connection and retry behaviors for message brokers and databases. Additionally, \FrameworkInfrastructure\ injects a configurable \Logger\ and \CQRSInfrastructure\ provides access to command, query, and event buses, while the \Instrumentation\ interface (with a \NoopInstrumentation\ default) offers a transport-agnostic tracing abstraction for distributed context propagation.

packages/core/src/infrastructure · high confidence

The Prisma adapter has been restructured to support dedicated per-aggregate state tables alongside the existing shared event and state stores. Users can now configure specific aggregates to use their own Prisma models via the new \createPrismaAdapter\ builder API and \PrismaStateMapper\ interface, allowing for typed column persistence instead of opaque JSON storage. Additionally, the adapter introduces \PrismaAdvisoryLocker\ for pessimistic concurrency control, which safely manages database advisory locks for PostgreSQL, MySQL, and MariaDB by enforcing session affinity through a single-connection client.

packages/adapters/prisma/src · high confidence

The TypeORM adapter package now emits both CommonJS and ESM bundles via tsup, ensuring compatibility with modern module resolution. Additionally, it introduces \`createNodddeEntities(

packages/adapters/typeorm · high confidence

The TypeORM adapter introduces a builder API (\createTypeORMAdapter\) that allows configuring dedicated, per-aggregate state tables with type-safe mappers, enabling more efficient state storage than the previous shared table approach. It also adds an \EventIdempotencyStore\ to prevent duplicate event processing and a dialect-aware \AdvisoryLocker\ for PostgreSQL, MySQL, and MSSQL to support pessimistic concurrency control. Comprehensive integration tests verify these capabilities across all supported database engines.

packages/adapters/typeorm/src · high confidence

The default starter files for the \apps/web\ Next.js application and the \packages/ui\ shared component library have been removed. This deletes the initial page layout, global styles, and public assets (SVGs) that previously rendered the Turborepo welcome screen, as well as the basic \Button\, \Card\, and \Code\ React components and their associated code-generation templates. The web app no longer serves a default UI, and the UI package no longer exports these foundational components.

apps/web, packages/ui · high confidence

The auction sample's domain layer has been reorganized to follow a Decider pattern, separating command handling into explicit 'decide' functions (e.g., \decidePlaceBid\) that validate rules and emit events, and 'evolve' functions that update state. The write-model now exposes \Auction\ aggregate with \decide\ and \evolve\ hooks, while the read-model introduces an \AuctionSummaryProjection\ that builds a summary view from domain events and supports \GetAuctionSummary\ queries. Event schemas are strictly typed (e.g., \BidPlacedPayload\ with \timestamp\), and an upcaster chain handles \BidPlaced\ v1-to-v2 migration for backward compatibility.

samples/sample-auction/src/domain · high confidence

The auction sample has been updated to demonstrate the framework's new inference-preserving defineDomain pattern and multi-dialect adapter support. It now utilizes the Prisma adapter with SQLite for persistence, replacing previous implementations, and showcases a complete workflow including aggregate commands (CreateAuction, PlaceBid, CloseAuction) and projections.

samples/sample-auction/src · high confidence

The Drizzle adapter now includes a full suite of integration and unit tests covering PostgreSQL, MySQL, and SQLite dialects, along with new capabilities like event idempotency storage and advisory locking for pessimistic concurrency. The diff also addresses robustness issues by fixing schema constraints (adding missing primary keys and unique indexes), correcting JSON payload storage to use native JSON/JSONB types instead of double-encoded strings, and ensuring correct timestamp ordering in the outbox store across mixed-format migrations.

packages/adapters/drizzle/src · high confidence

The Drizzle adapter now uses AsyncLocalStorage to prevent cross-transaction contamination in concurrent workloads and fixes saga state loss by adding versioned optimistic concurrency to saga persistence. Shipped database schemas now include required composite primary keys to prevent silent row duplication, and JSON columns no longer double-encode payloads, though existing databases require a one-time migration to fix double-encoded data. The adapter also introduces \DrizzleEventIdempotencyStore\ for deduplicating event handler invocations under at-least-once delivery, adds an \EventReader\ for projection rebuilding, and improves advisory lock safety on pooled connections. Additionally, timestamp columns now use a portable string format, and outbox updates are optimized via indexed event IDs.

packages/adapters/drizzle · high confidence

The shared ESLint configuration now includes type-aware linting rules via @typescript-eslint/recommended-type-checked for TypeScript files, with specific rules like no-floating-promises enabled and unsafe-any checks temporarily disabled to avoid blocking CI. It also adds a no-console error rule and ignores tsup.config.ts and coverage/ directories. Additionally, the package no longer exports the previous Next.js and React-internal configurations, which have been removed.

packages/eslint-config · high confidence

The \@noddde/engine\ package is now available as a distinct runtime layer, separating the domain orchestration and in-memory infrastructure implementations from the core type definitions. This release (1.0.0-rc.2) introduces significant behavioral changes to improve reliability and correctness: the projection rebuild process now correctly applies event upcasters to prevent data corruption, and the OutboxRelay is protected against transient database failures that previously caused unhandled promise rejections. Additionally, pessimistic locks are now held until the owning unit of work commits, preventing stale state reads, and the domain shutdown process no longer leaves dangling timers. The package ships with dual CJS/ESM builds, in-memory implementations for all infrastructure contracts, and updated peer dependency ranges for adapters like Drizzle, TypeORM, and Prisma.

packages/engine · high confidence

The Kafka event bus adapter introduces an explicit \warmup()\ method and a \warmupOnConnect\ configuration option to absorb broker cold-start latency (topic auto-creation, leader election) before real traffic flows, ensuring predictable first-message delivery times. Additionally, the adapter now automatically provisions event topics at connection time with configurable partition and replication settings, and implements a dead-letter queue (DLQ) mechanism for messages that exhaust retries or fail to parse, preventing head-of-line blocking and silent data loss. These changes are accompanied by stricter subscription management (throwing on late topic subscriptions) and dual CJS/ESM build output.

packages/adapters/kafka · high confidence

The NATS adapter now enforces stricter configuration and improves reliability: the \subjectPrefix\ is required when \streamName\ is set to prevent unintended subject wildcards, and subscriptions use a durable queue group to allow multiple service replicas to compete for messages without crashing. Message processing is more robust with capped exponential backoff on retries and exhausted messages being sent to a dead-letter queue instead of being silently dropped. Additionally, duplicate subscriptions for the same event name are now prevented, and the adapter ships with dual CJS/ESM builds and updated documentation.

packages/adapters/nats · high confidence

The engine now uses dedicated \CommandLifecycleExecutor\ and \SagaExecutor\ classes to manage command and saga lifecycles. Commands gain idempotency support via an optional \IdempotencyStore\ that skips duplicate \commandId\s, and saga execution now supports configurable atomicity (\atomic\ vs \best-effort\) to control whether saga state persistence and reaction command dispatch happen in a single transaction or separately. Both executors integrate with OpenTelemetry for trace context propagation (including W3C Trace Context injection and restoration) and use a \MetadataEnricher\ to compute correlation IDs once per event batch, ensuring consistent tracing across events produced by a single command or saga step.

packages/engine/src/executors · high confidence

The pre-commit hook has been updated to run the full project linting and formatting checks on every commit, rather than only staging changed files. This ensures consistent code style and quality across the entire codebase before each commit is finalized.

.husky · high confidence

The Prisma persistence adapter now uses AsyncLocalStorage for transaction management to prevent cross-transaction contamination during concurrent commits, and introduces \PrismaAdvisoryLocker.fromUrl\ to ensure advisory locks are acquired and released on the same database session, preventing lock leaks. Saga persistence now correctly implements optimistic concurrency control with version checking, fixing silent state loss in multi-step sagas. A new \PrismaEventIdempotencyStore\ is added to deduplicate event handler invocations under at-least-once delivery. Additionally, the outbox gains an indexed \eventId\ column to optimize published-event marking, and the CLI scaffold is fixed to generate compilable code with correct dependency versions and payload structures.

packages/adapters/prisma · high confidence

The RabbitMQ event bus adapter now immediately throws a clear error if the configured \exchangeType\ does not match an existing exchange on the broker, rather than failing silently or with a generic \PRECONDITION\_FAILED\ exception. This change ensures that configuration mismatches are detected early during connection or reconnection, preventing subtle deployment issues where the wrong exchange type is used.

packages/adapters/rabbitmq · high confidence

The core domain definition API has been redesigned to use a typed, object-based configuration model. Aggregates now follow the Decider pattern, using \decide\ and \evolve\ maps instead of the previous \commands\ and \apply\ structure, and are defined via \defineAggregate\. Projections and Sagas are similarly defined via \defineProjection\ and \defineSaga\, with Sagas introducing an optional \atomicity\ mode (\atomic\ or \best-effort\) to control transactional coupling. A new \defineDomain\ function allows users to bundle aggregates, projections, sagas, and standalone handlers into a single \DomainDefinition\ for type-safe wiring. The API also introduces \AggregateTypes\, \ProjectionTypes\, and \SagaTypes\ bundles to simplify generic type inference, and adds support for view deletion in projections via a \DeleteView\ sentinel.

packages/core/src/ddd · high confidence

The sample applications now expose explicit infrastructure contracts to support consistent dependency injection and testing. The auction sample defines a \Clock\ interface and \SystemClock\ implementation, allowing time-based bid validation to be controlled (e.g., for testing), while the flash-sale sample aligns its infrastructure type with the core \Infrastructure\ base, ensuring uniform integration patterns across samples.

samples/sample-auction/src/infrastructure, samples/sample-flash-sale/src/infrastructure · high confidence

This change introduces three new scripts to improve release hygiene and documentation integrity. \check-spec-docs-links.mjs\ validates that spec frontmatter references point to existing documentation pages, failing CI on broken links. \check-spec-status-drift.mjs\ detects specs marked as 'draft' or 'ready' when their source code is already shipped and tested, ensuring lifecycle statuses remain accurate. \copy-license.mjs\ ensures the MIT license file is copied into every published package directory before publishing, guaranteeing that all distributed tarballs include the correct license text.

scripts · high confidence

Resolves robustness issues in the Prisma-based database adapters for PostgreSQL and MySQL where advisory locks could leak or fail due to Prisma's connection pool multiplexing queries across different connections. The new advisory locker implementations now track held locks locally and detect when an acquire and release land on different pool connections, throwing a clear error instead of silently failing or leaking resources. Users should ensure they configure their Prisma client with a pinned connection (connection\_limit=1) or use the provided factory methods to avoid these multiplexing issues.

packages/adapters/prisma/src/pg · high confidence

Add Prisma integration schemas for MySQL and PostgreSQL; Added comprehensive test coverage for Prisma adapter components; Added comprehensive test coverage for the engine core; Added comprehensive test suite for FlashSaleItem domain logic; Added comprehensive test suite for the sample auction domain; Added comprehensive type-level tests for core DDD primitives; Added contract tests for in-memory persistence implementations; Added integration and slice tests for the hotel-booking sample; Added integration tests for Kafka event bus; Added integration tests for NATS event bus resilience and multi-instance delivery; Added integration tests for Prisma adapter across MySQL, PostgreSQL, and SQLite; Added integration tests for RabbitMQ event bus reliability and broker-specific behavior; Added integration tests for engine core capabilities; Added spec audit and build reports for core infrastructure changes; Added test coverage for core infrastructure interfaces and utilities; Added test harnesses for aggregates, sagas, projections, and domain testing; Added tests for CLI domain diagram and code generation features; Added tests for engine executors and metadata enrichment; Added tests for engine implementation components; Added tests for persistence core interfaces and utilities; Added type and runtime tests for core EDD primitives; Added type-level tests for CQRS core APIs; Added type-system stress tests for core and engine packages; Added unit tests for KafkaEventBus; Added unit tests for the NATS event bus adapter; New @noddde/testing package with domain and unit test harnesses; New integration testing infrastructure for adapter validation.

The project has switched its package manager from pnpm to yarn (v1.22.19) and updated the minimum Node.js version to 22. This change includes upgrading Turborepo from v1.12.1 to v2.9.3, introducing Changesets for versioning, and adding Husky with lint-staged for pre-commit hooks. The monorepo structure has been reorganized: the previous \apps/\ and \packages/ui/\ directories were removed, and new packages were added for the CLI (\@noddde/cli\), core engine (\@noddde/engine\), and various adapters (Drizzle, Prisma, TypeORM, Kafka, NATS, RabbitMQ). The documentation site was also updated to use Next.js 16 and Fumadocs.

(dependencies) · high confidence

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

• CAI 54 → 65 (+11.0)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 93 → 84 (-8.8)
• Architecture 95 → 87 (-8.5)
• Maturity 70 → 80 (+10.0)
• Readiness 43 → 55 (+12.1)
• Security 50 → 73 (+23.2)
• Accessibility 71 → 71 (+0.0)

• Change coupling clique: ee-event-bus.ts, in-memory-aggregate-persistence.ts, in-memory-command-bus.ts (packages/engine/src/implementations/ee-event-bus.ts)
• Change coupling clique: index.ts, index.ts, index.ts (packages/adapters/drizzle/src/index.ts)
• Change coupling clique: schema.ts, persistence.ts, persistence.ts (packages/adapters/drizzle/src/mysql/schema.ts)
• Change coupling: aggregate-root.ts ↔ event-handler.ts (packages/core/src/ddd/aggregate-root.ts)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (yarn.lock)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• High CVE: [GHSA redacted] (yarn.lock)
• …and 72 more

• Change coupling: command-lifecycle-executor.ts ↔ saga-executor.ts (packages/engine/src/executors/command-lifecycle-executor.ts)
• ClassTooLong: Domain (packages/engine/src/domain.ts)
• CommandLifecycleExecutor.execute (cognitive 36) (packages/engine/src/executors/command-lifecycle-executor.ts)
• CommandLifecycleExecutor.execute (cyclomatic 19) (packages/engine/src/executors/command-lifecycle-executor.ts)
• CommandLifecycleExecutor.executeLifecycle (cognitive 29) (packages/engine/src/executors/command-lifecycle-executor.ts)
• CommandLifecycleExecutor.executeLifecycle (cyclomatic 22) (packages/engine/src/executors/command-lifecycle-executor.ts)
• Coverage not measured — JavaScript/TypeScript suite
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical vulnerability: [GHSA redacted] (yarn.lock)
• Documentation: no architecture or design documentation (packages/core/README.md)
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no installation or build instructions (docs/public/llms.txt)
• Documentation: no usage examples (README.md)
• Documentation: no usage examples (docs/public/llms.txt)
• Domain.init (cognitive 228) (packages/engine/src/domain.ts)
• Domain.init (cyclomatic 113) (packages/engine/src/domain.ts)
• Domain.rebuildProjection (cognitive 23) (packages/engine/src/domain.ts)
• Domain.rebuildProjection (cyclomatic 18) (packages/engine/src/domain.ts)
• FunctionTooLong: entities.buildEntities (packages/adapters/typeorm/src/entities.ts)
• …and 468 more

• 42 commits — 21 feature/other, 21 fixes

• (repo) — 18 commits
• packages/adapters — 8 commits
• packages/cli — 4 commits
• .changeset/kafka-consumer-crash-restart.md — 2 commits
• packages/core — 2 commits
• packages/engine — 2 commits
• specs/core — 2 commits
• packages/integrations — 1 commit
• packages/testing-integration — 1 commit
• scripts/check-spec-docs-links.mjs — 1 commit
• specs/api-freeze.spec.md — 1 commit

• fix: fix(adapters): fix CI failures from phase 1 GA fixes
• fix: fix(adapters): harden SQL adapter concurrency, schemas, and capability gaps
• fix: fix(ci): make the test/lint dashboard actually mean something (#140)
• fix: fix(ci): raise prisma hookTimeout and normalize -0 in fast-check payloads
• fix: fix(cli): add required queuePrefix to rabbitmq scaffold template
• fix: fix(cli): add required queuePrefix to rabbitmq scaffold template
• fix: fix(cli): add required queuePrefix to rabbitmq wiring template
• fix: fix(cli,release): repair scaffold golden path and GA release hygiene
• fix: fix(engine): harden aggregate/saga lifecycle reliability paths (#132, #133)
• fix: fix(engine): repair OTelInstrumentation import broken by rename
• fix: fix(kafka): mark handler-failure errors retriable so kafkajs actually restarts the crashed consumer
• fix: fix(kafka): restart crashed consumer so handler failures actually redeliver
• fix: fix(messaging): multi-instance delivery, poison-message handling, default-config safety (#134, #135)
• fix: fix(nestjs): propagate metadata context through the ALS scope and harden the public API
• fix: fix(prisma): add missing child() to Logger test mock after merge
• fix: fix(specs): bump 8 shipped/tested modules from ready to implemented
• fix: fix(specs): remap ~56 dangling docs: frontmatter paths after docs-site reorg
• fix: fix(specs): resolve outbox-relay contradiction, add spec-hygiene CI guards
• fix: fix(testing-integration): normalize -0 in JSON payload roundtrip property test
• fix: fix: conform DrizzleSagaPersistence to the SagaPersistence contract
• …and 22 more

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

dogganidhal/noddde 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.