minos-framework/minos-python

This system is a comprehensive microservice framework that provides infrastructure for building distributed applications using the CQRS and Saga patterns. It manages aggregate state through event sourcing, snapshots, and transactional consistency, while offering robust networking capabilities for HTTP, GraphQL, and message brokers like Kafka and RabbitMQ. The architecture supports pluggable backends for databases (PostgreSQL, LMDB) and service discovery, enabling developers to construct scalable, event-driven microservices with built-in resilience and testing utilities.

The \minos.networks.http\ module has been introduced, providing base classes and concrete implementations for HTTP-based routing. Users can now define REST command and query decorators (\RestCommandEnrouteDecorator\, \RestQueryEnrouteDecorator\) and use the \HttpEnrouteDecorator\ to specify path and HTTP method for microservice network endpoints.

packages/core/minos-microservice-networks/minos/networks/decorators/definitions/http · high confidence

The \minos/common/protocol\ module now provides concrete serialization implementations for binary data. This includes an abstract base class \MinosBinaryProtocol\ and specific implementations for Avro (supporting both database storage and message passing) and JSON (using the \orjson\ library). These classes handle encoding and decoding of data structures into bytes, enabling consistent serialization across the Minos microservice framework.

packages/core/minos-microservice-common/minos/common/protocol · high confidence

The aiopg plugin now provides concrete database operation factories for Minos network components, enabling PostgreSQL-backed message queues and duplicate detection. Specifically, it introduces \AiopgBrokerQueueDatabaseOperationFactory\ for managing broker queues, \AiopgBrokerPublisherQueueDatabaseOperationFactory\ for publishing to queues, \AiopgBrokerSubscriberQueueDatabaseOperationFactory\ for consuming from queues, and \AiopgBrokerSubscriberDuplicateValidatorDatabaseOperationFactory\ for tracking processed message IDs. These are wired into the \AiopgDatabaseClient\ via \set\_factory\ calls, allowing the application to use PostgreSQL for reliable message delivery and at-least-once semantics.

packages/plugins/minos-database-aiopg/minos/plugins/aiopg/factories/networks · high confidence

The aiopg plugin now includes new \AiopgEventDatabaseOperationFactory\, \AiopgSnapshotDatabaseOperationFactory\, and \AiopgTransactionDatabaseOperationFactory\ classes. These implement the database operations for events, snapshots, and transactions using PostgreSQL-specific SQL (e.g., \uuid-ossp\ extension, JSONB, and specific table schemas), enabling the Minos framework to persist aggregate state in a PostgreSQL database via the aiopg client.

packages/plugins/minos-database-aiopg/minos/plugins/aiopg/factories/aggregate · high confidence

The cart microservice now includes a query layer to read cart data. New files define SQLAlchemy models for Cart, CartItem, and Product, a repository class that manages the PostgreSQL database connection and persistence of cart state, and a query service that exposes REST endpoints to retrieve a cart and its items, while also listening to 'CartCreated' and 'CartUpdated' events to keep the read model in sync.

tutorials/eboutique/microservices/cart/src/queries · high confidence

The tutorial now includes external infrastructure components to support stock, crypto, and wallet microservices. This includes an API gateway (using minos-apigateway 0.1.0) with CORS and authentication configuration, a service discovery service (using minos-discovery 0.0.8) with Redis backend, and a PostgreSQL 14.2 database setup that initializes new databases for stocks and crypto services alongside the existing wallet databases.

tutorials/stock-wallet/external · medium confidence

The \minos.networks.discovery.clients\ module now exposes an \InMemoryDiscoveryClient\ alongside the abstract \DiscoveryClient\ base class. This in-memory implementation allows developers to perform local testing of service discovery logic without requiring an external discovery server, as the client simply tracks subscription state in memory rather than making network calls.

packages/core/minos-microservice-networks/minos/networks/discovery/clients · high confidence

A new \QueuedBrokerPublisher\ implementation is introduced in the \minos.networks.brokers.publishers.queued\ package, enabling message queuing for broker publishers. The change adds an abstract \BrokerPublisherQueue\ interface and concrete queue implementations: an in-memory queue (\InMemoryBrokerPublisherQueue\) and a database-backed queue (\DatabaseBrokerPublisherQueue\), along with a corresponding database operation factory. This allows publishers to buffer and process messages asynchronously via a queue.

packages/core/minos-microservice-networks/minos/networks/brokers/publishers/queued · medium confidence

A new \QueuedBrokerSubscriber\ class has been added to the \minos.networks.brokers.subscribers.queued\ module. This class wraps an existing \BrokerSubscriber\ implementation and a \BrokerSubscriberQueue\ to handle message queuing. The module also introduces several queue-related classes (\BrokerSubscriberQueue\, \InMemoryBrokerSubscriberQueue\, \DatabaseBrokerSubscriberQueue\, etc.) and their corresponding builders. A \QueuedBrokerSubscriberBuilder\ is also provided, though it is marked as deprecated in favor of the standard \BrokerSubscriberBuilder\.

packages/core/minos-microservice-networks/minos/networks/brokers/subscribers/queued · high confidence

The stock-wallet tutorial now includes a complete microservices architecture for tracking stock and crypto assets. The project is configured with Postgres, Kafka, and Minos for discovery and API gateway, and the docker-compose setup deploys services for wallet, stocks, and crypto alongside infrastructure like Redis and Zookeeper.

