feat(): push notifications via firebase admin

src/template_project/adapters/data_gateways/notification_device.py

@@ -0,0 +1,20 @@
+from typing import override
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from template_project.adapters.data_gateways.tables import notification_device_table
+from template_project.application.user.entity import UserId
+from template_project.application.user.notification_device.data_gateway import NotificationDeviceDataGateway
+from template_project.application.user.notification_device.entity import NotificationDevice
+
+
+class DefaultNotificationDeviceDataGateway(NotificationDeviceDataGateway):
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    @override
+    async def load_by_user_id(self, user_id: UserId) -> NotificationDevice | None:
+        statement = select(NotificationDevice).where(notification_device_table.c.user_id == user_id)
+        result = await self._session.execute(statement)
+        return result.scalar_one_or_none()

src/template_project/adapters/data_gateways/tables.py

@@ -15,6 +15,7 @@ from sqlalchemy.orm import registry
 from template_project.application.access_token.entity import AccessToken
 from template_project.application.auth_identity.entity import AuthIdentity, AuthMethod
 from template_project.application.user.entity import User
+from template_project.application.user.notification_device.entity import NotificationDevice
 from template_project.application.user.profile.entity import Profile
 
 meta_data = MetaData()
@@ -66,7 +67,19 @@ profile_table = Table(
     Column("created_at", DateTime(timezone=True), nullable=False),
 )
 
+notification_device_table = Table(
+    "notification_devices",
+    meta_data,
+    Column("id", UUID, primary_key=True),
+    Column("user_id", UUID, ForeignKey("users.id", ondelete="CASCADE"), nullable=False),
+    Column("device_id", String, nullable=False),
+    Column("deleted_at", DateTime(timezone=True)),
+    Column("created_at", DateTime(timezone=True), nullable=False),
+    UniqueConstraint("user_id", "device_id", name="uq_user_device"),
+)
+
 mapper_registry.map_imperatively(User, user_table)
 mapper_registry.map_imperatively(AccessToken, access_token_table)
 mapper_registry.map_imperatively(AuthIdentity, auth_identity_table)
 mapper_registry.map_imperatively(Profile, profile_table)
+mapper_registry.map_imperatively(NotificationDevice, notification_device_table)

src/template_project/adapters/notifications/fcm.py

@@ -0,0 +1,20 @@
+import asyncio
+from typing import override
+
+from firebase_admin import messaging  # type: ignore[import-untyped]
+from firebase_admin.messaging import Message, Notification  # type: ignore[import-untyped]
+
+from template_project.application.common.notifications.service import NotificationService
+
+
+class FCMNotificationService(NotificationService):
+    def __init__(self) -> None:
+        pass
+
+    @override
+    async def send_notification(self, identifier: str, title: str, body: str) -> None:
+        message = Message(
+            token=identifier,
+            notification=Notification(title=title, body=body),
+        )
+        await asyncio.to_thread(messaging.send, message)

src/template_project/application/common/notifications/service.py

@@ -0,0 +1,8 @@
+from abc import abstractmethod
+from typing import Protocol
+
+
+class NotificationService(Protocol):
+    @abstractmethod
+    async def send_notification(self, identifier: str, title: str, body: str) -> None:
+        raise NotImplementedError

src/template_project/application/user/notification/interactors/send_notification.py

@@ -0,0 +1,32 @@
+from template_project.application.common.data_structure import to_data_structure
+from template_project.application.common.identity_provider import IdentityProvider
+from template_project.application.common.interactor import to_interactor
+from template_project.application.common.notifications.service import NotificationService
+from template_project.application.user.notification_device.data_gateway import NotificationDeviceDataGateway
+from template_project.application.user.notification_device.errors import NotificationDeviceNotFoundError
+
+
+@to_data_structure
+class SendNotificationRequest:
+    title: str
+    body: str
+
+
+@to_interactor
+class NotificationInteractor:
+    identity_provider: IdentityProvider
+    notification_device_data_gateway: NotificationDeviceDataGateway
+    notification_service: NotificationService
+
+    async def send_notification(self, request: SendNotificationRequest) -> None:
+        current_user = await self.identity_provider.get_current_user()
+        notification_device = await self.notification_device_data_gateway.load_by_user_id(current_user.id)
+
+        if not notification_device:
+            raise NotificationDeviceNotFoundError
+
+        await self.notification_service.send_notification(
+            identifier=notification_device.device_id,
+            title=request.title,
+            body=request.body,
+        )

