Improve the frontend and repository layer

services/tenant/app/repositories/tenant_member_repository.py

@@ -13,6 +13,7 @@ import json
 from .base import TenantBaseRepository
 from app.models.tenants import TenantMember
 from shared.database.exceptions import DatabaseError, ValidationError, DuplicateRecordError
+from shared.config.base import is_internal_service
 
 logger = structlog.get_logger()
 
@@ -89,6 +90,25 @@ class TenantMemberRepository(TenantBaseRepository):
     async def get_membership(self, tenant_id: str, user_id: str) -> Optional[TenantMember]:
         """Get specific membership by tenant and user"""
         try:
+            # Validate that user_id is a proper UUID format for actual users
+            # Service names like 'inventory-service' should be handled differently
+            import uuid
+            try:
+                uuid.UUID(user_id)
+                is_valid_uuid = True
+            except ValueError:
+                is_valid_uuid = False
+
+            # For internal service access, return None to indicate no user membership
+            # Service access should be handled at the API layer
+            if not is_valid_uuid and is_internal_service(user_id):
+                # This is an internal service request, return None
+                # Service access is granted at the API endpoint level
+                logger.debug("Internal service detected in membership lookup",
+                            service=user_id,
+                            tenant_id=tenant_id)
+                return None
+
             memberships = await self.get_multi(
                 filters={
                     "tenant_id": tenant_id,
@@ -444,4 +464,4 @@ class TenantMemberRepository(TenantBaseRepository):
         except Exception as e:
             logger.error("Failed to cleanup inactive memberships",
                         error=str(e))
-            raise DatabaseError(f"Cleanup failed: {str(e)}")
+            raise DatabaseError(f"Cleanup failed: {str(e)}")

services/tenant/app/repositories/tenant_settings_repository.py

@@ -0,0 +1,82 @@
+# services/tenant/app/repositories/tenant_settings_repository.py
+"""
+Tenant Settings Repository
+Data access layer for tenant settings
+"""
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from typing import Optional
+from uuid import UUID
+import structlog
+
+from ..models.tenant_settings import TenantSettings
+
+logger = structlog.get_logger()
+
+
+class TenantSettingsRepository:
+    """Repository for TenantSettings data access"""
+
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_by_tenant_id(self, tenant_id: UUID) -> Optional[TenantSettings]:
+        """
+        Get tenant settings by tenant ID
+
+        Args:
+            tenant_id: UUID of the tenant
+
+        Returns:
+            TenantSettings or None if not found
+        """
+        result = await self.db.execute(
+            select(TenantSettings).where(TenantSettings.tenant_id == tenant_id)
+        )
+        return result.scalar_one_or_none()
+
+    async def create(self, settings: TenantSettings) -> TenantSettings:
+        """
+        Create new tenant settings
+
+        Args:
+            settings: TenantSettings instance to create
+
+        Returns:
+            Created TenantSettings instance
+        """
+        self.db.add(settings)
+        await self.db.commit()
+        await self.db.refresh(settings)
+        return settings
+
+    async def update(self, settings: TenantSettings) -> TenantSettings:
+        """
+        Update tenant settings
+
+        Args:
+            settings: TenantSettings instance with updates
+
+        Returns:
+            Updated TenantSettings instance
+        """
+        await self.db.commit()
+        await self.db.refresh(settings)
+        return settings
+
+    async def delete(self, tenant_id: UUID) -> None:
+        """
+        Delete tenant settings
+
+        Args:
+            tenant_id: UUID of the tenant
+        """
+        result = await self.db.execute(
+            select(TenantSettings).where(TenantSettings.tenant_id == tenant_id)
+        )
+        settings = result.scalar_one_or_none()
+
+        if settings:
+            await self.db.delete(settings)
+            await self.db.commit()