tutorials/stock-wallet · high confidence

A new wallet query service has been introduced to handle read operations for the wallet microservice. The implementation includes SQLAlchemy models for Wallet, Ticker, and Quotes, along with a repository layer that manages database interactions. The service exposes REST endpoints to retrieve wallets, tickers, and quotes, and subscribes to domain events (WalletCreated, WalletUpdated, QuotesChannel) to keep the read model in sync with state changes.

tutorials/stock-wallet/microservices/wallet/src/queries · high confidence

A new \builders\ module has been introduced in the GraphQL plugin, providing a \GraphQLSchemaBuilder\ class that dynamically constructs GraphQL schemas from route definitions. This component maps query and mutation routes to GraphQL object types, handling argument adaptation and ensuring the schema meets GraphQL constraints.

packages/plugins/minos-router-graphql/minos/plugins/graphql/builders · medium confidence

The cart microservice now exposes a new command service that handles cart creation and item addition. Users can create a new cart via a POST request to /cart, and add items to an existing cart via POST to /cart/{uuid}/item, which triggers a saga to process the item addition.

tutorials/eboutique/microservices/cart/src/commands · high confidence

The cart microservice now includes the core domain models (Cart, CartItem, Product) and a CLI entry point for launching the service. It also introduces a saga workflow (add\_cart.py) that validates product existence via a remote service call before adding an item to the cart, handling errors by raising a ValueError if the product is not found.

tutorials/eboutique/microservices/cart/src · high confidence

A new 'crypto' microservice has been added to the tutorials/stock-wallet/microservices/crypto directory. This service implements a Python-based microservice using the Minos framework, featuring an aggregate for storing crypto tickers, a command service that periodically fetches market data from the Kraken exchange via the ccxt library, and a query service with a SQL repository for reading data. The implementation includes a Dockerfile for containerization, configuration files for database and broker connections, and a full suite of unit tests for both commands and queries.

tutorials/stock-wallet/microservices/crypto · high confidence

The e-boutique tutorial now includes two new microservices: a checkout service and a currency service. The checkout service provides a REST endpoint to create checkouts and handles related events, while the currency service exposes a command to fetch currency conversion quotes using an external rate provider. Both services follow the Minos framework patterns with command and query sides, enabling users to explore microservice architecture in a practical example.

tutorials/eboutique/microservices/checkout, tutorials/eboutique/microservices/currency · high confidence

A new query service layer has been introduced for the stocks microservice, providing the foundational structure for read operations. This includes a SQLAlchemy-based repository for database connectivity and a \StocksQueryService\ that exposes a REST endpoint at \/stockss\ (currently returning a 'Not implemented' exception). The implementation also includes ORM model definitions and dependency injection wiring, with event handlers for stock creation, update, and deletion currently commented out.

tutorials/stock-wallet/microservices/stocks/src/queries · high confidence

The product microservice now includes a complete structural foundation, introducing the \Product\ aggregate and its associated command and query services. Users can now interact with product data through REST endpoints for creating, retrieving, and deleting products, as well as a CLI entry point to start the microservice. The implementation leverages Minos CQRS patterns, with \ProductCommandService\ handling write operations and \ProductQueryService\ managing read operations via a SQLAlchemy-backed repository.

tutorials/eboutique/microservices/product · high confidence

The stocks microservice now includes command handlers that listen for wallet ticker updates and periodically fetch historical stock data from the Polygon API. When a new ticker is added to a stock, the system records the timestamp. On a scheduled basis, the service retrieves the last month of hourly aggregate data for all tracked tickers, then publishes real-time quote updates (ticker, close price, volume, and timestamp) to a message broker channel for downstream consumers.

tutorials/stock-wallet/microservices/stocks/src/commands · high confidence

A new stocks microservice has been introduced to handle stock crawling. This includes the core aggregate logic for managing stock tickers and updates, a command service for writing operations, and a query service for reading data. The service is exposed via a CLI entry point that launches the microservice using the Minos framework.

tutorials/stock-wallet/microservices/stocks/src · high confidence

The Notifier microservice has been added to the tutorials/eboutique/microservices/notifier directory. This new component provides a complete microservice implementation including a CLI entry point, command handling for sending email notifications via SMTP, and query services for managing Notifier aggregates. The service integrates with PostgreSQL for data persistence and exposes REST and broker-based endpoints for creating, updating, and deleting notifiers.

tutorials/eboutique/microservices/notifier · high confidence

The eboutique tutorial project has been added, providing a complete example of an online boutique built with Minos microservices. The project includes configuration files (.minos-answers.yml, .minos-project.yaml), Docker Compose setups, and individual microservice directories for cart, checkout, currency, and notifier. Each microservice contains its own configuration, Dockerfile, and test suite, enabling users to run and test the full stack locally.

tutorials/eboutique · high confidence

The shipping microservice has been added to the e-boutique tutorial, providing a new service for calculating shipping quotes. The implementation includes a command handler that computes a shipping price based on the distance from Madrid to a destination, applying a surcharge for orders with more than two items. Additionally, the service exposes a REST endpoint to retrieve shipping information and subscribes to shipping lifecycle events (created, updated, deleted) to handle state changes.

tutorials/eboutique/microservices/shipping · high confidence

