equinox-project/equinox-js

This system is an event-sourcing framework called Equinox, designed to simplify the construction of domain-driven applications with persistent state management. It provides a core library for handling streams, codecs, and deciders, supported by pluggable storage backends including PostgreSQL (MessageDB), Amazon DynamoDB, libSQL, and in-memory stores. The repository also includes example applications demonstrating HTTP APIs, background processing, and complex process managers, alongside a visualization tool for exploring event data.

31 changes.

The project was restructured into an Equinox JS monorepo, introducing a comprehensive event sourcing library with support for multiple storage backends including PostgreSQL, DynamoDB, and in-memory stores. This period focused on building out the core domain models, stream processing infrastructure, and visualization tools to support scalable event-sourced applications.

5 changes.

This period focused on establishing core database schemas and persistence layers, including a new message store, libSQL support, and memory store testing. It also introduced example applications demonstrating the framework's capabilities, such as a hotel group checkout process manager and database migration scripts for the example app.

The message-db-consumer package now includes the core source implementation for consuming from MessageDB. This adds a new MessageDbSource class that reads from specified categories, supports consumer group partitioning, and manages checkpoints via a PgCheckpoints implementation backed by PostgreSQL. The change introduces the ability to stream timeline events from MessageDB into a sink, with configurable batch sizes, tail sleep intervals, and checkpoint intervals.

packages/message-db/message-db-consumer/src · high confidence

A new file, explorer-config.ts, has been added to the example application. This file defines a configuration array that registers three domain entities—Invoice, Payer, and InvoiceAutoEmailer—each with their respective stream categories, event codecs, and fold modules. This change enables the example app to expose these specific explorers, likely allowing users to view and interact with data from these domains within the application's UI.

apps/example/src · high confidence

A new configuration file at apps/example/src/config/equinox.ts introduces factory functions for setting up three different storage backends: MemoryStore, MessageDB, and DynamoDB. Each backend provides methods to create cached, unoptimized, latest-known, and snapshotted category instances, allowing the example app to demonstrate various state management strategies across different data stores.

apps/example/src/config · medium confidence

The example application now includes entrypoints for an HTTP server (applying CRUD operations for Payers and Invoices), a background reaction handler that processes events from either a PostgreSQL-based message store or a DynamoDB store, and OpenTelemetry-based tracing instrumentation for HTTP, Express, and database calls.

apps/example/src/entrypoints · high confidence

Introduces a new 'hotel' application that demonstrates a Reactor/Process Manager pattern for managing group checkouts. The change adds domain models for 'GroupCheckout' and 'GuestStay' aggregates, along with a 'GroupCheckoutProcessor' that drives the reactive processing of events. It includes configuration for multiple storage backends (Memory, MessageDB, DynamoDB) and infrastructure definitions for AWS CDK. The entry also adds integration tests that verify the end-to-end scenario of merging stays into a group checkout, handling payments, and confirming the group. This serves as a concrete example of implementing a Reactor using the Equinox framework.

apps/hotel · high confidence

Introduces a new libSQL-based implementation for the event store, including database schema initialization, read/write clients, and context management. This enables the application to persist and retrieve domain events using libSQL, supporting features like snapshotting, rolling state, and batched loading with configurable batch sizes and tracing.

packages/libsql · high confidence

A new \test-domain\ package has been introduced, providing domain models for a shopping Cart and user ContactPreferences. The Cart model supports adding, removing, and updating items, while the ContactPreferences model manages user communication settings. Both are implemented using the Equinox library for event sourcing, exposing a Service class to handle commands and queries.

packages/test-domain · high confidence

Two new k6 benchmarking scripts have been added to the k6-bench directory: payer-create.js, which simulates PUT requests to the /payer endpoint with randomized IDs and names, and raise-invoice.js, which simulates POST requests to the /invoice endpoint. Both scripts are configured with 80 virtual users over a 20-second duration, enabling load testing for these specific API endpoints.

k6-bench · high confidence

The message-store database schema is established with a new \message\_store\ schema, a \messages\ table, and supporting database objects. This includes a \message\ composite type, utility functions for hashing and ID extraction, and core business logic functions for writing messages, retrieving stream and category-based messages, and managing locks. The migration also creates indexes for efficient querying by category, ID, and stream, as well as several summary views for analytics. Finally, all necessary privileges are granted to the \message\_store\ role.

