reimagined/resolve

This system is the reSolve framework, an event-sourcing and CQRS platform for building scalable web applications. It provides a modular runtime that manages aggregates, read models, and sagas, supported by adapters for various event stores (PostgreSQL, MySQL, SQLite) and read models. The framework includes comprehensive tooling for scaffolding projects, testing domain logic, and deploying to environments like AWS Serverless, along with client-side libraries for React and Redux integration.

Introduces a new Angular 8 TypeScript template for the reSolve framework, providing a complete starter project structure. This includes the Angular client application (AppComponent, AppModule, and entry point), configuration files for development, production, and cloud deployment (using @resolve-js/runtime-single-process and @resolve-js/runtime-aws-serverless), and an end-to-end test suite using TestCafe. The template also sets up necessary build tooling via Babel and Webpack (with @ngtools/webpack) and TypeScript configurations to support the Angular environment.

templates/ts/angular · high confidence

Introduces a complete Hacker News clone example built with reSolve, featuring user authentication (login/register with JWT), story submission, upvoting with optimistic UI updates, and a threaded comment system with real-time notifications. The client-side implementation uses React, Redux, and Redux-Saga for state management and side effects, while the server-side leverages CQRS and Event Sourcing patterns.

examples/js/hacker-news · high confidence

New project templates are now available for applications using PostCSS (with CSS Modules) and Vue.js. These templates provide pre-configured build pipelines, including Webpack adjustments for CSS processing and Vue loader integration, along with environment-specific configurations for development, production, and cloud deployment, enabling users to scaffold new projects with these frameworks out of the box.

templates/js/postcss · high confidence

Introduces a new TypeScript-based example template that demonstrates how to integrate PostCSS with CSS modules in a reSolve application. This template includes a complete client-side setup with React components, server-side rendering (SSR) configuration, and Webpack adjustments to process CSS files using postcss-loader and autoprefixer. It also provides configuration files for development, production, and cloud deployment environments, along with a Jest configuration for testing.

templates/ts/postcss · high confidence

Added a new benchmark suite in the \benchmarks/eventstore\ directory to measure the performance of the PostgreSQL event store adapter. The suite includes scripts for saving events (\save-event.ts\), loading events with filters (\load-events.ts\), and parallel save/load operations (\parallel-save.ts\), along with utility functions (\utils.ts\) to create and manage the PostgreSQL database schema. An example specification file (\event-spec.example.json\) is provided to configure event distributions for the save benchmarks.

benchmarks/eventstore · high confidence

Introduces a new Vue.js client template for the Resolve framework, featuring server-side rendering (SSR) and Bootstrap-Vue for UI components. The template includes a complete build configuration using Webpack and Babel to support TypeScript and Vue Single-File Components, along with environment-specific runtime configurations for development, production, and AWS Serverless deployment. It also provides end-to-end testing via TestCafe to verify static asset resolution and UI rendering.

templates/ts/vue · high confidence

The functional test application now includes a dedicated routing configuration and a React context provider to support specific test scenarios. A new \UploaderContext\ is introduced to manage uploader state, while \routes.js\ defines navigation paths for the Counter, Client Middleware, Secrets Manager, and File Uploader components, enabling these features to be tested via the browser UI.

functional-tests/app/client/hooks · high confidence

The shopping-list example now includes a complete set of React components for the client-side UI. This adds an App shell with a Header (using react-bootstrap and react-helmet for styling and metadata), a MyLists view for browsing and creating lists, a ShoppingList view for managing individual items (adding, renaming, removing), and supporting components like ShoppingListItem, ShoppingListCreator, ShoppingListRemover, and a NotFound page. These components use @resolve-js/react-hooks for data fetching and command execution, enabling users to interact with the shopping list feature directly in the browser.

examples/js/shopping-list/client/components · high confidence

The client-side code for the styled-components template has been added, providing a complete React application structure. This includes an entry point and server-side rendering (SSR) handler that integrates styled-components for server-side style extraction, react-helmet for managing document head tags, and react-bootstrap for UI components. The template also features a Header container and a StaticImage component that utilize @resolve-js/react-hooks to resolve static asset paths, ensuring correct resource loading in both client and server environments.

templates/js/styled-components/client · high confidence

The functional test application now includes the Bootstrap v3.3.7 minified CSS file, providing standard styling for the test UI components.

functional-tests/app/static · high confidence

The templates/js/postcss/client directory now includes a complete React-based client application demonstrating PostCSS module integration. This includes an entry point (index.js) and server-side rendering handler (ssr.js) that render routes using react-router-config and resolve-js hooks. The app features a Header container for navigation and metadata, a StaticImage component for resolving static assets, and a PostCSS component showcasing scoped CSS styling. Route configuration is provided via get-routes.js, linking the App component to the PostCSS view.

templates/js/postcss/client · high confidence

The project now includes a new Vue.js-based client template located in templates/js/vue/client. This addition introduces a client entry point (index.js) that initializes a Vue application using BootstrapVue, and a server-side rendering entry point (ssr.js) that renders the Vue app on the server and serves the resulting HTML with necessary static assets like CSS and JavaScript bundles. The App.vue component provides a basic navigation bar with links to Resolve's social media and documentation.

templates/js/vue/client · high confidence

New client entry points and server-side rendering (SSR) markup handlers have been added to support functional testing of different Redux integration patterns. The entry points include \index.js\ for React hooks, \index-hoc.js\ for Higher-Order Components, and \index-redux-hooks.js\ for Redux hooks, each configuring the appropriate routing and store providers. Corresponding SSR handlers (\ssr-hoc.js\, \ssr-redux-hooks.js\) generate the initial HTML markup, injecting necessary runtime environments and entry point scripts to facilitate testing of these specific client-side rendering flows.

functional-tests/app/client · high confidence

The React common template now includes a complete set of generated files to support a sample 'my-aggregate' domain model. This adds command handlers for creating, deleting, and managing items, along with corresponding event types and state projections. It also introduces a read-model projection that persists aggregate data to a store and exposes it via resolvers, as well as a view-model projection for tracking individual items, providing a functional starting point for building React-based event-sourced applications.

templates/js/react/common · high confidence