A new database-backed queue implementation for broker subscribers has been introduced, providing a generic, database-agnostic way to manage message queues. This change adds a \DatabaseBrokerSubscriberQueue\ and its associated builder, which interact with the database via a \DatabaseOperationFactory\ to build and execute queries for counting and dequeuing messages. This allows subscribers to use a database as their underlying storage mechanism for queued messages, abstracting away the specific SQL operations needed for queue management.

packages/core/minos-microservice-networks/minos/networks/brokers/subscribers/queued/queues/database · medium confidence

The Minos Framework now includes a new plugin for integrating with Kong, an API gateway. This release introduces a \KongClient\ for managing services, routes, and authentication plugins (Basic Auth, JWT, ACL) via the Kong Admin API, a \KongDiscoveryClient\ that implements the Minos discovery interface to automatically register and unregister microservices with Kong, and a middleware to extract user context from Kong headers. The plugin is released as version 0.7.0.

packages/plugins/minos-discovery-kong/minos/plugins/kong · high confidence

Added new Avro serializers for encoding and decoding model data and schemas, including abstract base classes for encoders and decoders, and concrete implementations for handling Avro-specific types such as dates, times, and UUIDs. This enables the system to serialize and deserialize Python objects into Avro-compatible formats.

packages/core/minos-microservice-common/minos/common/model/serializers · high confidence

The \minos.networks.brokers\ package now exposes a \BrokerClient\ class that encapsulates sending and receiving \BrokerMessage\ objects via a \BrokerPublisher\ and \BrokerSubscriber\. A \BrokerClientPool\ is also provided to manage a pool of these clients, automatically managing their lifecycle (setup/destroy) and handling reply topic context. This change introduces the core abstractions for broker communication, including the client, pool, and associated message types, replacing previous ad-hoc implementations.

packages/core/minos-microservice-networks/minos/networks/brokers · high confidence

Added the \BrokerHandler\ implementation and \BrokerPort\ (along with the deprecated \BrokerHandlerService\ wrapper) in the \minos.networks.brokers.handlers\ package. The \BrokerHandler\ manages message consumption and dispatching with configurable concurrency, while \BrokerPort\ provides the lifecycle management (start/stop) for the broker handler. This change establishes the core components for handling broker messages within the microservice network.

packages/core/minos-microservice-networks/minos/networks/brokers/handlers · high confidence

The publishers module now exposes a new \BrokerPublisher\ abstract base class and a corresponding \BrokerPublisherBuilder\ for constructing publisher instances. An \InMemoryBrokerPublisher\ implementation is provided for testing or lightweight scenarios, storing sent messages in memory. This establishes a consistent interface for publishing messages to message brokers, with support for optional queuing via the builder pattern.

packages/core/minos-microservice-networks/minos/networks/brokers/publishers · high confidence

The \minos.networks.decorators\ package now includes an \EnrouteFactory\ that aggregates handler functions from decorated classes, supporting middleware chains and pre/post-processing hooks. An \EnrouteCollector\ is provided to scan classes and extract decorator metadata for broker, REST, and periodic events. These components enable the framework to automatically discover and route commands, queries, and events based on decorator usage.

packages/core/minos-microservice-networks/minos/networks/decorators · high confidence

Added the \minos-database-lmdb\ package, providing an \LmdbDatabaseClient\ for persistent storage using LMDB, along with an \LmdbSagaExecutionDatabaseOperationFactory\ to support saga execution tracking. This enables users to configure their applications to use LMDB as a backend for both general database operations and saga state management.

packages/plugins/minos-database-lmdb/minos/plugins/lmdb · high confidence

The Minos framework now includes a new GraphQL plugin that enables GraphQL support. This adds a \GraphQlHttpRouter\ that exposes endpoints for executing GraphQL operations and retrieving the schema. The plugin provides decorators (\GraphQlEnroute\, \GraphQlCommandEnrouteDecorator\, \GraphQlQueryEnrouteDecorator\) to mark routes as GraphQL handlers, and a \GraphQlHandler\ to process requests. Users can now integrate GraphQL into their Minos applications by using these new components.

packages/plugins/minos-router-graphql/minos/plugins/graphql · high confidence

The Minos Framework now includes a complete implementation of the Saga pattern for managing distributed transactions across microservices. This release adds the \minos.saga\ module, which provides core components such as \SagaManager\ for orchestrating execution, \Executor\ classes (Local, Request, Response) for handling different step types, and a \SagaContext\ for maintaining state. The update also introduces a \SagaExecutionRepository\ interface with a \DatabaseSagaExecutionRepository\ implementation for persistence, along with a comprehensive set of exceptions and message types (\SagaRequest\, \SagaResponse\) to facilitate communication between services.

packages/core/minos-microservice-saga/minos/saga · high confidence

A new \MinosDiscoveryClient\ is now available in the \minos-discovery-minos\ plugin, implementing the \DiscoveryClient\ interface to handle microservice discovery via HTTP endpoints. The client supports subscribing and unsubscribing to service metadata and includes a \CircuitBreakerMixin\ to handle transient network failures, defaulting to \localhost:5567\ for the discovery service.

_packages/plugins/minos-discovery-minos/minos/plugins/minos\discovery · high confidence

The Minos framework now includes a new RabbitMQ broker plugin that provides \RabbitMQBrokerPublisher\ and \RabbitMQBrokerSubscriber\ implementations. Users can now configure and connect to a RabbitMQ instance using host, port, user, and password settings from their configuration. The plugin handles connection management, message publishing, and queue subscription, enabling event-driven communication via RabbitMQ.

