neuroglia-python 0.0.23__py3-none-any.whl

neuroglia/data/infrastructure/event_sourcing/event_store/event_store.py

@@ -0,0 +1,175 @@
+import inspect
+import logging
+import sys
+import threading
+from typing import Dict, List, Optional
+import rx
+from rx.disposable.disposable import Disposable
+from neuroglia.data.abstractions import DomainEvent
+from neuroglia.data.infrastructure.event_sourcing.abstractions import Aggregator, EventDescriptor, EventRecord, EventStore, EventStoreOptions, StreamDescriptor, StreamReadDirection
+from neuroglia.hosting.abstractions import ApplicationBuilderBase
+from neuroglia.serialization.json import JsonSerializer
+from esdbclient import EventStoreDBClient, NewEvent, StreamState, RecordedEvent
+from esdbclient.exceptions import AlreadyExists
+from rx import Observable
+from rx.subject import Subject
+
+
+class ESEventStore(EventStore):
+    ''' Represents the EventStore.com implementation of the EventStore abstract class '''
+
+    _metadata_type = 'type'
+    ''' Gets the name of the metadata attribute used to store the qualified name of the recorded event's type ('{module_name}.{type_name}')  '''
+
+    _eventstore_options: EventStoreOptions
+    ''' Gets the options used to configure the EventStore '''
+
+    _eventstore_client: EventStoreDBClient
+    ''' Gets the service used to interact with the EventStore DB'''
+
+    _serializer: JsonSerializer
+    ''' Gets the service used to serialize/deserialize objects to/from JSON'''
+
+    def __init__(self, options: EventStoreOptions, eventstore_client: EventStoreDBClient, serializer: JsonSerializer):
+        self._eventstore_options = options
+        self._eventstore_client = eventstore_client
+        self._serializer = serializer
+
+    async def contains_async(self, stream_id: str) -> bool: return await self.get_async(stream_id) != None
+
+    async def append_async(self, stream_id: str, events: List[EventDescriptor], expected_version: Optional[int] = None):
+        if expected_version is not None:
+            expected_version = expected_version - 1
+        stream_name = self._get_stream_name(stream_id)
+        stream_state = StreamState.NO_STREAM if expected_version is None else expected_version
+        formatted_events = [NewEvent
+                            (
+                                type=e.type,
+                                data=None if e.data == None else self._serializer.serialize(e.data),
+                                metadata=self._serializer.serialize(self._build_event_metadata(e.data, e.metadata))
+                            )
+                            for e in events]
+        self._eventstore_client.append_to_stream(stream_name=stream_name, current_version=stream_state, events=formatted_events)
+
+    async def get_async(self, stream_id: str) -> Optional[StreamDescriptor]:
+        stream_name = self._get_stream_name(stream_id)
+        metadata, metadata_version = self._eventstore_client.get_stream_metadata(stream_name)
+        if metadata_version == StreamState.NO_STREAM:
+            return None
+        truncate_before = metadata.get('$tb')
+        offset = 0 if truncate_before is None else truncate_before
+        read_response = self._eventstore_client.read_stream(
+            stream_name=stream_name,
+            stream_position=offset,
+            backwards=False,
+            resolve_links=True,
+            limit=1
+        )
+        recorded_events = tuple(read_response)
+        first_event = recorded_events[0]
+        read_response = self._eventstore_client.read_stream(
+            stream_name=stream_name,
+            stream_position=offset,
+            backwards=True,
+            resolve_links=True,
+            limit=1
+        )
+        recorded_events = tuple(read_response)
+        last_event = recorded_events[0]
+        return StreamDescriptor(stream_id, last_event.stream_position, None, None)  # todo: esdbclient does not provide timestamps
+
+    async def read_async(self, stream_id: str, read_direction: StreamReadDirection, offset: int, length: Optional[int] = None) -> List[EventRecord]:
+        stream_name = self._get_stream_name(stream_id)
+        read_response = self._eventstore_client.read_stream(
+            stream_name=stream_name,
+            stream_position=offset,
+            backwards=True if read_direction == StreamReadDirection.BACKWARDS else False,
+            resolve_links=True,
+            limit=sys.maxsize if length is None else length
+        )
+        recorded_events = tuple(read_response)
+        return [self._decode_recorded_event(stream_id, recorded_event) for recorded_event in recorded_events]
+
+    async def observe_async(self, stream_id: Optional[str], consumer_group: Optional[str] = None, offset: Optional[int] = None) -> Observable:
+        stream_name = self._get_stream_name(stream_id)
+        subscription = None
+        if consumer_group is None:
+            subscription = self._eventstore_client.subscribe_to_stream(stream_name=stream_name, resolve_links=True, stream_position=offset)
+        else:
+            try:
+                self._eventstore_client.create_subscription_to_stream(stream_name=stream_name, resolve_links=True)  # todo: persistence
+            except AlreadyExists:
+                pass
+        subject = Subject()
+        thread = threading.Thread(target=self._consume_events_async, kwargs={'stream_id': stream_id, 'subject': subject, 'subscription': subscription})
+        thread.start()
+        return rx.using(lambda: Disposable(lambda: subscription.stop()), lambda s: subject)
+
+    def _build_event_metadata(self, e: DomainEvent, additional_metadata: Optional[any]):
+        module_name = inspect.getmodule(e).__name__
+        type_name = type(e).__name__
+        metadata = {self._metadata_type: f'{module_name}.{type_name}'}
+        if additional_metadata != None:
+            if isinstance(additional_metadata, dict):
+                metadata.update(additional_metadata)
+            elif hasattr(additional_metadata, '__dict__'):
+                metadata.update(additional_metadata.__dict__)
+            else:
+                raise Exception()
+        return metadata
+
+    def _decode_recorded_event(self, stream_id: str, e: RecordedEvent) -> EventRecord:
+        text = e.metadata.decode()
+        metadata = self._serializer.deserialize_from_text(text)
+        type_qualified_name_parts = metadata[self._metadata_type].split('.')
+        module_name = '.'.join(type_qualified_name_parts[:-1])
+        type_name = type_qualified_name_parts[-1]
+        module = __import__(module_name, fromlist=[type_name])
+        expected_type = getattr(module, type_name)
+        text = e.data.decode()
+        data = None if text is None or text.isspace() else self._serializer.deserialize_from_text(text, expected_type)
+        if isinstance(data, Dict) and not isinstance(data, expected_type):
+            typed_data = expected_type.__new__(expected_type)
+            typed_data.__dict__ = data
+            data = typed_data
+        return EventRecord(stream_id=stream_id, id=e.id, offset=e.stream_position, position=e.commit_position, timestamp=None, type=e.type, data=data, metadata=metadata)
+
+    def _get_stream_name(self, stream_id: str) -> str:
+        ''' Converts the specified stream id to a qualified stream id, which is prefixed with the current database name, if any '''
+        return stream_id if self._eventstore_options.database_name is None or stream_id.startswith('$ce-') else f'{self._eventstore_options.database_name}-{stream_id}'
+
+    def _consume_events_async(self, stream_id: str, subject: Subject, subscription):
+        ''' Asynchronously enumerate events returned by a subscription '''
+        try:
+            e: RecordedEvent
+            for e in subscription:
+                try:
+                    decoded_event = self._decode_recorded_event(stream_id, e)
+                except Exception as ex:
+                    logging.error(f"An exception occured while decoding event with offset '{e.stream_position}' from stream '{e.stream_name}': {ex}")
+                    raise
+                try:
+                    subject.on_next(decoded_event)
+                except Exception as ex:
+                    logging.error(f"An exception occured while handling event with offset '{e.stream_position}' from stream '{e.stream_name}': {ex}")
+                    raise
+            subject.on_completed()
+        except Exception as ex:
+            logging.error(f"An exception occured while consuming events from stream '{stream_id}', consequently to which the related subscription will be stopped: {ex}")  # todo: improve feedback
+            subscription.stop()
+
+    def configure(builder: ApplicationBuilderBase, options: EventStoreOptions) -> ApplicationBuilderBase:
+        ''' Registers and configures an EventStore implementation of the EventStore class.
+
+            Args:
+                services (ServiceCollection): the service collection to configure
+        '''
+        connection_string_name = "eventstore"
+        connection_string = builder.settings.connection_strings.get(connection_string_name, None)
+        if connection_string is None:
+            raise Exception(f"Missing '{connection_string_name}' connection string")
+        builder.services.try_add_singleton(Aggregator)
+        builder.services.try_add_singleton(EventStoreOptions, singleton=options)
+        builder.services.try_add_singleton(EventStoreDBClient, singleton=EventStoreDBClient(uri=connection_string))
+        builder.services.try_add_singleton(EventStore, ESEventStore)
+        return builder