packages/message-db/message-db/migrations · high confidence

A new CDK construct library, @equinox-js/dynamo-store-cdk, is introduced to provision DynamoDB tables and an associated Lambda indexer. Users can now deploy a pre-configured stack that creates an events table and an index table with specified billing modes, alongside a Lambda function that processes table streams with a configurable batch size. The package includes standard TypeScript configuration, gitignore rules, and usage documentation.

packages/dynamo-store/cdk · high confidence

Adds a new \DynamoStore\ implementation that persists domain events and state snapshots to Amazon DynamoDB. The module exposes the store via \index.ts\, enabling the application to use DynamoDB as a durable, scalable backend for event sourcing and state management.

packages/dynamo-store/dynamo-store/src · high confidence

The \packages/dynamo-store/source\ package now provides a new \DynamoStoreSource\ implementation that reads from a DynamoDB-based event store, supporting both index-only and data-hydrated read modes. It introduces a \DynamoCheckpoints\ class to manage stream positions and supports configurable checkpointing intervals. The source allows consumers to process events from DynamoDB, with options to load event bodies and metadata in parallel. Tests confirm correct batching, fast failure on errors, and proper handling of both compressed and raw event bodies.

packages/dynamo-store/source · high confidence

This change adds the DynamoStore indexer package, which provides the core logic for ingesting and managing stream data. It includes the \DynamoStoreIndexer\ and \DynamoStoreIngester\ classes that handle exactly-once ingestion, epoch management, and state folding. The package also introduces a CLI tool (\dynamostore-cli\) with commands to read from DynamoDB streams and create DynamoDB tables for indexing. Additionally, a Lambda handler is added to process DynamoDB stream events and forward them to the indexer.

packages/dynamo-store/indexer · high confidence

Adds a new interactive tool for visualizing and exploring the event store. The package includes a CLI interface, a web-based UI with pages for the main dashboard, individual streams, categories, and correlation trees, along with supporting components for charts, tables, and navigation. The diff also includes a fix for scrolling behavior on the stream page.

packages/explorer · high confidence

The MessageDB module now provides a complete persistence implementation backed by PostgreSQL, featuring a new \MessageDbContext\ for managing read/write operations and an \AccessStrategy\ system that allows users to choose between unoptimized, latest-known-event, or adjacent-snapshot read strategies. The implementation includes optimized batch loading, snapshot storage and decoding, and token management, enabling more efficient state reconstruction and synchronization for event-sourced aggregates.

packages/message-db/message-db/src · high confidence

The Propeller package is introduced, providing core infrastructure for processing streams of timeline events. This includes a \TailingFeedSource\ for polling and emitting batches, a \StreamsSink\ for managing concurrent stream processing with configurable concurrency limits, and a \CheckpointWriter\ that asynchronously commits read positions to a \MemoryCheckpoints\ store. The library also adds a \Stats\ class for emitting metrics and a \BatchLimiter\ to control in-flight batch counts, along with tracing support for handlers.

packages/propeller · high confidence

Adds a new \VolatileStore\ and \MemoryStoreCategory\ in the \packages/memory-store\ package, providing an in-memory implementation of the Equinox store interface. This allows users to utilize a non-persistent, volatile storage backend for testing or ephemeral scenarios, supporting stream sync, load, and reload operations via the standard Equinox category API.

packages/memory-store/src · high confidence

Added new domain modules for managing invoices and payers, including state machines, event codecs, and deciders. The invoice module now supports raising invoices, recording payments, and finalizing them. A new invoice-auto-emailer module automatically sends emails when invoices are raised, using a configurable email sender. Payer management includes updating profiles and deleting payers. A read model for payers is also added to project payer state to a database.

apps/example/src/domain · high confidence

A new \projection-pg\ package has been added, providing a PostgreSQL implementation for handling data projections. The module exposes a \createHandler\ function that accepts a projection configuration and returns a handler capable of collapsing and executing SQL operations (insert, update, delete, upsert) against a PostgreSQL database. The implementation includes utilities for safe identifier quoting and type definitions for change actions, enabling users to build efficient database projections without relying on external query builders.

packages/projection-pg/src · high confidence

