refactor: decouple models

Author: giancarloromeo

packages/models-library/src/models_library/rpc/notifications/account.py

@@ -0,0 +1,15 @@
+from typing import Literal
+
+from pydantic import EmailStr
+
+from .notifications import Event
+
+
+class AccountRequestedEvent(Event):
+    type: Literal["account.requested"] = "account.requested"
+
+    first_name: str
+    last_name: str
+    email: EmailStr
+
+    # TODO: add more fields as needed

packages/models-library/src/models_library/rpc/notifications/messages.py

@@ -0,0 +1,32 @@
+from typing import Annotated, Literal, TypeAlias
+
+from pydantic import BaseModel, ConfigDict, EmailStr, Field
+
+
+class Event(BaseModel):
+    type: str
+
+    model_config = ConfigDict(
+        frozen=True,
+    )
+
+
+class EmailChannel(BaseModel):
+    type: Literal["email"] = "email"
+
+    to: EmailStr
+    reply_to: EmailStr | None = None
+
+
+class SMSChannel(BaseModel):
+    type: Literal["sms"] = "sms"
+
+    phone_number: str  # Consider using phone number validation library here
+
+
+Channel: TypeAlias = EmailChannel | SMSChannel
+
+
+class Notification(BaseModel):
+    event: Event
+    channel: Annotated[Channel, Field(discriminator="type")]

packages/models-library/src/models_library/rpc/notifications/notifications.py

@@ -2,22 +2,22 @@
 
 from models_library.api_schemas_notifications import NOTIFICATIONS_RPC_NAMESPACE
 from models_library.rabbitmq_basic_types import RPCMethodName
-from models_library.rpc.notifications.messages import NotificationMessage
+from models_library.rpc.notifications.notifications import Notification
 from pydantic import NonNegativeInt, TypeAdapter
 
 from ... import RabbitMQRPCClient
 
 _DEFAULT_TIMEOUT_S: Final[NonNegativeInt] = 30
 
 