A new static stylesheet (style.css) has been added to the vanilla JavaScript template location, providing the visual presentation for the chat application. This includes layout rules for the main container, alternating background colors for message rows, and specific formatting for usernames and input fields, ensuring the interface renders correctly with the intended design.

templates/js/vanilla/static · high confidence

A new executable script at internal/cra-test/bin/index.js has been added to automate testing of the create-resolve-app templates. This tool allows users to run unit and end-to-end tests for JavaScript or TypeScript examples (or all of them) by generating temporary projects, executing the create-resolve-app generator, and running the associated test suites.

internal/cra-test · high confidence

The \common\ directories for the \shopping-list\, \shopping-list-redux\, and \shopping-list-redux-hoc\ examples now include shared event type definitions and projection logic. This adds the \event-types.js\ file defining events like \SHOPPING\_LIST\_CREATED\ and \SHOPPING\_ITEM\_TOGGLED\, along with \aggregates/shopping-list.projection.js\ for aggregate state, \read-models/shopping-lists.projection.js\ for database persistence, and \view-models/shopping-list.projection.js\ for UI state management.

examples/js/shopping-list-redux-hoc/common, examples/js/shopping-list-redux/common, examples/js/shopping-list/common · high confidence

The TypeScript Hacker News example now includes a Dockerfile and associated configuration files (such as .babelrc and .gitignore), enabling users to build and run the application inside a containerized environment. This addition provides a standardized way to deploy the example, exposing port 3000 and utilizing a multi-stage build process to optimize the final image size.

examples/ts/hacker-news · high confidence

This change introduces a new default React-based template for generating reSolve applications. It provides a complete project structure including Babel configuration for JSX and modern JavaScript, environment-specific settings for development, production, and cloud deployment, and a CLI entry point to manage building, running, and testing the application.

templates/js/react · high confidence

The @resolve-js/module-admin package is introduced, providing a CLI tool and API handlers to manage reSolve application components. Users can now install and register the module to control sagas, read models, and the event store via commands such as resetting read models, pausing/resuming sagas, and importing/exporting event store data.

packages/modules/module-admin · high confidence

The @resolve-js/runtime-base package has been added as a foundational component for reSolve runtimes. It includes a README, TypeScript configuration targeting ES2020 with CommonJS modules, and type declarations for Babel runtime helpers to support the runtime's internal dependencies.

packages/runtime/runtimes/runtime-base · high confidence

The \@resolve-js/eventstore-postgresql\ package is introduced, providing an adapter to store events in PostgreSQL 10.7. This addition includes the necessary TypeScript configuration (targeting ES2020) and type declarations for the \pg-cursor\ library to support event loading. Users can now configure the adapter with standard database connection parameters such as host, port, user, password, and specific schema/table names.

packages/runtime/adapters/eventstore-adapters/eventstore-postgresql · high confidence

The @resolve-js/client package has been initialized with its core build and test infrastructure. This includes a README describing the low-level client API for communicating with a reSolve server, a .gitignore to exclude build artifacts (lib, types, .d.ts), a Jest functional test configuration, and TypeScript configurations (tsconfig.json and tsconfig.prod.json) that set up compilation to ES2015 CommonJS, enable declaration file generation, and establish project references to the core package.

packages/core/client · high confidence

The \@resolve-js/module-auth\ package is now available, providing out-of-the-box support for Passport-compatible authentication strategies. This module allows applications to configure authentication strategies (such as local login and registration) and defines the necessary API routes for login, registration, and logout. It handles the execution of authentication strategies, manages JWT token issuance and cookie-based session management, and supports custom error handling and redirection logic. The implementation includes a comprehensive README with usage examples and TypeScript definitions to guide integration.

packages/modules/module-auth · high confidence

The new @resolve-js/module-uploader module provides server-side API handlers and client-side utilities to facilitate secure file uploads via CDN. It exposes three GET endpoints—/api/uploader/getFormUpload, /api/uploader/getUploadUrl, and /api/uploader/getToken—which generate signed POST and PUT requests for direct browser uploads. The module enforces security by validating JWT tokens for upload URLs and restricting token generation to a configurable list of public directories, while client helpers simplify the integration of these signed URLs into the application.

packages/modules/module-uploader · high confidence

The \replicator-via-api-handler\ adapter is now available, enabling read models to be built by replicating events from a remote application via HTTP API calls instead of direct database access. This adapter handles the full replication lifecycle—including locking, pausing, resuming, and status reporting—by communicating with a target application URL, allowing for distributed read model construction where the event store is not directly accessible.

packages/runtime/adapters/replicators/replicator-via-api-handler/src · high confidence

A new executable script at packages/core/create-resolve-app/bin/index.js has been added to serve as the command-line entry point for the create-resolve-app tool. This script initializes source-map-support to ensure accurate stack traces during execution and then delegates to the main application logic in the lib directory, enabling users to run the CLI tool directly from the command line.

packages/core/create-resolve-app/bin · high confidence

Added a new set of internal helper modules to streamline the build process. This includes \getBabelConfig\ to generate Babel configurations for different module types (CJS, ESM, MJS) and targets (server, client), \getCompileConfigs\ to prepare build entries from the package registry, and \patchPackageJson\ to redirect local dependencies to a local registry during development. Additional utilities support repository root detection, example/package resolution, and performance profiling.

internal/helpers · high confidence

This change adds the foundational monitoring adapter system for reSolve, including a base package (\@resolve-js/monitoring-base\) that handles metric collection, aggregation, and dimension management. It introduces a new AWS CloudWatch adapter (\@resolve-js/monitoring-aws-cloudwatch\) that publishes metrics to CloudWatch, supporting deployment and version tracking, and a console adapter (\@resolve-js/monitoring-console\) for local debugging. The CloudWatch adapter enforces specific limits (e.g., 256-character dimension values, 20 metrics per batch) and handles metric normalization and retry logic.

packages/runtime/adapters/monitoring-adapters · high confidence

The single-process runtime now provides a self-contained execution environment that includes an in-memory PubSub manager for local event dispatching, a WebSocket server for reactive subscriptions, and an Express-based HTTP server for API handlers. This change adds the necessary infrastructure for local development and testing, including process cleanup on exit, event subscriber notification via HTTP, and performance tracing, effectively replacing the need for external message brokers in single-process scenarios.