packages/plugins/minos-broker-rabbitmq/minos/plugins/rabbitmq · high confidence

The \minos.common\ package is introduced, providing a unified set of core classes for the Minos framework. This includes the \Builder\ and \BuildableMixin\ for object construction, \SetupMixin\ and \MinosSetup\ for lifecycle management, \Port\ and \EntrypointLauncher\ for service entry points, \Pool\ and \PoolFactory\ for resource management, \Lock\ and \LockPool\ for concurrency control, \CircuitBreakerMixin\ for resilience, and various exception and utility classes. This change consolidates common functionality into a single package, making it easier to access and use these foundational components.

packages/core/minos-microservice-common/minos/common · high confidence

The \minos/aggregate/transactions/repositories\ module now provides a new abstract \TransactionRepository\ base class and an \InMemoryTransactionRepository\ implementation. This change introduces a standardized interface for managing transaction entries, supporting operations like submitting, selecting, and filtering transactions by various attributes (UUID, status, timestamps, etc.). The in-memory implementation allows for testing and lightweight usage without a database, while the abstract class defines the contract for other storage backends.

packages/core/minos-microservice-aggregate/minos/aggregate/transactions/repositories · high confidence

The \minos.networks.brokers.subscribers.queued.queues\ package now provides a dedicated module for broker subscriber queues, introducing an abstract base class \BrokerSubscriberQueue\ and its builder \BrokerSubscriberQueueBuilder\. Additionally, an in-memory implementation \InMemoryBrokerSubscriberQueue\ is added, allowing for testing or scenarios where persistent storage is not required. This structure separates the queue logic from the broader broker subscriber implementation, providing a clear interface for queue-based message handling.

packages/core/minos-microservice-networks/minos/networks/brokers/subscribers/queued/queues · high confidence

The aiopg plugin for the Minos Framework is now available, providing an asynchronous PostgreSQL database client (AiopgDatabaseClient) that supports connection recreation during failures. The client includes circuit breaker functionality to handle connection issues, with specific exception handling for operational and timeout errors. The plugin also introduces a suite of database operation factories for aggregates, snapshots, transactions, locks, and broker queues, enabling consistent database interactions across the framework.

packages/plugins/minos-database-aiopg/minos/plugins/aiopg · high confidence

Added new files to the broker dispatchers module: \impl.py\ introduces the \BrokerDispatcher\ class, which handles routing and executing actions based on broker messages, while \requests.py\ defines \BrokerRequest\, \BrokerResponse\, and \BrokerResponseException\ to model the incoming and outgoing data for broker communication.

packages/core/minos-microservice-networks/minos/networks/brokers/dispatchers · high confidence

The \minos/common/model\ package now provides a complete set of model abstractions and utilities. Users can create declarative models via \DeclarativeModel\ (aliased as \MinosModel\) and dynamic models like \DynamicModel\ and \DataTransferObject\. The \Field\ class manages field metadata, parsing, validation, and Avro serialization/deserialization, exposing properties for schema and data encoding. The \Model\ base class supports Avro-based instantiation and serialization, while \ModelType\ and related type-hint utilities enable type introspection and comparison.

packages/core/minos-microservice-common/minos/common/model · medium confidence

A new \DatabaseLock\ class has been added to the \minos/common/database/locks\ module, providing a distributed lock implementation that acquires and releases locks via database operations. The change introduces a \LockDatabaseOperationFactory\ abstract base class to define the structure for acquire and release operations, allowing the lock behavior to be customized through different factory implementations.

packages/core/minos-microservice-common/minos/common/database/locks · medium confidence

The \minos.networks.discovery\ module now exposes a \DiscoveryConnector\ class that manages service registration and unregistration via a \DiscoveryClient\. The connector reads configuration to determine the client type, port, and endpoints, then subscribes or unsubscribes from the discovery service. Additionally, \DiscoveryClient\ and \InMemoryDiscoveryClient\ are exported for direct use.

packages/core/minos-microservice-networks/minos/networks/discovery · high confidence

Users can now utilize the new \DynamicModel\, \BucketModel\, and \DataTransferObject\ classes for dynamic model handling in the common package. Additionally, the saga module now provides concrete implementations for executing saga steps, including \LocalSagaStepExecution\, \RemoteSagaStepExecution\, and \ConditionalSagaStepExecution\, enabling the framework to manage local, remote, and conditional workflow steps with proper status tracking and rollback capabilities.

packages/core/minos-microservice-common/minos/common/model/dynamic, packages/core/minos-microservice-networks/minos/networks/decorators/callables, packages/core/minos-microservice-saga/minos/saga/executions/steps · high confidence

A new \FilteredBrokerSubscriber\ is introduced to wrap existing subscribers and validate incoming messages for duplicates before processing. This includes an abstract \BrokerSubscriberValidator\ interface and concrete implementations: an in-memory validator (\InMemoryBrokerSubscriberDuplicateValidator\) that tracks seen message identifiers in a set, and a database-backed validator (\DatabaseBrokerSubscriberDuplicateValidator\) that uses a configurable database key and a \DatabaseOperationFactory\ to check uniqueness via database constraints. The \BrokerSubscriberDuplicateDetector\ has been renamed to \BrokerSubscriberDuplicateValidator\ to better reflect its role in the filtering pipeline.

packages/core/minos-microservice-networks/minos/networks/brokers/subscribers/filtered · high confidence