neuroglia/data/infrastructure/event_sourcing/read_model_reconciliator.py

@@ -0,0 +1,62 @@
+import asyncio
+from dataclasses import dataclass
+import logging
+from rx.core.typing import Disposable
+from neuroglia.data.infrastructure.event_sourcing.abstractions import EventRecord, EventStore, EventStoreOptions
+from neuroglia.dependency_injection.service_provider import ServiceProviderBase
+from neuroglia.hosting.abstractions import HostedService
+from neuroglia.mediation.mediator import Mediator
+from neuroglia.reactive import AsyncRx
+
+
+@dataclass
+class ReadModelConciliationOptions:
+    ''' Represents the options used to configure the application's read model reconciliation features '''
+
+    consumer_group: str
+    ''' Gets the name of the group of consumers the application's read model is maintained by '''
+
+
+class ReadModelReconciliator(HostedService):
+    ''' Represents the service used to reconciliate the read model by streaming and handling events recorded on the application's event store '''
+
+    _service_provider: ServiceProviderBase
+    ''' Gets the current service provider '''
+
+    _mediator: Mediator
+
+    _event_store_options: EventStoreOptions
+    ''' Gets the options used to configure the event store '''
+
+    _event_store: EventStore
+    ''' Gets the service used to persist and stream domain events '''
+
+    _subscription: Disposable
+
+    def __init__(self, service_provider: ServiceProviderBase, mediator: Mediator, event_store_options: EventStoreOptions, event_store: EventStore):
+        self._service_provider = service_provider
+        self._mediator = mediator
+        self._event_store_options = event_store_options
+        self._event_store = event_store
+
+    async def start_async(self):
+        await self.subscribe_async()
+
+    async def stop_async(self):
+        self._subscription.dispose()
+
+    async def subscribe_async(self):
+        observable = await self._event_store.observe_async(f'$ce-{self._event_store_options.database_name}')
+        self._subscription = AsyncRx.subscribe(observable, lambda e: asyncio.run(self.on_event_record_stream_next_async(e)))
+
+    async def on_event_record_stream_next_async(self, e: EventRecord):
+        try:
+            # todo: migrate event
+            await self._mediator.publish_async(e.data)
+            # todo: ack
+        except Exception as ex:
+            logging.error(f"An exception occured while publishing an event of type '{type(e.data).__name__}': {ex}")
+            pass  # todo: nack
+
+    async def on_event_record_stream_error(self, ex: Exception):
+        await self.subscribe_async()