packages/runtime/runtimes/runtime-single-process/src · high confidence

The testing-tools package now provides a dedicated API for testing domain components. Users can utilize the \givenEvents\ entry point to configure test scenarios for aggregates, read models, and sagas. The implementation includes specific types for test events (allowing optional timestamps), contexts for each component type, and utility functions for formatting assertion failures and handling side effects, ensuring clearer error messages and more robust test configurations.

packages/tools/testing-tools/src · high confidence

A new package, @resolve-js/scripts, has been added to provide scripts and configuration utilities for the create-resolve-app tool. This package exposes a set of functions for managing the application lifecycle, including build, start, watch, stop, and test execution (runTestcafe), as well as utilities for merging configurations, resetting state, and handling event store imports and exports. The package also includes TypeScript definitions for its exported members.

packages/tools/scripts · high confidence

The \packages/core/react-hooks\ package now provides a suite of React hooks to interact with the Resolve.js client. This includes \useQuery\ and \useCommand\ for executing queries and commands with support for builders, options, callbacks, and dependency arrays, as well as \useViewModel\ for connecting to and subscribing to view models. Additional utilities include \useClient\ for accessing the underlying client instance, \useStaticResolver\ and \useOriginResolver\ for asset and origin path resolution, and \ResolveProvider\ along with \ResolveContext\ to inject the client context into the React component tree.

packages/core/react-hooks/src · high confidence

The MySQL event store adapter has been implemented, providing a new backend for persisting events, snapshots, secrets, and event subscribers. This change introduces full support for MySQL 8+ as a storage engine, including features like incremental imports, event subscription management, and cursor-based event loading. Users can now configure the adapter to use MySQL for their event sourcing needs, with the adapter handling connection pooling, table initialization, and data serialization.

packages/runtime/adapters/eventstore-adapters/eventstore-mysql/src · high confidence

The new @resolve-js/debug-levels package provides a leveled debug API for reSolve packages, allowing users to control output verbosity via the DEBUG\_LEVEL environment variable (supporting error, warn, log, debug, info, and verbose levels). If DEBUG\LEVEL is not set, the default is 'debug'; if the DEBUG environment variable is absent, the package automatically enables 'resolve:\' namespaces and raises the level to 'log'. The package includes TypeScript configuration for both development and production builds, along with unit tests verifying the environment-variable-driven filtering logic.

packages/core/debug-levels · high confidence

The single-process runtime now exposes new API handlers for exporting and importing the event store (saving events and secrets to files) and for resetting domains (dropping event stores, read models, and sagas). Additionally, the AWS serverless runtime includes new Jest mocks for AWS SDK clients (CloudWatch, IoT Data, Lambda, Step Functions, STS) and Resolve Cloud utilities to support testing.

packages/runtime/runtimes/runtime-aws-serverless/src/\\mocks\\, packages/runtime/runtimes/runtime-single-process/src/api-handlers · high confidence

The module-admin module now exposes a comprehensive set of API handlers and CLI commands to manage the event-broker and event-store. Administrators can pause, resume, and reset read-models and sagas, as well as list their status, success/failure events, and errors. The event-broker also supports managing saga properties (get, set, list, delete). For the event-store, new capabilities include freezing/unfreezing the store, exporting and importing events and secrets to a directory, and performing incremental imports from a file, all supporting manual or auto maintenance modes. A system status endpoint is also available to check application readiness.

packages/modules/module-admin/src · high confidence

The JavaScript React client template has been updated to include a complete, functional UI scaffold. This change introduces a root entry point (\index.js\) that renders the application within a \ResolveProvider\, a main layout component (\App.js\) that configures static assets and navigation, and domain-specific components (\MyAggregateList\ and \MyAggregateItems\) that demonstrate how to interact with aggregates using \@resolve-js/react-hooks\ for querying and command execution.

templates/js/react/client · high confidence

A new TypeScript-based React template has been added to the project, providing a complete starting point for building reSolve applications. This template includes a sample 'MyAggregate' domain with commands, projections, and view models, alongside a React frontend using \@resolve-js/react-hooks\ for state management and command execution. It also provides configuration files for development, production, cloud (AWS Serverless), and testing environments, along with necessary build tooling like Babel, Webpack adjustments, and Jest configurations.

templates/ts/react · high confidence

Added a new TypeScript-based example application demonstrating the use of Redux Higher-Order Components (HOCs) within the ReSolve framework. This example showcases how to manage state using a Redux store with sagas for optimistic UI updates, implement read-models and view-models for data projection, and handle server-side rendering (SSR) with React Router. It includes full client-side and server-side code, configuration for development and production environments, and setup for end-to-end testing with TestCafe.

examples/ts/shopping-list, examples/ts/shopping-list-redux, examples/ts/shopping-list-redux-hoc · high confidence

A new TypeScript-based 'vanilla' example template has been added, demonstrating a real-time chat application using the @resolve-js/client library. The template includes a complete client-side implementation (client/index.ts, init-ui.ts, update-ui.ts) that connects to a Chat aggregate and updates the UI via view-model projections. It provides configuration for development (@resolve-js/runtime-single-process), cloud deployment (@resolve-js/runtime-aws-serverless), and functional testing, along with Webpack adjustments to support TypeScript compilation.

templates/ts/vanilla · high confidence

Added a new TypeScript-based example template that demonstrates integration with Styled Components. This template includes client-side and server-side rendering (SSR) implementations, configuring Babel for TypeScript and React, adjusting Webpack to handle TSX files, and setting up the application structure with React Router and Bootstrap. It provides a complete starting point for building React applications with styled components within the reSolve framework.

templates/ts/styled-components · high confidence

The testing tools now include a new aggregate-based BDD (Behavior-Driven Development) testing API located in \packages/tools/testing-tools/src/flow/aggregate\. This addition introduces a fluent interface for writing tests against aggregates, allowing users to define commands, set authorization tokens via \as\, inject custom secrets managers, and assert outcomes using \shouldProduceEvent\ and \shouldThrow\. The implementation includes core modules for command execution, test environment setup, and assertion handling, providing a structured way to validate aggregate behavior in a BDD style.

packages/tools/testing-tools/src/flow/aggregate · high confidence