src/template_project/application/user/notification_device/data_gateway.py

@@ -0,0 +1,11 @@
+from abc import abstractmethod
+from typing import Protocol
+
+from template_project.application.user.entity import UserId
+from template_project.application.user.notification_device.entity import NotificationDevice
+
+
+class NotificationDeviceDataGateway(Protocol):
+    @abstractmethod
+    async def load_by_user_id(self, user_id: UserId) -> NotificationDevice | None:
+        raise NotImplementedError

src/template_project/application/user/notification_device/entity.py

@@ -0,0 +1,29 @@
+from datetime import UTC, datetime
+from typing import NewType, Self
+from uuid import UUID
+
+from uuid_utils.compat import uuid7
+
+from template_project.application.common.entity import Entity, to_entity
+from template_project.application.user.entity import UserId
+
+NotificationDeviceId = NewType("NotificationDeviceId", UUID)
+
+
+@to_entity
+class NotificationDevice(Entity[NotificationDeviceId]):
+    user_id: UserId
+    device_id: str
+
+    @classmethod
+    def factory(
+        cls,
+        user_id: UserId,
+        device_id: str,
+    ) -> Self:
+        return cls(
+            id=NotificationDeviceId(uuid7()),
+            user_id=user_id,
+            device_id=device_id,
+            created_at=datetime.now(tz=UTC),
+        )

src/template_project/application/user/notification_device/errors.py

@@ -0,0 +1,6 @@
+from template_project.application.common.errors import ApplicationError, to_error
+
+
+@to_error
+class NotificationDeviceNotFoundError(ApplicationError):
+    pass

src/template_project/migrations/versions/9140c6824ab8_.py