The \minos.networks.brokers.subscribers\ package now includes an in-memory implementation of the broker subscriber interface (\InMemoryBrokerSubscriber\) along with its corresponding builder (\InMemoryBrokerSubscriberBuilder\). This allows users to create and configure in-memory subscribers for testing or lightweight scenarios, exposing the \add\_message\ method to push messages into the subscriber's internal queue.

packages/core/minos-microservice-networks/minos/networks/brokers/subscribers · high confidence

The \minos-microservice-aggregate\ package now includes an \InMemoryEventRepository\ implementation alongside the abstract \EventRepository\ base class. This allows users to persist event entries in memory rather than relying on a database, which simplifies testing and local development workflows by removing the need for external database dependencies.

packages/core/minos-microservice-aggregate/minos/aggregate/events/repositories · high confidence

The \minos.networks\ package now exposes a comprehensive set of routing and system utilities. It adds a \Router\ base class and specific routers (\HttpRouter\, \RestHttpRouter\, \BrokerRouter\, \PeriodicRouter\) that manage enroute decorators and callbacks. Additionally, a \SystemService\ is introduced, providing a \/system/health\ endpoint that returns the host's IP address, alongside utility functions for host and IP resolution.

packages/core/minos-microservice-networks/minos/networks · high confidence

A new \minos.networks.http\ module has been added, introducing \HttpAdapter\, \HttpConnector\, and \HttpPort\ classes to handle HTTP networking. This includes new \HttpRequest\ and \HttpResponse\ abstractions, allowing users to build and manage HTTP-based microservice interactions through a dedicated, structured interface.

packages/core/minos-microservice-networks/minos/networks/http · high confidence

The \minos.aggregate\ module has been restructured and expanded to support the new aggregate pattern. This includes the introduction of an \Aggregate\ base service class that coordinates transaction, event, and snapshot repositories. The module now exposes a comprehensive set of classes for managing entities, events, and snapshots, including \IncrementalSet\ for tracking changes to collections. Additionally, the \Condition\ query builder now supports a \LIKE\ operator for pattern matching in queries, and a new \RefException\ has been added to handle reference resolution errors.

packages/core/minos-microservice-aggregate/minos/aggregate · high confidence

The \minos.common.injections\ module has been added, introducing a new dependency injection framework. This includes the \InjectableMixin\ base class for injectable components, \Injectable\ and \Inject\ decorators for class and function injection, and a \DependencyInjector\ class to manage the lifecycle (wire, setup, destroy) of these dependencies. This change replaces the previous approach, as evidenced by the removal of the \dependency\_injector\ library from the CQRS package.

packages/core/minos-microservice-common/minos/common/injections · high confidence

The \minos.aggregate.events\ package now provides a dedicated module for managing domain events and their persistence. This includes an \Event\ model that captures field-level differences between \RootEntity\ states, a \FieldDiff\ system for tracking changes, and an \EventEntry\ class for database representation. Additionally, the diff introduces an \EventRepository\ interface along with an \InMemoryEventRepository\ implementation, allowing users to store and retrieve events using a consistent API.

packages/core/minos-microservice-aggregate/minos/aggregate/events · high confidence

The scheduling module now exposes a new \CronTab\ class for parsing and iterating over cron expressions, along with a \PeriodicTask\ and \PeriodicTaskScheduler\ to manage the lifecycle of scheduled jobs. A \PeriodicPort\ is provided to integrate this scheduler into the network, while \ScheduledRequest\ and \ScheduledResponseException\ handle the request/response types for these scheduled executions. Additionally, the legacy \PeriodicTaskSchedulerService\ is now deprecated in favor of the new \PeriodicPort\.

packages/core/minos-microservice-networks/minos/networks/scheduling · high confidence

The \minos.networks.requests\ module now provides core abstractions for handling network interactions. The \Response\ class includes a \status\ attribute (defaulting to 200) to represent HTTP status codes, and \ResponseException\ also carries a status code. Two concrete request implementations are added: \InMemoryRequest\ for testing and lightweight scenarios, and \WrappedRequest\ which allows wrapping another \Request\ with custom content and params transformation actions.

packages/core/minos-microservice-networks/minos/networks/requests · high confidence

The \minos.saga.definitions\ package now provides the core data models for defining sagas. This includes the \Saga\ class to manage sequences of operations, and distinct step types (\LocalSagaStep\, \RemoteSagaStep\, \ConditionalSagaStep\) that define how local and remote microservices interact. The \SagaOperation\ class encapsulates callbacks and parameters, while the \types\ module defines callable signatures for request, response, and local callbacks. These changes enable users to construct and validate complex distributed transaction flows.

packages/core/minos-microservice-saga/minos/saga/definitions · high confidence

The \minos/saga/executions\ module now provides the core classes for managing saga lifecycles and transactional consistency. This includes the \SagaExecution\ class to track execution state and steps, the \SagaStatus\ and \SagaStepStatus\ enumerations to define the current state of a saga and its steps, and the \TransactionCommitter\ to handle commit, reject, and reserve operations via the broker. Additionally, the module exposes the \Executor\ hierarchy (\LocalExecutor\, \RequestExecutor\, \ResponseExecutor\) and the \DatabaseSagaExecutionRepository\ interface for persistence.

packages/core/minos-microservice-saga/minos/saga/executions · high confidence