A new executable script at internal/build-packages/bin/index.js has been added to automate the creation of local package archives. When run, it iterates through configured package locations, temporarily patches their package.json files, and executes yarn pack to generate tarballs into a local registry directory before restoring the original state.

internal/build-packages · high confidence

This change introduces a comprehensive set of new JavaScript modules in the \packages/tools/scripts/src/alias\ directory that act as build-time resolvers for the Resolve framework's configuration and runtime components. These scripts generate code to import and wire up server-side and client-side assemblies, including aggregates, read models, view models, sagas, middlewares, API handlers, and monitoring adapters. They also handle the resolution of static configuration values like \rootPath\, \staticPath\, \host\, \port\, and \cdnUrl\, ensuring that environment variables and configuration options are correctly injected into the client or server bundles at build time. This provides a standardized way for the framework to resolve its internal dependencies and configuration during the build process.

packages/tools/scripts/src/alias · high confidence

The \packages/core/client/src\ directory now contains a complete, new client runtime library. This introduces a structured HTTP client (\client.ts\, \request.ts\) that supports GET/POST commands and queries, integrated with a middleware pipeline (\middleware/\) featuring built-in retry-on-error and wait-for-response strategies. It also adds a WebSocket-based subscription system (\subscribe.ts\, \subscribe-adapter.ts\) for real-time event streaming, along with supporting types, error handling, and JWT authentication providers.

packages/core/client/src · high confidence

The comments module now provides a complete, configurable system for managing nested comment threads. On the server side, it introduces a new aggregate handling create, update, and remove commands, alongside a read model that stores comments in a flat table with position-based indexing to efficiently reconstruct nested trees. This read model exposes resolvers for fetching comment trees, counting foreign comments, and paginating all comments. On the client side, the module exports renderless components (CommentsTreeRenderless, CommentsPaginateRenderless, CommentsNotificationRenderless, RefreshHelperRenderless) and a Redux reducer to manage comment state, enabling features like real-time comment count updates and tree rendering without imposing specific UI implementations.

packages/modules/module-comments/src · high confidence

This change introduces several new internal CLI scripts to streamline development workflows. The \@internal/babel-compile\ tool automates the TypeScript compilation and Babel transpilation of packages in dependency order. The \@internal/root-yarn\ script handles repository-wide dependency installation by cleaning the cache and running yarn. The \@internal/use-local-registry\ script facilitates local development deployments by patching package.json, installing dependencies, and triggering a cloud deployment. Finally, the \@internal/workspaces\ script provides a unified interface to run shell commands or npm scripts across all workspaces, either sequentially or in parallel, and includes a command to clean node\_modules.

(repo-wide) · high confidence

This change introduces a complete example application in \examples/js/personal-data\ that demonstrates how to store and manage encrypted personal data in compliance with GDPR. The application includes a React-based client with components for user registration, profile management, and a personal blog feed, alongside server-side aggregates for user profiles, blog posts, and media uploads. It implements end-to-end encryption for sensitive fields (names, contacts) using a secrets manager and provides API endpoints for users to gather or delete their personal data keys, fulfilling data subject rights.

examples/js/personal-data · high confidence

This change introduces two new starter templates for the reSolve framework: a Styled Components example and a Vanilla JS/TS example. Each template provides a complete project structure including configuration files for development, production, cloud, and testing environments, along with build scripts, Babel configurations, and README documentation. These templates allow users to quickly scaffold new applications using either the Styled Components library for styling or plain JavaScript/TypeScript without additional UI libraries.

templates/js/styled-components · high confidence

The testing tools package now includes a new set of runtime utilities to support more robust testing of sagas, event stores, and read models. This adds an in-memory event store implementation that handles event ordering and timestamp validation, a memory-based read-model adapter, and a saga runtime that mocks commands, queries, and side effects for isolated testing. It also introduces a secrets manager mock and utility functions for generating event keys and preparing/stripping test events.

packages/tools/testing-tools/src/runtime · high confidence

This change introduces a complete shopping-list example application for the reSolve framework, demonstrating the use of read-models, view-models, and the @resolve-js/react-hooks client library. The example includes a React-based frontend with routing (MyLists and ShoppingList components), a backend configuration defining a ShoppingList aggregate, and support for multiple deployment modes (development, production, AWS serverless cloud) using specific runtime and eventstore adapters. It also provides scripts for building, running, and testing the application via TestCafe.

examples/js/shopping-list · high confidence

The personal-data example has been migrated to TypeScript, enabling stricter type checking via the noImplicitAny compiler option and configuring Babel and Webpack to handle .ts/.tsx files. This update introduces a complete authentication system using Passport.js local strategy and JWT tokens for user registration and login, alongside middleware that enforces authorization on aggregate commands and read model resolvers. To support GDPR compliance, the application now encrypts personal data within aggregates and read models, and includes a saga that archives user data upon request.

examples/ts/personal-data · high confidence

The TypeScript personal-data example client now includes a complete React frontend. This adds components for user registration and profile management (including encrypted personal data handling), a blog feed with post creation and deletion, and an image upload feature. The client uses @resolve-js/react-hooks for data fetching and commands, and integrates with a CDN uploader module for media assets.

examples/ts/personal-data/client · high confidence

The TypeScript personal-data example now includes a complete set of common infrastructure files that enable encrypted user profiles, media upload tracking, and personal data archiving. This adds command and projection logic for blog posts and media uploads, along with user-profile aggregates that encrypt sensitive fields (first name, last name, contacts) using a secrets-manager-backed AES factory. It introduces read models for blog posts, media, and user profiles, with resolvers that enforce JWT-based authorization via new command and resolver middleware. A personal-data saga handles the GDPR-style data-gathering flow by querying read models, creating a signed archive, and updating the user profile state. Supporting files include event definitions, error classes, JWT utilities, and a view-model for the current user's profile.

examples/ts/personal-data/common · high confidence

The eventstore adapter base library has been restructured from a monolithic implementation into a modular architecture. The core adapter creation logic is now handled by a new \create-adapter\ factory that composes specific capabilities, while distinct operations are isolated into dedicated modules: \import-events\ and \export-events\ handle streaming data with configurable maintenance modes, \cursor-operations\ manages the binary cursor logic, and \errors\ defines specific error classes like \ConcurrentError\ and \ConnectionError\. This refactoring introduces a standardized \EventLoader\ interface for event retrieval and adds support for secret management through \import-secrets\ and \export-secrets\ streams, providing a more maintainable and extensible foundation for database-specific adapters.

