microservice/language/python/deploy/docker-compose/Dockerfile

@@ -1,4 +1,4 @@
-FROM ghcr.io/clariteia/minos-microservice:0.1.8 as development
+FROM ghcr.io/clariteia/minos-microservice:0.7.0.dev3 as development
 
 COPY ./pyproject.toml ./
 RUN poetry install --no-root

microservice/language/python/init/_utils.py

@@ -28,6 +28,14 @@ def build_deploy_playbook(path: Path) -> str:
 def build_docker_compose(path: Path, microservice_name: str) -> str:
     """Build Docker Compose file content."""
 
+    db_creation_path = path.parent / "external/postgres/10-create-database.sql"
+    if not db_creation_path.exists():
+        raise ValueError("external/postgres/10-create-database.sql script must exist")
+
+    with db_creation_path.open("a") as db_creation_file:
+        db_creation_file.write(f"\nCREATE DATABASE {microservice_name}_db;")
+        db_creation_file.write(f"\nCREATE DATABASE {microservice_name}_query_db;")
+
     if not path.exists():
         raise ValueError("A base Compose file must exist.")
 
@@ -36,9 +44,9 @@ def build_docker_compose(path: Path, microservice_name: str) -> str:
 
     if "x-microservice-environment" not in data:
         data["x-microservice-environment"] = {
-            "MINOS_BROKER_QUEUE_HOST": "postgres",
-            "MINOS_BROKER_HOST": "kafka",
-            "MINOS_REPOSITORY_HOST": "postgres",
+            "MINOS_INTERFACES_BROKER_COMMON_HOST": "kafka",
+            "MINOS_DATABASES_DEFAULT_HOST": "postgres",
+            "MINOS_DATABASES_QUERY_HOST": "postgres",
             "MINOS_SNAPSHOT_HOST": "postgres",
             "MINOS_DISCOVERY_HOST": "discovery",
         }

microservice/language/python/init/config.yml.jinja

@@ -1,65 +1,76 @@
-service:
-  name: {{ name }}
-  aggregate: src.aggregates.{{ aggregate }}
-  injections:
-    lock_pool: minos.common.PostgreSqlLockPool
-    postgresql_pool: minos.common.PostgreSqlPool
-    broker_publisher: minos.plugins.kafka.InMemoryQueuedKafkaBrokerPublisher
-    broker_subscriber_builder: minos.plugins.kafka.InMemoryQueuedKafkaBrokerSubscriberBuilder
-    broker_pool: minos.networks.BrokerClientPool
-    transaction_repository: minos.aggregate.PostgreSqlTransactionRepository
-    event_repository: minos.aggregate.PostgreSqlEventRepository
-    snapshot_repository: minos.aggregate.PostgreSqlSnapshotRepository
-    saga_manager: minos.saga.SagaManager
-    discovery: minos.networks.DiscoveryConnector
-  services:
-    - minos.networks.BrokerHandlerService
-    - minos.networks.RestService
-    - minos.networks.PeriodicTaskSchedulerService
-middleware:
-  - minos.saga.transactional_command
-services:
-  - minos.aggregate.TransactionService
-  - minos.aggregate.SnapshotService
-  - minos.saga.SagaService
-  - src.queries.{{ aggregate }}QueryService
-  - src.commands.{{ aggregate }}CommandService
-rest:
-  host: 0.0.0.0
-  port: 8080
-broker:
-  host: localhost
-  port: 9092
-  queue:
+version: 2
+name: {{ name }}
+injections:
+  - src.{{ aggregate }}QueryServiceRepository
+databases:
+  default:
+    client: minos.plugins.aiopg.AiopgDatabaseClient
     database: {{ name }}_db
     user: minos
     password: min0s
     host: localhost
     port: 5432