neuroglia/data/infrastructure/memory/__init__.py

@@ -0,0 +1 @@
+from .memory_repository import MemoryRepository as MemoryRepository

neuroglia/data/infrastructure/memory/memory_repository.py

@@ -0,0 +1,29 @@
+from typing import Optional
+from neuroglia.data.infrastructure.abstractions import Repository
+from neuroglia.data.abstractions import TEntity, TKey
+
+
+class MemoryRepository(Repository[TEntity, TKey]):
+
+    entities: dict = {}
+
+    async def contains_async(self, id: TKey) -> bool:
+        return self.entities.get(id) is not None
+
+    async def get_async(self, id: TKey) -> Optional[TEntity]:
+        return self.entities.get(id, None)
+
+    async def add_async(self, entity: TEntity) -> TEntity:
+        if entity.id in self.entities:
+            raise Exception()
+        self.entities[entity.id] = entity
+        return entity
+
+    async def update_async(self, entity: TEntity) -> TEntity:
+        self.entities[entity.id] = entity
+        return entity
+
+    async def remove_async(self, id: TKey) -> None:
+        if not id in self.entities:
+            raise Exception()
+        del self.entities[id]

neuroglia/data/infrastructure/mongo/mongo_repository.py

@@ -0,0 +1,331 @@
+import ast
+from inspect import isclass
+import pymongo
+from ast import NodeVisitor, expr
+from dataclasses import dataclass
+from neuroglia.data.queryable import T, QueryProvider, Queryable
+from neuroglia.data.infrastructure.abstractions import FlexibleRepository, QueryableRepository, Repository
+from neuroglia.data.abstractions import TEntity, TKey, VersionedState
+from pymongo import MongoClient
+from pymongo.collection import Collection
+from pymongo.cursor import Cursor
+from pymongo.database import Database
+from typing import Any, Dict, Generic, Optional, List, Type
+from neuroglia.expressions.javascript_expression_translator import JavaScriptExpressionTranslator
+from neuroglia.hosting.abstractions import ApplicationBuilderBase
+from neuroglia.serialization.json import JsonSerializer
+
+
+@dataclass
+class MongoRepositoryOptions(Generic[TEntity, TKey]):
+    ''' Represents the options used to configure a Mongo repository '''
+
+    database_name: str
+    ''' Gets the name of the Mongo database to use '''
+
+
+class MongoQuery(Generic[T], Queryable[T]):
+    ''' Represents a Mongo query '''
+
+    def __init__(self, query_provider: 'MongoQueryProvider', expression: Optional[expr] = None):
+        super().__init__(query_provider, expression)
+
+
+class MongoQueryBuilder(NodeVisitor):
+    ''' Represents the service used to build mongo queries '''
+
+    def __init__(self, collection: Collection, translator: JavaScriptExpressionTranslator):
+        self._collection = collection
+        self._translator = translator
+
+    _collection: Collection
+
+    _translator: JavaScriptExpressionTranslator
+
+    _order_by_clauses: Dict[str, int] = dict[str, int]()
+
+    _select_clause: Optional[List[str]] = None
+
+    _skip_clause: Optional[int] = None
+
+    _take_clause: Optional[int] = None
+
+    _where_clauses: List[str] = list[str]()
+
+    def build(self, expression: expr) -> Cursor:
+        self.visit(expression)
+        cursor: Cursor = self._collection.find(projection=self._select_clause)
+        if len(self._order_by_clauses) > 0:
+            cursor = cursor.sort(self._order_by_clauses)
+        if len(self._where_clauses) > 0:
+            cursor = cursor.where(" && ".join(self._where_clauses))
+        if self._skip_clause is not None:
+            cursor = cursor.skip(self._skip_clause)
+        if self._take_clause is not None:
+            cursor = cursor.limit(self._take_clause)
+        return cursor
+
+    def visit_Call(self, node):
+        clause = node.func.attr
+        expression = node.args[0]
+        self.visit(node.func.value)
+        javascript = self._translator.translate(expression)
+        if clause == "distinct_by":
+            self._distinct_by_clauses.append(javascript.replace("this.", ""))
+        elif clause == "first":
+            self._where_clauses.append(javascript)
+            self._take_clause = 1
+        elif clause == "last":
+            self._where_clauses.append(javascript)
+            self._take_clause = 1
+            # todo: could be anything, really
+            self._order_by_clauses["created_at"] = pymongo.DESCENDING
+        elif clause == "order_by":
+            self._order_by_clauses[javascript.replace(
+                "this.", "")] = pymongo.ASCENDING
+        elif clause == "order_by_descending":
+            self._order_by_clauses[javascript.replace(
+                "this.", "")] = pymongo.DESCENDING
+        elif clause == "select" and isinstance(expression.body, ast.List):
+            self._select_clause = [self._translator.translate(
+                elt).replace("this.", "") for elt in expression.body.elts]
+        elif clause == "skip" and isinstance(expression, ast.Constant):
+            self._skip_clause = expression.value
+        elif clause == "take" and isinstance(expression, ast.Constant):
+            self._take_clause = expression.value
+        elif clause == "where":
+            self._where_clauses.append(javascript)
+        pass
+
+
+class MongoQueryProvider(QueryProvider):
+    ''' Represents the Mongo implementation of the QueryProvider '''
+
+    def __init__(self, collection: Collection):
+        self._collection = collection
+
+    _collection: Collection
+
+    def create_query(self, element_type: Type,
+                     expression: expr) -> Queryable: return MongoQuery[element_type](self, expression)
+
+    def execute(self, expression: expr, query_type: Type) -> Any:
+        query = MongoQueryBuilder(
+            self._collection, JavaScriptExpressionTranslator()).build(expression)
+        type_ = query_type if isclass(
+            query_type) or query_type == List else type(query_type)
+        if issubclass(type_, List):
+            return list(query)
+        else:
+            return next(query, None)
+
+
+class MongoRepository(Generic[TEntity, TKey], QueryableRepository[TEntity, TKey]):
+    ''' Represents a Mongo implementation of the repository class '''
+
+    def __init__(self, options: MongoRepositoryOptions[TEntity, TKey], mongo_client: MongoClient, serializer: JsonSerializer):
+        ''' Initializes a new Mongo repository '''
+        self._options = options
+        self._mongo_client = mongo_client
+        self._mongo_database = self._mongo_client[self._options.database_name]
+        self._serializer = serializer
+        self._collection_name = None
+
+    _options: MongoRepositoryOptions[TEntity, TKey]
+    ''' Gets the options used to configure the Mongo repository '''
+
+    _mongo_client: MongoClient
+    ''' Gets the service used to interact with Mongo '''
+
+    _mongo_database: Database
+    ''' Gets the Mongo database to use '''
+
+    _serializer: JsonSerializer
+    ''' Gets the service used to serialize/deserialize to/from JSON '''
+
+    async def contains_async(self, id: TKey) -> bool: return self._get_mongo_collection().find_one({"id": id}, projection={"_id": 1})
+
+    async def get_async(self, id: TKey) -> Optional[TEntity]:
+        attributes_dictionary = self._get_mongo_collection().find_one({"id": id})
+        if (attributes_dictionary is None):
+            return None
+        json = self._serializer.serialize(attributes_dictionary)
+        entity = self._serializer.deserialize_from_text(json, self._get_entity_type())
+        return entity
+
+    async def add_async(self, entity: TEntity) -> TEntity:
+        if await self.contains_async(entity.id) is not None:
+            raise Exception(f"A {self._get_entity_type().__name__} with the specified id '{entity.id}' already exists")
+        json = self._serializer.serialize_to_text(entity)
+        attributes_dictionary = self._serializer.deserialize_from_text(
+            json, dict)
+        self._get_mongo_collection().insert_one(attributes_dictionary)
+        return entity
+
+    async def update_async(self, entity: TEntity) -> TEntity:
+        if not await self.contains_async(entity.id) is not None:
+            raise Exception(f"Failed to find a {self._get_entity_type().__name__} with the specified id '{entity.id}'")
+        query_filter = {"id": entity.id}
+        expected_version = entity.state_version if isinstance(
+            entity, VersionedState) else None
+        if expected_version is not None:
+            query_filter["state_version"] = expected_version
+        json = self._serializer.serialize_to_text(entity)
+        attributes_dictionary = self._serializer.deserialize_from_text(
+            json, dict)
+        self._get_mongo_collection().replace_one(query_filter, attributes_dictionary)
+        return entity
+
+    async def remove_async(self, id: TKey) -> None:
+        if not await self.contains_async(id) is not None:
+            raise Exception(f"Failed to find a {self._get_entity_type().__name__} with the specified id '{id}'")
+        self._get_mongo_collection().delete_one({"id": id})
+
+    async def query_async(self) -> Queryable[TEntity]: return MongoQuery[TEntity](MongoQueryProvider(self._get_mongo_collection()))
+
+    def _get_entity_type(self) -> str: return self.__orig_class__.__args__[0]
+
+    def _get_mongo_collection(self) -> Collection:
+        ''' Gets the Mongo collection to use '''
+        # to get the collection_name, we need to access 'self.__orig_class__', which is not yet available in __init__, thus the need for a function
+        collection_name = self._get_entity_type().__name__.lower()
+        if collection_name.endswith("dto"):
+            collection_name = collection_name[:-3]
+        return self._mongo_database[collection_name]
+
+    @staticmethod
+    def configure(builder: ApplicationBuilderBase, entity_type: Type, key_type: Type, database_name: str) -> ApplicationBuilderBase:
+        ''' Configures the specified application to use a Mongo repository implementation to manage the specified type of entity '''
+        connection_string_name = "mongo"
+        connection_string = builder.settings.connection_strings.get(
+            connection_string_name, None)
+        if connection_string is None:
+            raise Exception(
+                f"Missing '{connection_string_name}' connection string")
+        builder.services.try_add_singleton(MongoClient, singleton=MongoClient(connection_string))
+        builder.services.try_add_singleton(MongoRepositoryOptions[entity_type, key_type], singleton=MongoRepositoryOptions[entity_type, key_type](database_name))
+        builder.services.try_add_singleton(Repository[entity_type, key_type], MongoRepository[entity_type, key_type])
+        builder.services.try_add_singleton(QueryableRepository[entity_type, key_type], implementation_factory=lambda provider: provider.get_required_service(Repository[entity_type, key_type]))
+        return builder
+
+
+class FlexibleMongoRepository(MongoRepository[TEntity, TKey], FlexibleRepository[TEntity, TKey]):
+    ''' Represents a Mongo implementation of the flexible repository class '''
+
+    def __init__(self, mongo_client: MongoClient, serializer: JsonSerializer):
+        ''' Initializes a new Mongo repository '''
+        self._mongo_client = mongo_client
+        self._database_name = "NOTSETHERE"
+        self._mongo_database = self._mongo_client[self._database_name]
+        self._serializer = serializer
+        self._collection_name = ""
+
+    _mongo_client: MongoClient
+    ''' Gets the service used to interact with Mongo '''
+
+    _mongo_database: Database
+    ''' Gets the Mongo database to use '''
+
+    _serializer: JsonSerializer
+    ''' Gets the service used to serialize/deserialize to/from JSON '''
+
+    _collection_name: str
+    ''' Gets the name of the collection in which to CRUD the entity '''
+
+    async def set_database(self, database: str):
+        if not FlexibleMongoRepository._is_valid_database_name(database):
+            raise Exception(f"Database name {database} is invalid!")
+        self._database_name = database
+        self._mongo_database = self._mongo_client[self._database_name]
+
+    async def get_database(self) -> str:
+        return self._database_name
+
+    async def contains_by_collection_name_async(self, collection_name: str, id: TKey) -> bool:
+        if not FlexibleMongoRepository._is_valid_collection_name(collection_name):
+            raise Exception(f"Collection name {collection_name} is invalid!")
+        self._collection_name = collection_name
+        return self._get_mongo_collection().find_one({"id": id}, projection={"_id": 1})
+
+    async def get_by_collection_name_async(self, collection_name: str, id: TKey) -> Optional[TEntity]:
+        if not FlexibleMongoRepository._is_valid_collection_name(collection_name):
+            raise Exception(f"Collection name {collection_name} is invalid!")
+        self._collection_name = collection_name
+        return await self.get_async(id)
+
+    async def add_by_collection_name_async(self, collection_name: str, entity: TEntity) -> TEntity:
+        if not FlexibleMongoRepository._is_valid_collection_name(collection_name):
+            raise Exception(f"Collection name {collection_name} is invalid!")
+        self._collection_name = collection_name
+        return await self.add_async(entity)
+
+    async def update_by_collection_name_async(self, collection_name: str, entity: TEntity) -> TEntity:
+        if not FlexibleMongoRepository._is_valid_collection_name(collection_name):
+            raise Exception(f"Collection name {collection_name} is invalid!")
+        self._collection_name = collection_name
+        return await self.update_async(entity)
+
+    async def remove_by_collection_name_async(self, collection_name: str, id: TKey) -> None:
+        if not FlexibleMongoRepository._is_valid_collection_name(collection_name):
+            raise Exception(f"Collection name {collection_name} is invalid!")
+        self._collection_name = collection_name
+        return await self.remove_async(id)
+
+    async def query_by_collection_name_async(self, collection_name: str) -> Queryable[TEntity]:
+        return MongoQuery[TEntity](MongoQueryProvider(collection_name))
+
+    def _get_mongo_collection(self) -> Collection:
+        ''' Gets the Mongo collection to use '''
+        if self._collection_name is not None and self._collection_name != "":
+            return self._mongo_database[self._collection_name]
+        else:
+            collection_name = self._get_entity_type().__name__.lower()
+            if collection_name.endswith("dto"):
+                collection_name = collection_name[:-3]
+            return self._mongo_database[collection_name]
+
+    @staticmethod
+    def _is_valid_database_name(database_name: str) -> bool:
+        # https://www.mongodb.com/docs/manual/reference/limits/#naming-restrictions
+        # max 63chars, no `/\. "$*<>:|?`
+        assert len(database_name) < 64, f"Database name {database_name} is too long. Max 63chars."
+        assert "/" not in database_name, f"The char / (forward slash) may not be included in the database name."
+        # assert r"\ " not in database_name, f"The char \ (backward slash) may not be included in the database name."  # SyntaxWarning: invalid escape sequence
+        assert "." not in database_name, f"The char . (dot) may not be included in the database name."
+        assert " " not in database_name, f"Space char may not be included in the database name."
+        assert '"' not in database_name, f"Double quote char may not be included in the database name."
+        assert '$' not in database_name, f"Dollar sign char may not be included in the database name."
+        assert '*' not in database_name, f"Asterisk char may not be included in the database name."
+        assert '<' not in database_name, f"Less-than-sign char may not be included in the database name."
+        assert '>' not in database_name, f"Larger-than-sign char may not be included in the database name."
+        assert ':' not in database_name, f"Colon char may not be included in the database name."
+        assert '|' not in database_name, f"Pipe char may not be included in the database name."
+        assert '?' not in database_name, f"Question mark char may not be included in the database name."
+        return True
+
+    @staticmethod
+    def _is_valid_collection_name(collection_name: str) -> bool:
+        # https://www.mongodb.com/docs/manual/reference/limits/#naming-restrictions
+        assert len(collection_name) < 254, f"Collection name {collection_name} is too long. Max 243chars."
+        assert (collection_name[0] == '_' or collection_name[0].isalpha()), f"Collection name '{collection_name}' must start with either underscore or alphanumeric char."
+        assert not collection_name[0].isdigit(), f"Collection name '{collection_name}' must start with a digit."
+        assert '$' not in collection_name, f"Dollar sign char may not be included in the collection name '{collection_name}'."
+        assert collection_name != "", f"Collection name '{collection_name}' must not be the empty string."
+        assert "\0" not in collection_name, f"Collection name '{collection_name}' must not include the Null char."
+        assert not collection_name.startswith('system'), f"Collection name '{collection_name}' must not start with the word 'system'."
+        return True
+
+    @staticmethod
+    def configure(builder: ApplicationBuilderBase, entity_type: Type, key_type: Type, database_name: str) -> ApplicationBuilderBase:
+        ''' Configures the specified application to use a Mongo repository implementation to manage the specified type of entity '''
+        connection_string_name = "mongo"
+        connection_string = builder.settings.connection_strings.get(
+            connection_string_name, None)
+        if connection_string is None:
+            raise Exception(
+                f"Missing '{connection_string_name}' connection string")
+        builder.services.try_add_singleton(MongoClient, singleton=MongoClient(connection_string))
+        builder.services.try_add_singleton(MongoRepositoryOptions[entity_type, key_type], singleton=MongoRepositoryOptions[entity_type, key_type](database_name))
+        builder.services.try_add_singleton(Repository[entity_type, key_type], FlexibleMongoRepository[entity_type, key_type])
+        builder.services.try_add_singleton(FlexibleRepository[entity_type, key_type], implementation_factory=lambda provider: provider.get_required_service(Repository[entity_type, key_type]))
+        return builder