@@ -0,0 +1,41 @@
+"""empty message
+
+Revision ID: 9140c6824ab8
+Revises: b5fa4f3e95c5
+Create Date: 2025-11-20 20:57:31.722554
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '9140c6824ab8'
+down_revision: Union[str, Sequence[str], None] = 'b5fa4f3e95c5'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('notification_devices',
+    sa.Column('id', sa.UUID(), nullable=False),
+    sa.Column('user_id', sa.UUID(), nullable=False),
+    sa.Column('device_id', sa.String(), nullable=False),
+    sa.Column('deleted_at', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('user_id', 'device_id', name='uq_user_device')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('notification_devices')
+    # ### end Alembic commands ###

src/template_project/web_api/configuration.py

@@ -50,12 +50,18 @@ class YandexOAuthConfiguration:
     client_secret: SecretString
 
 
+@to_configuration
+class FirebaseConfiguration:
+    certificate_path: str
+
+
 @to_configuration
 class Configuration:
     server: ServerConfiguration
     database: DatabaseConfiguration
     access_token: AccessTokenConfiguration
     yandex_oauth: YandexOAuthConfiguration
+    firebase: FirebaseConfiguration
 
 
 retort = Retort(

src/template_project/web_api/entry_point.py

@@ -8,15 +8,17 @@ from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Final
 
+import firebase_admin  # type: ignore[import-untyped]
 import uvicorn
 from dishka import AsyncContainer
 from dishka.integrations.fastapi import setup_dishka
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from firebase_admin import credentials
 
-from template_project.web_api.configuration import load_configuration
+from template_project.web_api.configuration import Configuration, load_configuration
 from template_project.web_api.ioc.make import make_ioc
-from template_project.web_api.routes import auth, healthcheck, profile
+from template_project.web_api.routes import auth, healthcheck, notification, profile
 
 LOG_CONFIG: Final = {
     "version": 1,
@@ -41,6 +43,9 @@ LOG_CONFIG: Final = {
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+    configuration: Configuration = app.state.dishka_container.context[Configuration]
+    cred = credentials.Certificate(configuration.firebase.certificate_path)
+    firebase_admin.initialize_app(cred)
     yield
     await app.state.dishka_container.close()
 
@@ -66,6 +71,7 @@ def make_asgi_application(
     app.include_router(auth.router)
     app.include_router(healthcheck.router)
     app.include_router(profile.router)
+    app.include_router(notification.router)
 
     setup_dishka(container=ioc, app=app)
 

src/template_project/web_api/ioc/data_gateway.py

@@ -2,6 +2,7 @@ from dishka import BaseScope, Provider, Scope, WithParents, provide, provide_all
 
 from template_project.adapters.data_gateways.access_token import DefaultAccessTokenDataGateway
 from template_project.adapters.data_gateways.auth_identity import DefaultAuthIdentityDataGateway
+from template_project.adapters.data_gateways.notification_device import DefaultNotificationDeviceDataGateway
 from template_project.adapters.data_gateways.profile import DefaultProfileDataGateway
 from template_project.adapters.data_gateways.user import DefaultUserDataGateway
 from template_project.adapters.unit_of_work import DefaultUnitOfWork
@@ -16,4 +17,5 @@ class DataGatewayProvider(Provider):
         WithParents[DefaultAccessTokenDataGateway],
         WithParents[DefaultAuthIdentityDataGateway],
         WithParents[DefaultProfileDataGateway],
+        WithParents[DefaultNotificationDeviceDataGateway],
     )

src/template_project/web_api/ioc/interactor.py

@@ -2,6 +2,7 @@ from dishka import BaseScope, Provider, Scope, provide_all
 
 from template_project.application.auth_identity.interactors.sign_in import SignInInteractor
 from template_project.application.auth_identity.interactors.sign_up import SignUpInteractor
+from template_project.application.user.notification.interactors.send_notification import NotificationInteractor
 from template_project.application.user.profile.interactors.get_profile import GetProfileInteractor
 from template_project.application.user.profile.interactors.patch_profile import PatchProfileInteractor
 
@@ -14,4 +15,5 @@ class InteractorProvider(Provider):
         SignUpInteractor,
         GetProfileInteractor,
         PatchProfileInteractor,
+        NotificationInteractor,
     )

src/template_project/web_api/ioc/make.py

@@ -5,6 +5,7 @@ from template_project.web_api.configuration import (
     AccessTokenConfiguration,
     Configuration,
     DatabaseConfiguration,
+    FirebaseConfiguration,
     ServerConfiguration,
     YandexOAuthConfiguration,
 )
@@ -14,6 +15,7 @@ from template_project.web_api.ioc.data_gateway import DataGatewayProvider
 from template_project.web_api.ioc.factory import FactoryProvider
 from template_project.web_api.ioc.idp import IdPProvider
 from template_project.web_api.ioc.interactor import InteractorProvider
+from template_project.web_api.ioc.notifications import NotificationServiceProvider
 from template_project.web_api.ioc.oauth import OAuthClientProvider
 
 
@@ -27,11 +29,14 @@ def make_ioc(configuration: Configuration) -> AsyncContainer:
         DataGatewayProvider(),
         CryptographerProvider(),
         OAuthClientProvider(),
+        NotificationServiceProvider(),
         validation_settings=STRICT_VALIDATION,
         context={
             ServerConfiguration: configuration.server,
             DatabaseConfiguration: configuration.database,
             AccessTokenConfiguration: configuration.access_token,
             YandexOAuthConfiguration: configuration.yandex_oauth,
+            FirebaseConfiguration: configuration.firebase,
+            Configuration: configuration,
         },
     )

src/template_project/web_api/ioc/notifications.py

@@ -0,0 +1,12 @@
+from dishka import BaseScope, Provider, Scope, provide
+
+from template_project.adapters.notifications.fcm import FCMNotificationService
+from template_project.application.common.notifications.service import NotificationService
+
+
+class NotificationServiceProvider(Provider):
+    scope: BaseScope | None = Scope.APP
+
+    @provide
+    def notification_service(self) -> NotificationService:
+        return FCMNotificationService()

src/template_project/web_api/routes/notification.py

@@ -0,0 +1,31 @@
+from dishka import FromDishka
+from dishka.integrations.fastapi import DishkaRoute
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import HTTPBearer
+from pydantic import BaseModel
+
+from template_project.application.user.notification.interactors.send_notification import (
+    NotificationInteractor,
+    SendNotificationRequest,
+)
+from template_project.application.user.notification_device.errors import NotificationDeviceNotFoundError
+
+security = HTTPBearer()
+router = APIRouter(route_class=DishkaRoute, tags=["Notifications"], dependencies=[Depends(security)])
+
+
+class SendNotificationRequestModel(BaseModel):
+    title: str
+    body: str
+
+
+@router.post("/notifications/send")
+async def send_notification(
+    request: SendNotificationRequestModel,
+    interactor: FromDishka[NotificationInteractor],
+) -> None:
+    try:
+        notification_request = SendNotificationRequest(title=request.title, body=request.body)
+        await interactor.send_notification(notification_request)
+    except NotificationDeviceNotFoundError as error:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Notification device not found") from error