add command registry, module.execute_command method, unit of work, tests

Author: pgorecki

.gitignore

@@ -6,3 +6,5 @@ src-gen/
 htmlcov/
 logs.json
 tmp/
+.idea/
+poetry.lock

.idea/dataSources.xml

@@ -1,124 +1,46 @@
-# configure logger prior to first usage
-import uuid
-
-from sqlalchemy.orm import Session
-
 from config.container import Container
-from modules.catalog.domain.entities import Listing, Money
-from modules.catalog.infrastructure.listing_repository import (
-    Base,
-    PostgresJsonListingRepository,
+from modules.catalog.application.command.create_listing_draft import (
+    CreateListingDraftCommand,
 )
+from modules.catalog.domain.entities import Money
+from modules.catalog.infrastructure.listing_repository import Base
 from seedwork.infrastructure.logging import LoggerFactory, logger
-from seedwork.infrastructure.request_context import request_context
 
 # a sample command line script to print all listings
 # run with "cd src && python -m cli"
 
-
+# configure logger prior to first usage
 LoggerFactory.configure(logger_name="cli")
 
 
 container = Container()
 container.config.from_dict(
     dict(
-        DATABASE_URL="sqlite+pysqlite:///:memory:",
+        # DATABASE_URL="sqlite+pysqlite:///:memory:",
+        DATABASE_URL="postgresql://postgres:password@localhost:5432/postgres",
         DEBUG=True,
     )
 )
 
 engine = container.engine()
 Base.metadata.create_all(engine)
 
-listing_id = uuid.uuid4()
-
-with Session(engine) as session:
-    request_context.correlation_id.set(uuid.uuid4())
-    logger.info("Session 1")
-    print(engine, session)
-    repo = PostgresJsonListingRepository(session)
-    listing = Listing(
-        id=listing_id,
-        seller_id=uuid.uuid4(),
-        title="Foo",
-        description="",
-        ask_price=Money(1),
-    )
-    repo.add(listing)
+catalog_module = container.catalog_module()
 
+with catalog_module.unit_of_work() as uow:
+    logger.info(f"executing unit of work")
+    count = uow.listing_repository.count()
+    logger.info(f"{count} listing in the repository")
 
-with Session(engine) as session:
-    request_context.correlation_id.set(uuid.uuid4())
-    logger.info("Session 2")
-    repo = PostgresJsonListingRepository(session)
-    repo.get_by_id(listing_id)
-
-
-# # configure catalog module
-#
-#
-# # instantiate catalog module
-# catalog_module = container.catalog_module()
-#
-# logger.info("Application configured")
-#
-# # let's generate a fake seller id for now
-# seller_id = SellerRepository.next_id()
-#
-#
-# ###############################
-# from modules.catalog.infrastructure.listing_repository import PostgresJsonListingRepository
-#
-#
-# session = ...
-# repository = PostgresJsonListingRepository(sqla_session=session)
-
-
-# from contextlib import contextmanager
-# from modules.catalog.module import CatalogModule
-#
-# @contextmanager
-# def business_tansaction():
-#     try:
-#         unit_of_work = ...
-#
-#         yield CatalogModule(unit_of_work, listing_repository=container.listing_repository())
-#     finally:
-#         ...
-#
-#
-#
-#
-# with BusinessTransactionOn(CatalogModule) as catalog_module:
-#     catalog_module.foo_repo()
-#
-#
-#
-# with catalog_module as transaction:
-#     print(transaction)
-
+with catalog_module.unit_of_work():
+    logger.info(f"adding new draft")
+    catalog_module.execute_command(
+        CreateListingDraftCommand(
+            title="First listing", description=".", ask_price=Money(100), seller_id=None
+        )
+    )
 
-#
-# # interact with a catalog module by issuing queries and commands
-# # use request context if you want to logically separate queries/commands
-# # from each other in the logs
-# with request_context:
-#     command = CreateListingDraftCommand(
-#         title="Foo", description="Bar", ask_price=1, seller_id=seller_id
-#     )
-#     result = catalog_module.execute_command(command)
-#     print(result)
-#     if result.is_ok():
-#         logger.info("Draft added")
-#     else:
-#         logger.error(result.get_errors())
-#
-# with request_context:
-#     query_result = catalog_module.execute_query(GetAllListings())
-#     logger.info(f"All listings: {query_result.result}")
-#
-# with request_context:
-#     query_result = catalog_module.execute_query(
-#         GetListingsOfSeller(seller_id=seller_id)
-#     )
-#     logger.info(f"Listings of seller {seller_id}: {query_result.result}")
+with catalog_module.unit_of_work() as uow:
+    logger.info(f"executing unit of work")
+    count = uow.listing_repository.count()
+    logger.info(f"{count} listing in the repository")

.idea/misc.xml

@@ -2,14 +2,7 @@
 from dependency_injector.wiring import inject  # noqa
 from sqlalchemy import create_engine
 
-from modules.catalog.infrastructure.listing_repository import (
-    PostgresJsonListingRepository,
-)
-from modules.catalog.module import CatalogModule
-from modules.iam.application.services import AuthenticationService
-from modules.iam.infrastructure.user_repository import PostgresJsonUserRepository
-from modules.iam.module import IdentityAndAccessModule
-from seedwork.infrastructure.request_context import RequestContext
+from modules.catalog import CatalogModule
 
 
 def _default(val):
@@ -62,32 +55,8 @@ class Container(containers.DeclarativeContainer):
 
     config = providers.Configuration()
     engine = providers.Singleton(create_engine_once, config)
-    dummy_service = providers.Factory(DummyService, config)
-    dummy_singleton = providers.Singleton(DummyService, config)
 
-    request_context: RequestContext = providers.Factory(
-        create_request_context, engine=engine
-    )
-
-    correlation_id = providers.Factory(
-        lambda request_context: request_context.correlation_id.get(), request_context
-    )
-
-    # catalog module and it's dependencies
-    listing_repository = providers.Factory(
-        PostgresJsonListingRepository, db_session=request_context.provided.db_session
-    )
     catalog_module = providers.Factory(
-        CatalogModule, listing_repository=listing_repository
-    )
-
-    # iam module and it's dependencies
-    user_repository = providers.Factory(
-        PostgresJsonUserRepository, db_session=request_context.provided.db_session
-    )
-    authentication_service = providers.Factory(
-        AuthenticationService, user_repository=user_repository
-    )
-    iam_module = providers.Factory(
-        IdentityAndAccessModule, authentication_service=authentication_service
+        CatalogModule,
+        engine=engine,
     )

src/cli/__main__.py

@@ -1,13 +1,15 @@
+from dataclasses import dataclass, field
 from datetime import datetime
 
 from modules.bidding.domain.repositories import ListingRepository
 from seedwork.application.decorators import query_handler
-from seedwork.application.queries import Field, Query
+from seedwork.application.queries import Query
 from seedwork.application.query_handlers import QueryResult
 
 
+@dataclass
 class GetPastdueListingsQuery(Query):
-    now: datetime = Field(default_factory=datetime.utcnow)
+    now: datetime = field(default_factory=datetime.utcnow)
 
 
 @query_handler

src/config/container.py

@@ -1,21 +1,21 @@
-from modules.bidding.application.query.get_pastdue_listings import (
-    GetPastdueListingsQuery,
-)
-from modules.bidding.module import BiddingModule
-from seedwork.infrastructure.repository import InMemoryRepository
+# from modules.bidding.application.query.get_pastdue_listings import (
+#     GetPastdueListingsQuery,
+# )
+# from modules.bidding.module import BiddingModule
+# from seedwork.infrastructure.repository import InMemoryRepository
+#
+#
+# class DummyEventPublisher:
+#     ...
+#
 
-
-class DummyEventPublisher:
-    ...
-
-
-def test_module():
-    module = BiddingModule(
-        event_publisher=DummyEventPublisher(), listing_repository=InMemoryRepository()
-    )
-
-    query = GetPastdueListingsQuery()
-    result = module.execute_query(query)
-
-    assert result.is_ok()
-    assert result.get_result() == []
+# def test_module():
+#     module = BiddingModule(
+#         event_publisher=DummyEventPublisher(), listing_repository=InMemoryRepository()
+#     )
+#
+#     query = GetPastdueListingsQuery()
+#     result = module.execute_query(query)
+#
+#     assert result.is_ok()
+#     assert result.get_result() == []

src/modules/bidding/application/query/get_pastdue_listings.py

@@ -0,0 +1,106 @@
+import uuid
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+
+from sqlalchemy.orm import Session
+
+from modules.catalog.application.command import (
+    CreateListingDraftCommand,
+    PublishListingCommand,
+    UpdateListingDraftCommand,
+)
+from modules.catalog.application.command.create_listing_draft import (
+    create_listing_draft,
+)
+from modules.catalog.application.query import GetAllListings
+from modules.catalog.domain.repositories import ListingRepository
+from modules.catalog.infrastructure.listing_repository import (
+    PostgresJsonListingRepository,
+)
+from seedwork.application.decorators import registry
+from seedwork.infrastructure.request_context import request_context
+
+
+def handles_command(command_class):
+    ...
+
+
+def handles_query(query_class):
+    ...
+
+
+class implemented_as:
+    def __init__(self, repo_class):
+        self.repo_class = repo_class
+
+    def __get__(self, obj, obj_type=None):
+        raise NotImplementedError()
+
+
+def get_arg(name, kwargs1, kwargs2):
+    return kwargs1.get(name, None) or kwargs2.get(name)
+
+
+@dataclass
+class UnitOfWork:
+    db_session: Session
+    correlation_id: uuid.UUID
+    listing_repository: ListingRepository
+
+
+class CatalogModule:
+    handles_command(CreateListingDraftCommand)
+    handles_query(GetAllListings)
+
+    def __init__(self, **kwargs):
+        self._uow: ContextVar[UnitOfWork] = ContextVar("_uow", default=None)
+        self.extra_kwargs = kwargs
+
+    @contextmanager
+    def unit_of_work(self, **kwargs):
+        engine = get_arg("engine", kwargs, self.extra_kwargs)
+        correlation_id = uuid.uuid4()
+        db_session = None
+        with Session(engine) as db_session:
+            uow = UnitOfWork(
+                correlation_id=correlation_id,
+                db_session=db_session,
+                listing_repository=PostgresJsonListingRepository(db_session=db_session),
+            )
+            # begin unit of work
+            self._uow.set(uow)
+            self.begin_unit_of_work(uow)
+            yield uow
+            self.end_unit_of_work(uow)
+            # end unit of work
+            self._uow.set(None)
+
+    def begin_unit_of_work(self, uow: UnitOfWork):
+        request_context.correlation_id.set(uow.correlation_id)
+
+    def end_unit_of_work(self, uow):
+        uow.listing_repository.persist_all()
+        uow.db_session.commit()
+
+    def configure(self, **kwargs):
+        self.extra_kwargs = kwargs
+
+    def execute_command(self, command):
+        command_class = type(command)
+        handler = registry.get_command_handler_for(command_class)
+        kwargs = registry.get_command_handler_parameters_for(command_class)
+
+        for param_name, param_type in kwargs.items():
+            for attr in self.uow.__dict__.values():
+                if isinstance(attr, param_type):
+                    kwargs[param_name] = attr
+
+        return handler(command=command, **kwargs)
+
+    @property
+    def uow(self) -> UnitOfWork:
+        uow = self._uow.get()
+        print(self._uow, self._uow.get())
+        assert uow, "Unit of work not set, use context manager"
+        return uow

src/modules/bidding/test_module.py

@@ -0,0 +1,3 @@
+from .create_listing_draft import CreateListingDraftCommand
+from .publish_listing import PublishListingCommand
+from .update_listing_draft import UpdateListingDraftCommand

src/modules/catalog/__init__.py

@@ -0,0 +1,3 @@
+from .get_all_listings import GetAllListings
+from .get_listing_details import GetListingDetails
+from .get_listings_of_seller import GetListingsOfSeller