packages/runtime/adapters/eventstore-adapters/eventstore-base/src · high confidence

The runtime-base package has been restructured into a modular architecture, introducing dedicated files for bootstrapping (bootstrap.ts, bootstrap-one.ts), command execution (command.ts, command-executed-hook-factory.ts), and event broadcasting (event-broadcast-factory.ts). A new composite monitoring adapter (create-composite-monitoring-adapter.ts) allows aggregating multiple monitoring sources, while built-in API routes (builtin-routes.ts) explicitly define endpoints for queries, commands, and uploads. The event subscriber lifecycle is now managed through dedicated factories (event-subscribers-lifecycle.ts, event-subscribers-properties.ts) and a new event listeners manager (event-listeners-manager-factory.ts) that handles both bootstrapping and shutdown of orphaned subscribers. Default implementations for encryption, read models, and uploads are centralized in a new defaults directory.

packages/runtime/runtimes/runtime-base/src · high confidence

The AWS Serverless runtime now automatically configures the event store and read model connectors to use PostgreSQL via environment variables (RESOLVE\_EVENT\STORE\\*, RESOLVE\READMODEL\\*, RESOLVE\USER\\*). If a user previously specified custom eventstoreAdapter, staticPath, or readModelConnectors.default settings, these are now ignored with a warning, and the runtime forces the PostgreSQL-based defaults. This ensures consistent deployment behavior for serverless AWS environments.

packages/runtime/runtimes/runtime-aws-serverless/src/compile-time · high confidence

The AWS Serverless runtime implementation has been restructured from a monolithic entry point into a modular architecture. The new \lambda-worker.ts\ acts as the central dispatcher, routing incoming Lambda events to specific handlers: \api-gateway-handler.ts\ for HTTP requests, \websocket-event-handler.ts\ for WebSocket connections, \cloud-service-event-handler.ts\ for deployment operations, and \scheduler-event-handler.ts\ for scheduled tasks. This change introduces dedicated factories for infrastructure concerns, including \event-subscriber-notifier-factory.ts\ for managing event subscriptions via SQS or Lambda, \scheduler-factory.ts\ for saga scheduling, and \performance-tracer-factory.ts\ for AWS X-Ray integration. Additionally, \uploader-factory.ts\ now uses \node-fetch\ for presigned URL uploads, and \metrics.ts\ sends duration metrics to CloudWatch, while \get-reactive-subscription-factory.ts\ handles WebSocket subscription token generation.

packages/runtime/runtimes/runtime-aws-serverless/src · high confidence

This change introduces new TypeScript declaration files and test utilities to support the scoping of internal packages. Specifically, it adds global type definitions for the \global/window\ module, type stubs for the \tmp\, \mysql2\, and \mysql2/promise\ libraries used by the event store adapters, a CLI entry point for the admin module, and a mock implementation for the \crypto\ module used in testing scripts. These additions ensure type safety and testability for the newly scoped package structure.

(repo-wide) · high confidence

The build and runtime scripts in \packages/tools/scripts/src\ have been completely rewritten from scratch. This change introduces a new modular architecture for the build pipeline, featuring dedicated modules for generating webpack configurations (client, server, and React Native), handling module resolution, and managing runtime environment injection. It also adds new operational modes for importing and exporting the event store, alongside improved process management and error detection logic, fundamentally changing how the framework compiles and launches applications.

packages/tools/scripts/src · high confidence

The eventstore-lite adapter has been completely rewritten to use the better-sqlite3 library, replacing the previous sqlite3 implementation. This change introduces support for incremental event imports via new begin/commit/rollback operations, adds event subscriber management capabilities, and implements a describe method for adapter status reporting. The adapter now includes improved connection handling with retry logic, enhanced secret management with deletion tracking, and optimized cursor operations for event loading.

packages/runtime/adapters/eventstore-adapters/eventstore-lite/src · high confidence

The view-model execution logic now tracks and reports the number of events processed during a build operation, exposing this count in the build result. Additionally, the system instruments view model resolution and event application with performance tracing segments and monitoring groups, allowing users to observe execution metrics and identify performance bottlenecks in view model projections.

packages/core/core/src/view-model · high confidence

The local registry binary has been refactored to act as a direct HTTP file server for local packages. Instead of relying on external tooling to fetch files, the registry now listens on a configurable host and port, checks if a requested filename exists in the local registry directory and is part of the resolved packages, and serves the file with a 'application/tar+gzip' content type. This changes the interaction model for consumers of the local registry, requiring them to handle HTTP requests for package artifacts rather than file system paths.

internal/local-registry · high confidence

The module-replication package has been converted from JavaScript to TypeScript, introducing a new tsconfig.json that targets ES2020 and enables strict type checking. This migration adds explicit type definitions in index.d.ts and configures the build to produce declaration files, ensuring better type safety and IDE support for consumers of the module.

packages/modules/module-replication · high confidence

The MySQL read-model adapter has been completely rewritten to use an 'inline-ledger' delivery strategy, storing event processing state directly in the database alongside the read model data. This new implementation requires MySQL 8 or later, leveraging JSON columns and generated virtual columns for efficient indexing and querying. The adapter now provides a full set of store operations (find, insert, update, delete, count) and external lifecycle methods (subscribe, pause, resume, reset, status) that coordinate with the event store via a ledger table. It includes robust error handling for MySQL-specific conditions like deadlocks and lock timeouts, and exposes an 'isAlive' status check to monitor the health of the event processing loop.

packages/runtime/adapters/readmodel-adapters/readmodel-mysql/src · high confidence

The core aggregate execution logic has been refactored to introduce \CommandHttpResponseMode\, allowing users to configure whether a command execution returns the resulting event or an empty response. This change also adds support for command middlewares via \commandMiddlewares\ in the runtime configuration and introduces \preSaveEvent\ and \postSaveEvent\ hooks for custom event handling logic.

packages/core/core/src/aggregate · high confidence

