Monorepo: consolidate 7 repos into one

Combines shared, blog, market, cart, events, federation, and account
into a single repository. Eliminates submodule sync, sibling model
copying at build time, and per-app CI orchestration.

Changes:
- Remove per-app .git, .gitmodules, .gitea, submodule shared/ dirs
- Remove stale sibling model copies from each app
- Update all 6 Dockerfiles for monorepo build context (root = .)
- Add build directives to docker-compose.yml
- Add single .gitea/workflows/ci.yml with change detection
- Add .dockerignore for monorepo build context
- Create __init__.py for federation and account (cross-app imports)

shared/services/market_impl.py

@@ -0,0 +1,128 @@
+"""SQL-backed MarketService implementation.
+
+Queries ``shared.models.market.*`` and ``shared.models.market_place.*`` —
+only this module may read market-domain tables on behalf of other domains.
+"""
+from __future__ import annotations
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from shared.models.market import Product
+from shared.models.market_place import MarketPlace
+from shared.browser.app.utils import utcnow
+from shared.contracts.dtos import MarketPlaceDTO, ProductDTO
+from shared.services.relationships import attach_child, detach_child
+
+
+def _mp_to_dto(mp: MarketPlace) -> MarketPlaceDTO:
+    return MarketPlaceDTO(
+        id=mp.id,
+        container_type=mp.container_type,
+        container_id=mp.container_id,
+        name=mp.name,
+        slug=mp.slug,
+        description=mp.description,
+    )
+
+
+def _product_to_dto(p: Product) -> ProductDTO:
+    return ProductDTO(
+        id=p.id,
+        slug=p.slug,
+        title=p.title,
+        image=p.image,
+        description_short=p.description_short,
+        rrp=p.rrp,
+        regular_price=p.regular_price,
+        special_price=p.special_price,
+    )
+
+
+class SqlMarketService:
+    async def marketplaces_for_container(
+        self, session: AsyncSession, container_type: str, container_id: int,
+    ) -> list[MarketPlaceDTO]:
+        result = await session.execute(
+            select(MarketPlace).where(
+                MarketPlace.container_type == container_type,
+                MarketPlace.container_id == container_id,
+                MarketPlace.deleted_at.is_(None),
+            ).order_by(MarketPlace.name.asc())
+        )
+        return [_mp_to_dto(mp) for mp in result.scalars().all()]
+
+    async def list_marketplaces(
+        self, session: AsyncSession,
+        container_type: str | None = None, container_id: int | None = None,
+        *, page: int = 1, per_page: int = 20,
+    ) -> tuple[list[MarketPlaceDTO], bool]:
+        stmt = select(MarketPlace).where(MarketPlace.deleted_at.is_(None))
+        if container_type is not None and container_id is not None:
+            stmt = stmt.where(
+                MarketPlace.container_type == container_type,
+                MarketPlace.container_id == container_id,
+            )
+        stmt = stmt.order_by(MarketPlace.name.asc())
+        stmt = stmt.offset((page - 1) * per_page).limit(per_page + 1)
+        rows = (await session.execute(stmt)).scalars().all()
+        has_more = len(rows) > per_page
+        return [_mp_to_dto(mp) for mp in rows[:per_page]], has_more
+
+    async def product_by_id(self, session: AsyncSession, product_id: int) -> ProductDTO | None:
+        product = (
+            await session.execute(select(Product).where(Product.id == product_id))
+        ).scalar_one_or_none()
+        return _product_to_dto(product) if product else None
+
+    async def create_marketplace(
+        self, session: AsyncSession, container_type: str, container_id: int,
+        name: str, slug: str,
+    ) -> MarketPlaceDTO:
+        # Look for existing (including soft-deleted)
+        existing = (await session.execute(
+            select(MarketPlace).where(
+                MarketPlace.container_type == container_type,
+                MarketPlace.container_id == container_id,
+                MarketPlace.slug == slug,
+            )
+        )).scalar_one_or_none()
+
+        if existing:
+            if existing.deleted_at is not None:
+                existing.deleted_at = None  # revive
+                existing.name = name
+                await session.flush()
+                await attach_child(session, container_type, container_id, "market", existing.id)
+                return _mp_to_dto(existing)
+            raise ValueError(f'Market with slug "{slug}" already exists for this container.')
+
+        market = MarketPlace(
+            container_type=container_type, container_id=container_id,
+            name=name, slug=slug,
+        )
+        session.add(market)
+        await session.flush()
+        await attach_child(session, container_type, container_id, "market", market.id)
+        return _mp_to_dto(market)
+
+    async def soft_delete_marketplace(
+        self, session: AsyncSession, container_type: str, container_id: int,
+        slug: str,
+    ) -> bool:
+        market = (await session.execute(
+            select(MarketPlace).where(
+                MarketPlace.container_type == container_type,
+                MarketPlace.container_id == container_id,
+                MarketPlace.slug == slug,
+                MarketPlace.deleted_at.is_(None),
+            )
+        )).scalar_one_or_none()
+
+        if not market:
+            return False
+
+        market.deleted_at = utcnow()
+        await session.flush()
+        await detach_child(session, container_type, container_id, "market", market.id)
+        return True