The \minos-microservice-networks\ package now exposes a dedicated \definitions\ subpackage that centralizes the type system for enroute decorators. This includes an abstract \EnrouteDecorator\ base class, specific implementations for broker-based commands/queries/events, HTTP-based routing, and periodic (cron) event handling. Additionally, a \CheckDecorator\ is provided to manage handler validation and retry logic. These classes define the metadata and behavior for routing and scheduling, enabling the framework to automatically handle pre/post execution hooks and periodic task execution.

packages/core/minos-microservice-networks/minos/networks/decorators/definitions · high confidence

The \minos.common.model.types\ package now provides a comprehensive set of tools for handling Python type hints. This includes \TypeHintBuilder\ and \TypeHintParser\ for constructing and parsing type hints, \TypeHintComparator\ for comparing types (including generic types and model subclasses), and \GenericTypeProjector\ for resolving generic type variables. These components enable more robust type checking and resolution within the microservice framework.

packages/core/minos-microservice-common/minos/common/model/types · high confidence

The configuration system now uses a versioned abstraction, introducing \ConfigV1\ and \ConfigV2\ classes that implement the new \Config\ base class. This change allows the framework to support multiple configuration formats, with the \Config\ factory automatically selecting the appropriate version based on the config file's version field. Users can now define configurations using either the legacy V1 format or the new V2 format, enabling a smoother transition and future-proofing the configuration structure.

packages/core/minos-microservice-common/minos/common/config · high confidence

The \minos-microservice-cqrs\ package now provides a structured CQRS (Command Query Responsibility Segregation) implementation. Users can inherit from \CommandService\ or \QueryService\ to define endpoints, with automatic routing via the \HandlerWrapper\ protocol. The \PreEventHandler\ handles reference resolution for events, controlled by the \resolve\_references\ parameter (defaulting to \False\). This introduces a new way to build microservices with clear separation between commands and queries, leveraging the \minos.networks\ request handling and \minos.common\ configuration.

packages/core/minos-microservice-cqrs/minos · high confidence

The \minos.aggregate.entities.refs\ package introduces a new \Ref\ model class that wraps a model's UUID and provides access to its data. This package also adds \RefExtractor\ to identify model references within data structures, \RefInjector\ to replace UUIDs with actual model instances, and \RefResolver\ to coordinate the extraction, querying, and injection process using a \BrokerClientPool\ for asynchronous resolution.

packages/core/minos-microservice-aggregate/minos/aggregate/entities/refs · high confidence

The \minos.plugins.aiohttp\ module has been introduced, providing an \AioHttpConnector\ and associated request/response classes (\AioHttpRequest\, \AioHttpResponse\) to enable HTTP interactions via the aiohttp library. This change adds a new plugin implementation for handling HTTP requests and responses within the Minos framework.

packages/plugins/minos-http-aiohttp/minos/plugins/aiohttp · high confidence

Added the core transaction management infrastructure, including the \TransactionService\ which exposes broker commands for reserving, committing, and rejecting transactions, along with the \TransactionEntry\ model that handles transaction state and context. The change also introduces the \DatabaseTransactionRepository\ and \InMemoryTransactionRepository\ for persistence, alongside supporting context variables and entry definitions to enable reliable transactional workflows.

packages/core/minos-microservice-aggregate/minos/aggregate/transactions · high confidence

The wallet microservice now provides a command API allowing users to create new wallets and add stock tickers to them. The service exposes two POST endpoints: one at /wallet to create a new wallet instance, and another at /wallet/ticker to add a specific ticker with a flag to an existing wallet. This introduces the core wallet management functionality within the microservice architecture.

tutorials/stock-wallet/microservices/wallet/src · high confidence

The aiopg plugin now includes \AiopgLockDatabaseOperationFactory\ and \AiopgManagementDatabaseOperationFactory\ implementations that register with \AiopgDatabaseClient\ to handle PostgreSQL advisory locking and database creation/deletion operations.

packages/plugins/minos-database-aiopg/minos/plugins/aiopg/factories/common · high confidence

The saga execution storage has been refactored to use a new \SagaExecutionRepository\ interface, which defines standard operations for storing, loading, and deleting saga executions. A concrete \DatabaseSagaExecutionRepository\ implementation is provided, which uses a \SagaExecutionDatabaseOperationFactory\ to build and execute database operations. This change introduces a cleaner separation between the repository interface and its database-specific implementation, allowing for easier testing and potential future storage backends.

packages/core/minos-microservice-saga/minos/saga/executions/repositories · high confidence

The \minos/aggregate/snapshots\ module now exposes a \SnapshotService\ that handles retrieving and synchronizing \RootEntity\ snapshots via broker commands and periodic tasks. The \SnapshotEntry\ class provides the data structure for storing and reconstructing \RootEntity\ instances, including methods to build entities from events or raw data. This change integrates \AiopgSnapshotRepositoryOperationFactory\ and \PostgreSqlSnapshotQueryBuilder\ for database operations, while simplifying the module by removing older database-specific classes like \DatabaseSnapshotReader\ and \DatabaseSnapshotWriter\.

packages/core/minos-microservice-aggregate/minos/aggregate/snapshots · high confidence

A new abstract \DatabaseClient\ base class has been introduced, providing a standardized interface for database clients. This includes a factory registration system via \set\_factory\ and \get\_factory\ methods, allowing clients to register and retrieve operation factory implementations. The change also introduces a dedicated exception hierarchy (\DatabaseClientException\, \ConnectionException\, \IntegrityException\, \ProgrammingException\) to handle database-specific errors. This refactors how database operations are executed and managed, moving away from concrete implementations like \AiopgDatabaseClient\ to a more flexible, abstracted approach.