-    records: 1000
-    retry: 2
-repository:
-  database: {{ name }}_db
-  user: minos
-  password: min0s
-  host: localhost
-  port: 5432
-query_repository:
-  database: {{ name }}_query_db
-  user: postgres
-  password: ""
-  host: localhost
-  port: 5432
-snapshot:
-  database: {{ name }}_db
-  user: minos
-  password: min0s
-  host: localhost
-  port: 5432
-saga:
-  storage:
+  query:
+    client: minos.plugins.aiopg.AiopgDatabaseClient
+    database: {{ name }}_query_db
+    user: minos
+    password: min0s
+    host: localhost
+    port: 5432
+  saga:
+    client: minos.plugins.lmdb.LmdbDatabaseClient
     path: ./{{ name }}.lmdb
+interfaces:
+  broker:
+    port: minos.networks.BrokerPort
+    common:
+      host: localhost
+      port: 9092
+      queue:
+        records: 1000
+        retry: 2
+    publisher:
+      client: minos.plugins.kafka.KafkaBrokerPublisher
+      queue: minos.networks.DatabaseBrokerPublisherQueue
+    subscriber:
+      client: minos.plugins.kafka.KafkaBrokerSubscriber
+      queue: minos.networks.DatabaseBrokerSubscriberQueue
+      validator: minos.networks.DatabaseBrokerSubscriberDuplicateValidator
+  http:
+    port: minos.networks.HttpPort
+    connector:
+      client: minos.plugins.aiohttp.AioHttpConnector
+      host: 0.0.0.0
+      port: 8023
+  periodic:
+    port: minos.networks.PeriodicPort
+pools:
+  lock: minos.common.DatabaseLockPool
+  database: minos.common.DatabaseClientPool
+  broker: minos.networks.BrokerClientPool
 discovery:
+  connector: minos.networks.DiscoveryConnector
   client: minos.plugins.minos_discovery.MinosDiscoveryClient
   host: localhost
   port: 5567
+saga:
+  manager: minos.saga.SagaManager
+aggregate:
+  entities:
+    - src.aggregates.{{ aggregate }}
+  repositories:
+    transaction: minos.aggregate.DatabaseTransactionRepository
+    event: minos.aggregate.DatabaseEventRepository
+    snapshot: minos.aggregate.DatabaseSnapshotRepository
+routers:
+  - minos.networks.BrokerRouter
+  - minos.networks.PeriodicRouter
+  - minos.networks.RestHttpRouter
+middleware:
+  - minos.saga.transactional_command
+services:
+  - minos.aggregate.TransactionService
+  - minos.aggregate.SnapshotService
+  - minos.saga.SagaService
+  - src.queries.{{ aggregate }}QueryService
+  - src.commands.{{ aggregate }}CommandService

microservice/language/python/init/src/aggregates.py.jinja

@@ -18,5 +18,5 @@ class {{ aggregate }}Aggregate(Aggregate[{{ aggregate }}]):
     @staticmethod
     async def create() -> UUID:
         """Create a new instance."""
-        root = await {{ aggregate }}.create()
-        return root.uuid
+        {{ name }} = await {{ aggregate }}.create()
+        return {{ name }}

microservice/language/python/init/src/commands/services.py.jinja