The \packages/core/core/src/types\ directory now contains newly defined TypeScript type files (\core.ts\ and \runtime.ts\) that formalize the structure of core domain objects and runtime interfaces. These changes introduce explicit types for \Event\, \Command\, \CommandResult\, and \Aggregate\ handlers, as well as detailed interfaces for \ReadModel\ and \ViewModel\ event handlers and resolvers. Additionally, the runtime types define a comprehensive \Monitoring\ interface with support for custom metrics, execution tracking, and performance tracing, alongside types for replication status and event store descriptions. This establishes a stricter type contract for how aggregates, read models, and monitoring data are structured and processed within the core system.

packages/core/core/src/types · high confidence

The PostgreSQL event store adapter has been significantly refactored to improve reliability and performance. Connection management now supports 'connect on demand' with automatic reconnection logic for service busy and connection terminated errors, and disposal uses Promise.allSettled to ensure all connections are closed. A new incremental import mechanism has been added, allowing events to be imported into a temporary table and committed atomically with validation. Event loading is optimized using pg-cursor for streaming results, and the adapter now exposes a describe method for monitoring event store state, including cursor positions and event counts.

packages/runtime/adapters/eventstore-adapters/eventstore-postgresql/src · high confidence

The PostgreSQL read-model adapter has been completely rewritten to implement a normalized store API and support procedural (PLV8) execution. The new implementation introduces a \buildMode\ configuration option (defaulting to 'auto') that allows users to choose between Node.js and PLV8-based projection building. It adds a \PassthroughError\ mechanism to better handle transient database errors like connection timeouts and deadlocks, improving resilience. The adapter now includes a \status\ method to report the health of the read model, a \forceStop\ capability for immediate ledger intervention, and a \maybeInit\ routine to ensure required ledger tables exist. All standard read operations (find, findOne, count, insert, update, delete) are now routed through a centralized SQL query builder that supports nested JSONB paths and complex search expressions.

packages/runtime/adapters/readmodel-adapters/readmodel-postgresql/src · high confidence

The read-model runtime now supports resolver and projection middlewares, allowing users to intercept and modify read-model operations. Additionally, execution of resolvers and projections is monitored, with performance timing and error tracking available when the monitoring configuration is provided.

packages/core/core/src/read-model · high confidence

The read-model-lite adapter has been completely rewritten to use the better-sqlite3 library instead of the previous sqlite3 driver, providing synchronous execution and improved performance. The adapter now implements an 'inline-ledger' delivery strategy where event processing and state updates are managed directly within the SQLite database using a dedicated ledger table, replacing the previous external coordination mechanism. This change introduces new internal methods for building upsert documents, converting binary rows, and handling search-to-where expressions, while maintaining the standard read-model store API (find, findOne, count, insert, update, delete) and external lifecycle methods (subscribe, unsubscribe, pause, resume, reset, status).

packages/runtime/adapters/readmodel-adapters/readmodel-lite/src · high confidence

The core Redux integration has been reorganized into a new modular structure, introducing dedicated files for command, read-model, and view-model handling. This includes new React hooks (\useReduxCommand\, \useReduxReadModel\, \useReduxViewModel\) and their corresponding Redux actions, reducers, and Redux-Saga implementations. The \createResolveStore\ and \createResolveMiddleware\ functions have been updated to support this new architecture, enabling better separation of concerns for state management and side effects.

packages/core/redux/src · high confidence

The PostgreSQL read-model adapter's resource management logic has been restructured into dedicated \create\ and \destroy\ modules. This change standardizes how the adapter initializes and cleans up its database schema, specifically by explicitly creating the event ledger and transaction tables during setup and ensuring proper schema ownership and cascading drops during teardown. This refactoring supports the broader normalization of the read-model Store API and enables more robust integration testing.

packages/runtime/adapters/readmodel-adapters/readmodel-postgresql/src/resource · high confidence

The core runtime library has been reorganized into a modular structure, introducing new source files for browser-specific utilities, error handling, logging, and interop logic. This change exposes a cleaner public API by exporting helper functions (such as URL validation and JSON serialization), new error classes (CommandError, ApiError, HttpError), and runtime environment declaration tools from the main index. It also centralizes the initialization of domain components (aggregates, read models, view models, sagas) and provides middleware application utilities, effectively decoupling these runtime concerns into distinct, reusable modules.

packages/core/core/src · high confidence

The read-model adapter base library has been refactored to normalize the Store API and improve operational robustness. The adapter factory now strictly enforces that implementations only provide standard methods, throwing an error if extra methods are detected. A new \AlreadyDisposedError\ type and associated checks ensure that operations on disposed adapters fail gracefully with a specific error rather than generic runtime failures. Additionally, search conditions are now validated to reject unsupported formats early, and all adapter operations are wrapped with performance tracing and monitoring hooks for better observability.

packages/runtime/adapters/readmodel-adapters/readmodel-base/src · high confidence

The testing tools for read-models have been refactored to use a new fluent API structure. The \read-model\ function now returns a node supporting \query\, \withAdapter\, and \withEncryption\ methods. The \query\ method provides a chainable interface for setting authentication (\as\), configuring secrets (\withSecretsManager\), and defining assertions (\shouldReturn\, \not\). Internally, \make-test-environment\ manages the test execution context, including monitoring and event subscription, ensuring that configuration changes like auth tokens or secrets cannot be applied after the test has started.

packages/tools/testing-tools/src/flow/read-model · high confidence

The replication module source code has been migrated from JavaScript to TypeScript. This change introduces a new set of API handlers (get-log, occupy\_replication, pause\_replication, release\_replication, replicate, replication\_state, reset\_replication, respond-with-error, resume\_replication) that manage replication lifecycle events such as locking, pausing, resuming, and uploading event batches. The module now exposes specific endpoints for state retrieval, replication control, and data upload, with improved error handling and logging via the debug-levels library.

packages/modules/module-replication/src · high confidence

The \@resolve-js/runtime-aws-serverless\ and \@resolve-js/runtime-single-process\ packages have been restructured, introducing a new \importMode\ option that allows users to specify whether to use static or dynamic imports between application modules. The \runtime-single-process\ package additionally exposes \host\ and \port\ configuration options for network binding. Under the hood, both packages now target ES2020 in their TypeScript configuration, which may affect compatibility with older JavaScript environments.