packages/core/minos-microservice-common/minos/common/database/clients · high confidence

The previous PostgreSQL-specific transaction repository has been refactored into a generic \DatabaseTransactionRepository\ that relies on a \TransactionDatabaseOperationFactory\ interface. This change allows the transaction repository to support multiple database backends rather than being locked to PostgreSQL, as the database operations are now abstracted behind the factory pattern.

packages/core/minos-microservice-aggregate/minos/aggregate/transactions/repositories/database · medium confidence

The \minos-microservice-aggregate\ package now provides a database-backed event repository implementation (\DatabaseEventRepository\) that uses a new \EventDatabaseOperationFactory\ abstraction. This change replaces previous PostgreSQL-specific classes with a generic \DatabaseOperation\ interface, allowing the repository to interact with different database backends through configurable operation factories rather than hardcoded SQL queries.

packages/core/minos-microservice-aggregate/minos/aggregate/events/repositories/database · medium confidence

The database module now exposes a set of generic, database-agnostic classes to manage connections and operations. Users can now utilize \DatabaseClient\ and \DatabaseClientPool\ for connection pooling, \DatabaseMixin\ for reusable database interaction logic, and \DatabaseOperation\/\DatabaseOperationFactory\ to define and execute database operations. This refactoring replaces previous PostgreSQL-specific implementations (such as \PostgreSqlMinosDatabase\ and \PostgreSqlLock\) with these new base classes, allowing for broader database support and improved code reuse across different database backends.

packages/core/minos-microservice-common/minos/common/database · medium confidence

The broker communication layer has been refactored to support multiple database backends and in-memory queues. A new \BrokerMessage\ model and its \v1\ implementation provide a structured way to handle message headers, payloads, and status. Concurrently, the \BrokerQueue\ interface and its \DatabaseBrokerQueue\ and \InMemoryBrokerQueue\ implementations allow for flexible message storage and retrieval, with the database variant supporting configurable retry and record limits.

packages/core/minos-microservice-networks/minos/networks/brokers/collections · high confidence

The Kafka broker plugin now includes a \KafkaCircuitBreakerMixin\ that wraps Kafka-specific errors (like \ConsumerStoppedError\) in the publisher and subscriber implementations, improving resilience against transient failures. Additionally, the plugin introduces \KafkaBrokerBuilderMixin\ and dedicated builder classes (\KafkaBrokerPublisherBuilder\, \KafkaBrokerSubscriberBuilder\) to streamline configuration and instantiation, while also exposing the core classes (\KafkaBrokerPublisher\, \KafkaBrokerSubscriber\) and mixins via the \\_\init\\_.py\ module.

packages/plugins/minos-broker-kafka/minos/plugins/kafka · medium confidence

The project has migrated its build system from \setup.py\ and \setup.cfg\ to \Poetry\, introducing a \poetry.toml\ and updating the \Makefile\ to use \poetry install\ and \poetry run\. The \pre-commit\ configuration (\.pre-commit-config.yaml\) has been significantly expanded to include local hooks for checking multiple microservice packages (aggregate, common, cqrs, networks, saga, broker, database, discovery, http, router) and plugins (kafka, rabbitmq, graphql). Additionally, the repository has adopted a Contributor Covenant Code of Conduct, updated the \.gitignore\ with a comprehensive template, and removed legacy files like \bitbucket-pipelines.yml\ and \MANIFEST.in\.

(repo-wide) · high confidence

The database snapshot repository has been refactored to use a new \SnapshotDatabaseOperationFactory\ pattern, replacing the previous \DatabaseSnapshotReader\, \DatabaseSnapshotWriter\, and \DatabaseSnapshotSetup\ components. The \DatabaseSnapshotRepository\ now relies on this factory to build database operations for creating tables, submitting snapshots, querying data, and managing offsets. This change simplifies the module hierarchy and introduces support for multiple databases via a \database\_key\ configuration. The implementation also includes updated method names for database execution (\execute\_on\_database\, \execute\_on\_database\_and\_fetch\_one\, \execute\_on\_database\_and\_fetch\_all\) and integrates with the event and transaction repositories for synchronization.

packages/core/minos-microservice-aggregate/minos/aggregate/snapshots/repositories/database · high confidence

The snapshot repository has been refactored to provide a unified \SnapshotRepository\ interface with concrete implementations for both in-memory and database-backed storage. Users can now access \InMemorySnapshotRepository\ for testing or lightweight scenarios, while the \DatabaseSnapshotRepository\ handles persistent storage. The refactoring simplifies the module by removing the previous \DatabaseSnapshotReader\, \DatabaseSnapshotWriter\, and \DatabaseSnapshotSetup\ classes, replacing them with a cleaner abstraction that supports querying, ordering, and filtering of \RootEntity\ snapshots.

packages/core/minos-microservice-aggregate/minos/aggregate/snapshots/repositories · medium confidence

The top-level \_\init\\_.py file for the minos package has been removed. This file previously defined package metadata such as the author, email, and version number. Its removal suggests a restructuring of the package's initialization or a shift in how package-level attributes are managed.

minos · high confidence