@@ -25,7 +25,7 @@ class {{ aggregate }}CommandService(CommandService):
         :return: A ``Response`` instance.
         """
         try:
-            uuid = await {{ aggregate }}Aggregate.create()
-            return Response({"uuid": uuid})
+            {{ name }} = await {{ aggregate }}Aggregate.create()
+            return Response({{ name }})
         except Exception as exc:
             raise ResponseException(f"An error occurred during {{ aggregate }} creation: {exc}")

microservice/language/python/init/src/queries/__init__.py.jinja

@@ -4,4 +4,4 @@ from .services import (
 
 from .repository import (
     {{ aggregate }}QueryServiceRepository,
-)
+)

microservice/language/python/init/src/queries/repository.py.jinja

@@ -1,22 +1,29 @@
-from minos.common import MinosSetup, MinosConfig
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-from src.queries.models import Base
+from minos.common import (
+    Config,
+    Injectable,
+    SetupMixin,
+)
+from sqlalchemy import (
+    create_engine,
+)
+from sqlalchemy.orm import (
+    sessionmaker,
+)
 
+from src.queries.models import (
+    Base,
+)
 
-class {{ aggregate }}QueryServiceRepository(MinosSetup):
+@Injectable("{{ aggregate.lower() }}_repository")
+class {{ aggregate }}QueryServiceRepository(SetupMixin):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.engine = create_engine("postgresql+psycopg2://postgres:@localhost:5432/{{ name }}_query_db".format(**kwargs))
-        self.session = sessionmaker(bind=self.engine)
+        self.engine = create_engine("postgresql+psycopg2://{user}:{password}@{host}:{port}/{{ name }}_query_db".format(**kwargs))
+        self.session = sessionmaker(bind=self.engine)()
 
     async def _setup(self) -> None:
         Base.metadata.create_all(self.engine)
 
     @classmethod
-    def _from_config(cls, *args, config: MinosConfig, **kwargs) -> {{ aggregate }}QueryRepository:
-        return cls(*args, **(config.query_repository._asdict()) | kwargs)
-
-    @property
-    def session(self):
-        return self.session
+    def _from_config(cls, *args, config: Config, **kwargs):
+        return cls(*args, **(config.get_database_by_name("query")) | kwargs)

microservice/language/python/init/src/queries/services.py.jinja

@@ -1,6 +1,17 @@
+from dependency_injector.wiring import (
+    Provide,
+)
+
+from src.queries.repository import (
+    {{ aggregate }}QueryServiceRepository,
+)
+
 from minos.aggregate import (
     Event,
 )
+from minos.common import (
+    Inject,
+)
 from minos.cqrs import (
     QueryService,
 )
@@ -15,6 +26,11 @@ from minos.networks import (
 class {{ aggregate }}QueryService(QueryService):
     """{{ aggregate }}QueryService class."""
 
+    @Inject()
+    def __init__(self, repository: {{ aggregate }}QueryServiceRepository, **kwargs):
+        super().__init__(**kwargs)
+        self.repository = repository
+
     @enroute.rest.query("/{{ aggregate.lower() }}s", "GET")
     async def get_{{ aggregate.lower() }}(self, request: Request) -> Response:
         """Get a {{ aggregate }} instance.

microservice/language/python/init/tests/test_aggregates.py.jinja

@@ -16,10 +16,10 @@ class Test{{aggregate}}(unittest.IsolatedAsyncioTestCase):
         self.injector = build_dependency_injector()
 
     async def asyncSetUp(self) -> None:
-        await self.injector.wire(modules=[sys.modules[__name__]])
+        await self.injector.wire_and_setup_injections()
 
     async def asyncTearDown(self) -> None:
-        await self.injector.unwire()
+        await self.injector.unwire_and_destroy_injections()
 
     def test_constructor(self):
         obj = {{ aggregate }}()

microservice/language/python/init/tests/test_commands/test_services.py.jinja

@@ -21,10 +21,10 @@ class Test{{aggregate}}CommandService(unittest.IsolatedAsyncioTestCase):
         self.injector = build_dependency_injector()
 
     async def asyncSetUp(self) -> None:
-        await self.injector.wire(modules=[sys.modules[__name__]])
+        await self.injector.wire_and_setup_injections()
 
     async def asyncTearDown(self) -> None:
-        await self.injector.unwire()
+        await self.injector.unwire_and_destroy_injections()
 
     def test_constructor(self):
         service = {{ aggregate }}CommandService()

microservice/language/python/init/tests/test_queries/test_services.py.jinja

@@ -16,10 +16,10 @@ class Test{{aggregate}}QueryService(unittest.IsolatedAsyncioTestCase):
         self.injector = build_dependency_injector()
 
     async def asyncSetUp(self) -> None:
-        await self.injector.wire(modules=[sys.modules[__name__]])
+        await self.injector.wire_and_setup_injections()
 
     async def asyncTearDown(self) -> None:
-        await self.injector.unwire()
+        await self.injector.unwire_and_destroy_injections()
 
     def test_constructor(self):
         service = {{ aggregate }}QueryService()