-async def send_notification_message(
+async def send_notification(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
-    message: NotificationMessage,
+    notification: Notification,
 ) -> None:
     await rabbitmq_rpc_client.request(
         NOTIFICATIONS_RPC_NAMESPACE,
-        TypeAdapter(RPCMethodName).validate_python("send_notification_message"),
+        TypeAdapter(RPCMethodName).validate_python("send_notification"),
         timeout_s=_DEFAULT_TIMEOUT_S,
-        message=message,
+        notification=notification,
     )

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/notifications/messages.py

@@ -1,4 +1,4 @@
-from models_library.rpc.notifications.messages import NotificationMessage
+from models_library.rpc.notifications.notifications import Notification
 from servicelib.celery.task_manager import TaskManager
 from servicelib.rabbitmq import RPCRouter
 
@@ -8,12 +8,12 @@
 
 
 @router.expose(reraise_if_error_type=())
-async def send_notification_message(
+async def send_notification(
     task_manager: TaskManager,
     *,
-    message: NotificationMessage,
+    notification: Notification,
 ) -> None:
-    await notifications_service.send_notification_message(
+    await notifications_service.send_notification(
         task_manager,
-        message=message,
+        notification=notification,
     )

services/notifications/src/simcore_service_notifications/api/rpc/_notifications.py

@@ -6,9 +6,9 @@
 from celery_library.types import register_celery_types, register_pydantic_types
 from fastapi import FastAPI
 from fastapi_lifespan_manager import State
-from models_library.rpc.notifications.messages import (
+from models_library.rpc.notifications.notifications import (
     EmailChannel,
-    NotificationMessage,
+    Notification,
     SMSChannel,
 )
 from settings_library.celery import CelerySettings
@@ -28,7 +28,7 @@ async def celery_lifespan(app: FastAPI) -> AsyncIterator[State]:
         )
 
         register_celery_types()
-        register_pydantic_types(NotificationMessage, EmailChannel, SMSChannel)
+        register_pydantic_types(Notification, EmailChannel, SMSChannel)
     yield {}
 
 

services/notifications/src/simcore_service_notifications/clients/celery.py

@@ -3,19 +3,51 @@
 import logging
 
 from celery import Task
-from models_library.rpc.notifications.messages import EmailChannel, NotificationMessage
+from models_library.rpc.notifications.notifications import EmailChannel, Notification
 from servicelib.celery.models import TaskID
 
 _logger = logging.getLogger(__name__)
 
 EMAIL_CHANNEL_NAME = "email"
 
 
-async def send_email(
+async def send_email_notification(
     task: Task,
     task_id: TaskID,
-    message: NotificationMessage,
+    notification: Notification,
 ) -> None:
-    assert isinstance(message.channel, EmailChannel)  # nosec
+    assert isinstance(notification.channel, EmailChannel)  # nosec
 
-    _logger.info("Sending email notification to %s", message.channel.to)
+    _logger.info("Sending email notification to %s", notification.channel.to)
+
+    # event_extra_data = event_extra_data | (asdict(sharer_data) if sharer_data else {})
+
+    # parts = render_email_parts(
+    #     env=create_render_environment_from_notifications_library(
+    #         undefined=StrictUndefined
+    #     ),
+    #     event_name=event_name,
+    #     user=user_data,
+    #     product=product_data,
+    #     # extras
+    #     **event_extra_data,
+    # )
+
+    # from_ = get_support_address(product_data)
+    # to = get_user_address(user_data)
+
+    # assert from_.addr_spec == product_data.support_email
+    # assert to.addr_spec == user_email
+
+    # msg = compose_email(
+    #     from_,
+    #     to,
+    #     subject=parts.subject,
+    #     content_text=parts.text_content,
+    #     content_html=parts.html_content,
+    # )
+    # if event_attachments:
+    #     add_attachments(msg, event_attachments)
+
+    # async with create_email_session(settings=SMTPSettings.create_from_envs()) as smtp:
+    #     await smtp.send_message(msg)

services/notifications/src/simcore_service_notifications/modules/celery/_email_tasks.py

@@ -4,14 +4,14 @@
 from celery import Celery  # type: ignore[import-untyped]
 from celery_library.task import register_task
 from celery_library.types import register_celery_types, register_pydantic_types
-from models_library.rpc.notifications.messages import (
+from models_library.rpc.notifications.account import AccountRequestedEvent
+from models_library.rpc.notifications.notifications import (
     EmailChannel,
-    NotificationMessage,
     SMSChannel,
 )
 from servicelib.logging_utils import log_context
 
-from ...modules.celery._email_tasks import EMAIL_CHANNEL_NAME, send_email
+from ...modules.celery._email_tasks import EMAIL_CHANNEL_NAME, send_email_notification
 
 _logger = logging.getLogger(__name__)
 
@@ -25,9 +25,11 @@ class TaskQueue(StrEnum):
 
 def setup_worker_tasks(app: Celery) -> None:
     register_celery_types()
-    register_pydantic_types(NotificationMessage, EmailChannel, SMSChannel)
+    register_pydantic_types(AccountRequestedEvent, EmailChannel, SMSChannel)
 
     with log_context(_logger, logging.INFO, msg="worker tasks registration"):
         register_task(
-            app, send_email, ".".join((_NOTIFICATIONS_PREFIX, EMAIL_CHANNEL_NAME))
+            app,
+            send_email_notification,
+            ".".join((_NOTIFICATIONS_PREFIX, EMAIL_CHANNEL_NAME)),
         )

services/notifications/src/simcore_service_notifications/modules/celery/tasks.py

@@ -1,6 +1,6 @@
 import logging
 
-from models_library.rpc.notifications.messages import NotificationMessage
+from models_library.rpc.notifications.notifications import Notification
 from servicelib.celery.models import TaskContext
 from servicelib.celery.task_manager import TaskManager
 
@@ -9,14 +9,15 @@
 _logger = logging.getLogger(__name__)
 
 
-async def send_notification_message(
+async def send_notification(
     task_manager: TaskManager,
     *,
-    message: NotificationMessage,
+    notification: Notification,
 ) -> None:
     await task_manager.send_task(
-        name=f"notifications.{message.event_type}",
+        # send to the specific channel worker
+        name=f"notifications.{notification.channel.type}",
         context=TaskContext(),  # TODO: TaskFilter
         queue=TaskQueue.DEFAULT,
-        message=message,
+        notification=notification,
     )

services/notifications/src/simcore_service_notifications/services/notifications_service.py

@@ -1,8 +1,12 @@
 import pytest
-from models_library.rpc.notifications.messages import NotificationMessage
+from faker import Faker
+from models_library.rpc.notifications.notifications import (
+    AccountRequestedEvent,
+    Notification,
+)
 from servicelib.rabbitmq import RabbitMQRPCClient
 from servicelib.rabbitmq.rpc_interfaces.notifications.messages import (
-    send_notification_message,
+    send_notification,
 )
 from simcore_service_notifications.clients.celery import EmailChannel
 
@@ -17,14 +21,20 @@
     "mock_celery_worker",
     "fastapi_app",
 )
-async def test_send_email(
+async def test_account_requested(
     notifications_rabbitmq_rpc_client: RabbitMQRPCClient,
+    faker: Faker,
 ):
-    await send_notification_message(
+    email = faker.email()
+
+    await send_notification(
         notifications_rabbitmq_rpc_client,
-        message=NotificationMessage(
-            event_type="on_account_requested",
-            channel=EmailChannel(to="[email protected]"),
-            context={"key": "value"},
+        notification=Notification(
+            event=AccountRequestedEvent(
+                first_name=faker.first_name(),
+                last_name=faker.last_name(),
+                email=email,
+            ),
+            channel=EmailChannel(to=email),
         ),
     )