packages/runtime/runtimes/runtime-aws-serverless, packages/runtime/runtimes/runtime-single-process · high confidence

The saga runtime in \packages/core/core/src/saga\ has been refactored to introduce timestamp-based control over side-effect execution. New files (\create-event-handler.ts\, \wrap-side-effects.ts\, and \types.ts\) implement a mechanism where side effects are only enabled if the current event's timestamp is earlier than a stored \sideEffectsStartTimestamp\. This change ensures that side effects are not re-executed for events processed after a specific point, addressing issues with stale or duplicate side effects during saga recovery or replay.

packages/core/core/src/saga · high confidence

The saga testing tool in \packages/tools/testing-tools/src/flow/saga\ has been refactored to allow tests to opt into executing real side effects via the new \allowSideEffects\ method, rather than relying solely on mocked behavior. This change introduces a strict execution model where configuration methods (\withAdapter\, \withEncryption\, \withSecretsManager\) and assertions (\shouldExecuteCommand\, \shouldExecuteQuery\, \shouldExecuteSideEffect\) must be set up before the test runs; attempting to modify the test environment or add assertions after execution begins now throws an error. Additionally, the \startSideEffectsFrom\ method allows specifying a timestamp to control when side effects are considered active.

packages/tools/testing-tools/src/flow/saga · high confidence

The static assets for the JavaScript shopping list example have been updated to include the minified CSS for Bootstrap v4.4.1. This change provides the example with the styling and layout capabilities of this specific Bootstrap version, ensuring consistent visual presentation for users interacting with the demo.

examples/js/shopping-list/static · high confidence

The client-side code for the shopping list examples has been refactored to adopt modern React and Redux practices. The HOC-based example now utilizes Redux Saga for handling side effects and optimistic updates, while the standard Redux example has been migrated to React hooks (useReduxCommand, useReduxViewModel) and functional components, replacing the previous class-based containers and reducers. Both examples now use the @resolve-js/redux library for data fetching and command execution, providing a more consistent and up-to-date developer experience.

examples/js/shopping-list-redux-hoc/client, examples/js/shopping-list-redux/client · high confidence

The single-process runtime now explicitly sets the build target to 'local' and clears external dependencies during the compile-time phase. This ensures that the runtime environment is configured to resolve modules locally without treating any dependencies as external, providing a consistent and isolated execution context for single-process scenarios.

packages/runtime/runtimes/runtime-single-process/src/compile-time · high confidence

The repository now enforces consistent code style and linting through new configuration files. A \.prettierrc\ file standardizes formatting (2-space tabs, single quotes, no semicolons), while \.eslintignore\ and \.eslintrc.js\ configure ESLint to ignore generated files (dist, lib, es, types) and apply rules including a new \no-console\ error and a spell-checker plugin. Additionally, a \validate-lock-file.js\ script ensures all dependencies are resolved from the official Yarn registry, and \.prettierignore\ excludes build artifacts and type definitions from formatting.

(repo-wide) · high confidence

The static Bootstrap CSS file in the PostCSS and Styled Components templates has been updated to version 4.4.1. This change ensures that projects using these templates benefit from the latest styling, bug fixes, and component behaviors provided by this specific Bootstrap release.

templates/js/postcss/static, templates/js/styled-components/static · high confidence

The static assets for the \shopping-list-redux-hoc\ and \shopping-list-redux\ examples have been updated to include Bootstrap v4.4.1. This change ensures the examples use the latest styling and component definitions from the Bootstrap framework, affecting the visual appearance of the shopping list interfaces.

examples/js/shopping-list-redux-hoc/static, examples/js/shopping-list-redux/static · high confidence

The static assets for the React template now include Bootstrap v4.4.1, replacing the previous version. This update brings the latest styling, component classes, and utility functions from the Bootstrap framework to the generated React applications, ensuring consistent and modern UI rendering out of the box.

templates/js/react/static · high confidence

The \shopping-list-redux\ and \shopping-list-redux-hoc\ examples have been updated with new configuration files to support modern build tooling and environment-specific deployments. Both examples now include \.babelrc\ files with \@babel/preset-env\, \@babel/preset-react\, and TypeScript support plugins, alongside \config.adjust-webpack.js\ to handle \.tsx\ files. The \run.js\ scripts have been refactored to use \@resolve-js/scripts\ for managing development, production, cloud, and testing modes. Configuration files (\config.dev.js\, \config.prod.js\, \config.cloud.js\, \config.test-functional.js\) now explicitly define runtime modules (e.g., \@resolve-js/runtime-single-process\, \@resolve-js/runtime-aws-serverless\), event store adapters (\@resolve-js/eventstore-lite\), and read model connectors (\@resolve-js/readmodel-lite\). The \shopping-list-redux\ example specifically uses React hooks for Redux integration, while \shopping-list-redux-hoc\ demonstrates the Higher-Order Component pattern. Both examples now support TypeScript via \ts-jest\ in their Jest configurations.

examples/js/shopping-list-redux, examples/js/shopping-list-redux-hoc · high confidence

The tutorial's first lesson template has been updated to include a standard project structure with Babel configuration for React and ES6+ features, a .gitignore file, and a README. It now features a 'ShoppingList' aggregate with command and projection handlers, configured via \config.app.js\. The runtime environment is set up to use \@resolve-js/runtime-single-process\ for development and production, and \@resolve-js/runtime-aws-serverless\ for cloud deployment, with the \@resolve-js/eventstore-lite\ adapter for local data storage. A new \run.js\ script provides commands for development, building, starting, and testing the application.

tutorial · high confidence

The documentation website has been rebuilt using Docusaurus v2, replacing the previous static site generator. This change introduces a new landing page (\src/pages/index.js\) featuring a hero banner with a custom SVG background and feature highlights, alongside a restructured documentation sidebar (\sidebars.json\) that organizes content into Basics, Guides, and API sections. The site configuration (\docusaurus.config.js\) now includes Algolia search integration, updated navigation links, and custom theming via \customTheme.css\ to support a consistent visual identity across light and dark modes.

website · high confidence

The source code for the create-resolve-app CLI tool has been converted from JavaScript to TypeScript. This change introduces strict typing for application name validation, example selection, and package patching, while preserving the existing functionality for scaffolding Resolve applications, downloading repositories, and managing dependencies.