The \entities\ module has been reorganized, moving \models.py\ and \collections.py\ into the \entities\ package and exposing \Entity\, \ExternalEntity\, and \RootEntity\ via \\_\init\\_.py\. \RootEntity\ now includes \get\_all\ and \find\ class methods that query the snapshot repository, enabling retrieval of all instances or filtered sets based on conditions. Additionally, \EntitySet\ has been updated to support hashable entity instances, fixing a previous bug where non-hashable entities caused failures in set operations.

packages/core/minos-microservice-aggregate/minos/aggregate/entities · high confidence

Add comprehensive unit tests for the Config class; Add test coverage for network components; Add tests for transaction repository implementations; Add unit and integration tests for RabbitMQ broker plugin; Added AsyncAPI and OpenAPI specification generation services; Added mocked broker operation factories for testing; Added test coverage for AsyncAPI and OpenAPI specification generation; Added test coverage for Avro serialization components; Added test coverage for aggregate core components; Added test coverage for declarative model behavior; Added test coverage for network decorator definitions; Added test fixtures for HTTP and Broker services; Added test infrastructure and mock classes for the microservice common library; Added test infrastructure for minos-discovery-kong plugin; Added test infrastructure for the aggregate module; Added test suites for aggregate repositories; Added test utilities and configuration for the CQRS module; Added test utilities and configuration for the saga microservice; Added testing utilities for database operations; Added tests for AioHttpConnector and AioHttpRequest; Added tests for BrokerRequest, BrokerResponse, and BrokerDispatcher; Added tests for ConfigV1 configuration parsing; Added tests for ConfigV2 configuration parsing; Added tests for EntitySet and EntitySetDiff; Added tests for Event, EventEntry, and FieldDiffContainer; Added tests for HTTP network components; Added tests for LmdbDatabaseClient and LmdbSagaExecutionDatabaseOperationFactory; Added tests for Minos Kong plugin components; Added tests for MinosDiscoveryClient; Added tests for Ref, RefExtractor, RefInjector, and RefResolver; Added tests for SnapshotEntry and SnapshotService; Added tests for SystemService; Added tests for aiopg database client and operations; Added tests for aiopg database operation factories; Added tests for broker client and pool functionality; Added tests for broker handler implementation and port interfaces; Added tests for broker queue implementations; Added tests for broker subscriber components; Added tests for database-related components; Added tests for dependency injection and injection decorators; Added tests for discovery client implementations; Added tests for enroute decorator factories and collectors; Added tests for event repositories; Added tests for filtered broker subscribers and duplicate validators; Added tests for queued broker publisher and queue implementations; Added tests for queued broker subscriber implementations; Added tests for root entity models and database integration; Added tests for saga core components; Added tests for saga execution repository and database operations; Added tests for the DiscoveryConnector component; Added tests for the Minos GraphQL plugin; Added tests for the QueuedBrokerSubscriber implementation; Added tests for transaction entry and service logic; Added unit tests for CQRS handlers and services; Added unit tests for broker publisher components; Added unit tests for core common components; Added unit tests for core microservice components; Added unit tests for database client and operation classes; Added unit tests for minos-microservice-networks; Added unit tests for model type utilities; Added unit tests for network request and response classes; Added unit tests for saga execution and executor components; Added unit tests for saga step execution logic; Added unit tests for snapshot repository implementations; Added unit tests for the stocks microservice; Added unit tests for the wallet command service; Added unit tests for wallet query services; Removed obsolete test files.

The Minos microservice packages (minos-microservice-common, -aggregate, -networks, -saga, -cqrs, and the Kafka/RabbitMQ/aiopg plugins) have been updated to version 0.7.0. This update aligns the core libraries with the latest \minos-microservice-common\ and \minos-microservice-networks\ dependencies, ensuring compatibility across the framework's microservice components.

(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 49.

• Code Health 94
• Architecture 95
• Maturity 62
• Readiness 62
• Security 23
• Domain Modelling 100

• 300 commits — 267 feature/other, 33 fixes

• packages/core — 143 commits
• (repo) — 77 commits
• packages/plugins — 66 commits
• (root) — 11 commits
• .github/workflows — 3 commits

• fix: * Fix bug related with dependency constraints (2).
• fix: * Minor fix.
• fix: ISSUE #144 * Fix naming bug
• fix: ISSUE #346 * Fix broken tests.
• fix: ISSUE #346 * Fix bug related with a blocking status related with pool dependencies.
• fix: ISSUE #346 * Increase coverage. * Fix bug related with PostgresAsyncTestCase.
• fix: ISSUE #367 * Fix broken tests. * Work on the multi-database case.
• fix: ISSUE #367 * Fix bug.
• fix: ISSUE #367 * Fix minor bugs.
• fix: ISSUE #371 * Fix broken tests.
• fix: ISSUE #371 * Fix bug related with a query.
• fix: ISSUE #371 * Fix bugs.
• fix: ISSUE #371 * Fix minor bugs.
• fix: ISSUE #415 * Fix bug related with pyparsing import instead of typing.
• fix: ISSUE #416 * Fix bug related with poetry's include.
• fix: ISSUE #442 * Fix bug related with locking and ComposedDatabaseOperation.
• fix: ISSUE #446 * Fix bug related with non-hashable Entity instances within EntitySet.
• fix: ISSUE #98 * Fix broken test.
• fix: ISSUE #98 * Fix broken tests on minos-microservice-networks.
• fix: ISSUE #98 * Fix broken tests.
• …and 280 more

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

minos-framework/minos-python 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.