The \message-db\ package's internal implementation files (Caching, Category, MessageDbClient, Read, Snapshot, Token, and Write) have been deleted. This removes the previous database access layer, likely as part of a migration to a new architecture or a different database provider.

packages/message-db/src/lib · high confidence

The example application now includes three new database migrations: 0001-users.sql creates the 'equinox\_example' role and configures its search path; 0002-payer.sql creates the 'payer' table with specific columns and grants permissions; 0003-checkpoints.sql creates the 'eqx\_checkpoint' table for tracking positions and grants permissions to the example role.

apps/example/migrations · medium confidence

The example app now includes environment configuration for database connections (DBURL, DBURL\_RO, DBURL\_ADMIN) and a .gitignore file. Additionally, the TypeScript configuration has been moved from a shared location to the app's root, and the compilation target has been upgraded from ES2020 to ES2022, with module resolution and output settings updated to 'nodenext'.

apps/example · medium confidence

A new bootstrap script has been added to automate database creation and migration for the message store, example app, and hotel app, streamlining the initial setup process. Additionally, a new versioning script was introduced to update version numbers across all packages in the packages directory, simplifying version management.

scripts · high confidence

The project has been rebranded and restructured as a JS port of the Equinox library, replacing the previous Turborepo starter template. This change includes updating the README to reflect the new identity and purpose, adding a CONTRIBUTING.md guide, and configuring the monorepo to support both build and test tasks via Turbo. The pnpm workspace configuration has been expanded to include apps and docs directories, and the Turbo pipeline now targets .svelte-kit/ outputs instead of .next/. Additionally, environment variables for database connections (PostgreSQL, DynamoDB) and local development tools (direnv, nvmrc) have been standardized to support the new architecture.

(repo-wide) · high confidence

The core library has been refactored to introduce a new caching strategy via the \Cache\ and \CachingCategory\ classes, which support configurable staleness and leader requirements. A new \Codec\ module provides JSON, upcast, and compression (brotli/deflate) capabilities, replacing the previous \Codec\ type with a more flexible interface. Stream identification is now handled by the \StreamId\ and \StreamName\ modules, which enforce validation and composition rules. The \Core\ module has been updated to use \TokenAndState\ instead of \StateTuple\, and tracing has been improved with specific tags for cache hits, staleness, and load methods. The \Decider\ class now supports returning stream versions and has been renamed to \forStream\. These changes provide a more robust and observable core for building event-sourced applications.

packages/core/src · high confidence

The top-level re-export of the Category module from the message-db package has been removed. This change aligns the package's public API with the project's migration to ESM, ensuring that consumers no longer access the Category export through the main entry point.

packages/message-db/src · high confidence

The pre-compiled JavaScript and TypeScript declaration files for the message-db package have been removed from the distribution directory. This eliminates the bundled implementation of the message database layer, which previously exposed classes for reading and writing events to a PostgreSQL database.

packages/message-db/dist · high confidence

Added comprehensive test coverage for core modules; Added comprehensive test suite for DynamoDB store implementation; Added domain tests for invoice, payer, and emailer logic; Added tests for MessageDB snapshot version handling and round-trip operations; Added tests for PayerReadModel; Added tests for memory-store transactVersion behavior; Added tests for message-db consumer components; Added tests for projection-pg change collapsing and view data handling.

The project has been updated to use pnpm 10.33.0 (up from 7.18.2) and upgraded TypeScript to 5.3.3. Development tooling has been modernized with Vitest 4.1.1 and esbuild 0.27.4. Additionally, the \tsconfig\ package was removed, and the \message-db\ package was renamed to \test-domain\.

(dependencies) · medium confidence

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

• CAI 50 → 52 (+1.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 94 → 75 (-19.1)
• Architecture 100 → 67 (-32.5)
• Maturity 66 → 64 (-1.9)
• Readiness 35 → 35 (-0.2)
• Security 43 → 70 (+27.8)

• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• …and 44 more

• Coverage not measured — JavaScript/TypeScript suite
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Critical CVE: [GHSA redacted] (pnpm-lock.yaml)
• Handler.parse (cognitive 31) (packages/dynamo-store/lambda/src/Handler.ts)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• …and 104 more

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

equinox-project/equinox-js 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.