packages/core/create-resolve-app/src · high confidence

Add Redux Hooks functional test suite; Add shared test utilities and constants for functional testing; Added HOC functional test application with view-model isolation scenarios; Added Jest snapshot for webpack configuration generation; Added Jest snapshots for resolve alias configuration tests; Added authentication test fixtures for login and registration flows; Added automated tests for the Redux and HOC shopping-list examples; Added comprehensive test coverage for the client library; Added comprehensive tests for eventstore save and load operations; Added end-to-end tests for JavaScript templates; Added end-to-end tests for personal data management; Added end-to-end tests for static asset resolution; Added functional and unit tests for the shopping list example; Added functional test harness for Redux hooks; Added functional tests for API benchmarks, monitoring, sagas, and schedulers; Added functional tests for HOC view model isolation; Added functional tests for Postgres read-model adapter jitter behavior; Added functional tests for React Hooks scenarios; Added functional tests for Redux Hooks query string, view model, and named selector behaviors; Added functional tests for saga side effects and scheduler; Added functional tests for the MySQL read-model adapter; Added functional tests for the Read-model Store API; Added integration tests for eventstore adapter freeze/unfreeze and secrets management; Added integration tests for read-model samples; Added integration tests for the Comments read-model sample; Added integration tests for the saga-sample application; Added snapshot tests for PostgreSQL read-model adapter SQL generation; Added snapshot tests for givenEvents timestamp handling; Added snapshot tests for read-model samples; Added snapshot tests for saga authorization sample; Added test coverage for Redux core modules; Added test coverage for module-admin API handlers and command endpoints; Added test coverage for testing-tools aggregate, read-model, saga, and BDD chain APIs; Added test coverage for the React template; Added test fixtures for alias resolution; Added test mocks for the eventstore-lite adapter; Added test runner script for resolve-scripts-sample; Added test suite for custom read model connector; Added test utilities for eventstore adapters; Added tests for PostgreSQL read-model adapter core operations and status logic; Added tests for alias resolution scripts; Added tests for config validation and webpack configuration generation; Added tests for event broadcast factory and runtime index; Added tests for event store import/export functionality; Added tests for eventstore adapter connection lifecycle and disposal; Added tests for eventstore adapter event ordering; Added tests for eventstore adapter initialization and drop operations; Added tests for eventstore adapter replication state management; Added tests for eventstore adapter timeout behavior; Added tests for eventstore event filtering capabilities; Added tests for incremental event import functionality; Added tests for node-postgres connection termination behavior; Added tests for parallel event and secret operations in SQLite eventstore adapter; Added tests for read-model base adapter and search condition validation; Added tests for readmodel-lite adapter operations; Added tests for replicator-via-api-handler adapter connectivity; Added tests for the saga-with-authorization sample; Added unit tests for AWS Serverless runtime and API handler wrapper; Added unit tests for MySQL event store adapter configuration and schema operations; Added unit tests for PostgreSQL event store adapter core operations; Added unit tests for comments module commands and reducers; Added unit tests for core interop builders and utilities; Added unit tests for eventstore-base adapter utilities; Added unit tests for eventstore-lite adapter configuration and drop operations; Added unit tests for runtime initialization and API handler wrapping; Added utility functions for saga and monitoring functional tests; Added view model projections and resolvers for functional testing; Initial setup of functional test infrastructure; New functional test application scaffolding; New functional test components for React Hooks integration; New functional test fixtures for read models and aggregates; Snapshot tests for read-model generic adapter API; Unit tests added for React hooks in packages/core/react-hooks.

This release updates the dependency manifests for the reSolve framework examples (Hacker News, Personal Data, Shopping List in both JS and TS variants), the benchmarks workspace, the functional-tests app, and internal tooling packages to version 0.34.3. Core framework packages such as @resolve-js/client, @resolve-js/core, and create-resolve-app are also aligned to 0.34.3. Supporting dependencies like React (17.0.2), Jest (27.5.1), TypeScript (4.3.2 in examples, 4.5.5 in root), and Babel (7.17.2) are present in the updated manifests.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 52.

• Code Health 66
• Architecture 56
• Maturity 68
• Readiness 43
• Security 57
• Accessibility 83

• 300 commits — 257 feature/other, 43 fixes

• (root) — 102 commits
• packages/runtime — 101 commits
• (repo) — 22 commits
• docs/api — 13 commits
• examples/js — 11 commits
• packages/tools — 9 commits
• .github/workflows — 8 commits
• packages/core — 6 commits
• examples/ts — 5 commits
• benchmarks/eventstore — 3 commits
• docs/application-configuration.md — 3 commits
• functional-tests/app — 2 commits
• templates/ts — 2 commits
• docs/README.md — 1 commit
• docs/getting-started-chart — 1 commit
• docs/preparing-to-production.md — 1 commit
• docs/running-in-containers.md — 1 commit
• examples/README.md — 1 commit
• packages/modules — 1 commit
• templates/js — 1 commit

• fix: Better logging. Fix #2141. Fix casting loadEventsByTimestamp result to JSON (#2142)
• fix: Bump versions / Fix Lint (#2239)
• fix: Exit process from signal handler. Possible fix for #2126 (#2127)
• fix: Fix #1292 (#2117)
• fix: Fix #2044 (#2051)
• fix: Fix #2119 (#2135)
• fix: Fix #2230 (#2232)
• fix: Fix Github Actions workflows (#2259)
• fix: Fix MDIS (#2099)
• fix: Fix PLV8 field filter (#2268)
• fix: Fix api handler path validation (#2143)
• fix: Fix bad anchor link in Application Configuration article (#2275)
• fix: Fix broken outlines (#2228)
• fix: Fix command post save event notification performance (#2277)
• fix: Fix create-resolve-app tests (#2258)
• fix: Fix eliminated error message in Init projection handler (#2250)
• fix: Fix error monitoring dimensions if name or message is absent (#2161)
• fix: Fix events import/export for node runtime (#2069)
• fix: Fix isAlive in read model status (#2098)
• fix: Fix isAlive value in read model adapter status (#2057)
• …and 280 more

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

reimagined/resolve 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.