neuroglia/data/queries/generic/__init__.py

@@ -0,0 +1,2 @@
+from .get_by_id_query import *
+from .list_query import *

neuroglia/data/queries/generic/get_by_id_query.py

@@ -0,0 +1,30 @@
+from typing import Any, Generic
+from neuroglia.core.operation_result import OperationResult
+from neuroglia.data.abstractions import TEntity, TKey
+from neuroglia.data.infrastructure.abstractions import QueryableRepository, Repository
+from neuroglia.mediation.mediator import Query, QueryHandler
+
+
+class GetByIdQuery(Generic[TEntity, TKey], Query[OperationResult[TEntity]]):
+    ''' Represents the query used to get an entity by id'''
+
+    def __init__(self, id: Any):
+        self.id = id
+
+    id: Any
+    ''' Gets the id of the entity to get '''
+
+
+class GetByIdQueryHandler(Generic[TEntity, TKey], QueryHandler[GetByIdQuery[TEntity, TKey], OperationResult[TEntity]]):
+    ''' Represents the service used to handle GetByIdQuery instances '''
+
+    def __init__(self, repository: Repository[TEntity, TKey]):
+        self.repository = repository
+
+    repository: Repository[TEntity, TKey]
+
+    async def handle_async(self, query: GetByIdQuery[TEntity, TKey]) -> OperationResult[TEntity]:
+        entity = await self.repository.get_async(query.id)
+        if entity is None:
+            return self.not_found(self.repository.__orig_class__.__args__[0], query.id)
+        return self.ok(entity)

neuroglia/data/queries/generic/list_query.py

@@ -0,0 +1,23 @@
+from typing import Any, Generic
+from neuroglia.core.operation_result import OperationResult
+from neuroglia.data.abstractions import TEntity, TKey
+from neuroglia.data.infrastructure.abstractions import QueryableRepository
+from neuroglia.mediation.mediator import Query, QueryHandler
+
+
+class ListQuery(Generic[TEntity, TKey], Query[OperationResult[TEntity]]):
+    ''' Represents the query used to get an entity by id'''
+    pass
+
+
+class ListQueryHandler(Generic[TEntity, TKey], QueryHandler[ListQuery[TEntity, TKey], OperationResult[TEntity]]):
+    ''' Represents the service used to handle ListQuery instances '''
+
+    def __init__(self, repository: QueryableRepository[TEntity, TKey]):
+        self.repository = repository
+
+    repository: QueryableRepository[TEntity, TKey]
+
+    async def handle_async(self, query: ListQuery[TEntity, TKey]) -> OperationResult[TEntity]:
+        res = await self.repository.query_async()
+        return self.ok(res.to_list())