feat(taxonomy): Implement complete taxonomy API with merchant isolation and JWT authentication

- Add merchant_id extraction and validation to TokenUser model in auth dependencies
- Implement get_taxonomy_by_id endpoint with proper access control and merchant data isolation
- Add merchant_id as required field in CreateUserRequest schema
- Enhance taxonomy service with comprehensive error handling and logging
- Update taxonomy model with merchant-aware query methods
- Add TAXONOMY_API_COMPLETE_GUIDE.md documentation for API implementation
- Add test_complete_taxonomy_implementation.py for end-to-end testing
- Implement super admin bypass for cross-merchant taxonomy access
- Add correlation ID tracking and structured logging throughout taxonomy operations
- Validate merchant access for non-super-admin users on all taxonomy endpoints

app/dependencies/auth.py

@@ -22,6 +22,7 @@ class TokenUser(BaseModel):
     user_id: str
     username: str
     role: str
+    merchant_id: str
     metadata: Optional[dict] = None
     
     def has_role(self, *roles: str) -> bool:
@@ -68,9 +69,10 @@ async def get_current_user(
         user_id: str = payload.get("sub")
         username: str = payload.get("username")
         role: str = payload.get("role")
+        merchant_id: str = payload.get("merchant_id")
         metadata: dict = payload.get("metadata")
         
-        if user_id is None or username is None:
+        if user_id is None or username is None or merchant_id is None:
             raise credentials_exception
         
         # Create TokenUser from payload
@@ -78,6 +80,7 @@ async def get_current_user(
             user_id=user_id,
             username=username,
             role=role or "user",
+            merchant_id=merchant_id,
             metadata=metadata
         )
         
@@ -160,14 +163,16 @@ async def get_optional_user(
         user_id: str = payload.get("sub")
         username: str = payload.get("username")
         role: str = payload.get("role")
+        merchant_id: str = payload.get("merchant_id")
         
-        if user_id is None or username is None:
+        if user_id is None or username is None or merchant_id is None:
             return None
         
         return TokenUser(
             user_id=user_id,
             username=username,
-            role=role or "user"
+            role=role or "user",
+            merchant_id=merchant_id
         )
         
     except Exception:

app/system_users/schemas/schema.py

@@ -41,10 +41,10 @@ class CreateUserRequest(BaseModel):
 
     username: str = Field(..., description="Unique username", min_length=3, max_length=50)
     email: EmailStr = Field(..., description="Email address")
+    merchant_id: str = Field(..., description="Merchant identifier")
     password: str = Field(..., description="Password", min_length=8, max_length=100)
     full_name: str = Field(..., description="Full name", min_length=1, max_length=100)
     role_id: str = Field(..., description="Role identifier")
-    merchant_id: Optional[str] = Field(None, description="Merchant identifier")
     is_active: bool = Field(default=True, description="Active flag")
     metadata: Optional[Dict[str, str]] = Field(None, description="Optional metadata")
 

app/taxonomy/controllers/router.py

@@ -371,6 +371,123 @@ async def list_taxonomy(
         raise TaxonomyErrorHandler.convert_to_http_exception(
             e, correlation_id=str(uuid.uuid4())
         )
+@router.get("/{taxonomy_id}", status_code=status.HTTP_200_OK)
+async def get_taxonomy_by_id(
+    taxonomy_id: str = Path(..., description="Taxonomy document ID to retrieve"),
+    current_user: TokenUser = Depends(get_current_active_user),
+    taxonomy_service: TaxonomyService = Depends(get_taxonomy_service)
+) -> Dict[str, Any]:
+    """
+    Get a specific taxonomy document by ID.
+    
+    This endpoint retrieves a complete taxonomy document for a merchant by its unique identifier.
+    Implements proper merchant data isolation and access control.
+    
+    **Authentication Required**: Valid JWT token with merchant_id in metadata
+    
+    **Path Parameters**:
+    - taxonomy_id: The unique identifier of the taxonomy document
+    
+    **Note**: merchant_id is extracted from JWT token for validation
+    
+    **Returns**: Complete taxonomy document with all taxonomy categories
+    
+    **Validates Requirements**: 4.1, 4.2, 6.1
+    """
+    try:
+        # Set logging context
+        correlation_id = str(uuid.uuid4())
+        logger.set_context(
+            correlation_id=correlation_id,
+            user_id=current_user.user_id,
+            operation="get_taxonomy_by_id"
+        )
+        
+        # Extract merchant_id from JWT token
+        merchant_id = get_user_merchant_id(current_user)
+        
+        # Log the operation start
+        logger.log_operation_start(
+            "get_taxonomy_by_id",
+            details={
+                "taxonomy_id": taxonomy_id,
+                "merchant_id": merchant_id,
+                "username": current_user.username,
+                "is_super_admin": current_user.is_super_admin()
+            },
+            merchant_id=merchant_id,
+            user_id=current_user.user_id
+        )
+        
+        # Get taxonomy document from database
+        from app.taxonomy.models.model import TaxonomyModel
+        model = TaxonomyModel()
+        
+        # For super admin, don't filter by merchant_id to allow access to all merchants
+        filter_merchant_id = merchant_id if not current_user.is_super_admin() else None
+        
+        document = await model.get_taxonomy_by_id(
+            taxonomy_id=taxonomy_id,
+            merchant_id=filter_merchant_id
+        )
+        
+        if not document:
+            taxonomy_error = not_found_error(
+                resource_type="taxonomy document",
+                resource_id=taxonomy_id,
+                merchant_id=merchant_id,
+                user_id=current_user.user_id
+            )
+            raise TaxonomyErrorHandler.convert_to_http_exception(taxonomy_error)
+        
+        # Validate merchant access for non-super-admin users
+        if not current_user.is_super_admin() and document.get("merchant_id") != merchant_id:
+            taxonomy_error = access_denied_error(
+                message="Access denied for taxonomy document",
+                merchant_id=merchant_id,
+                user_id=current_user.user_id
+            )
+            raise TaxonomyErrorHandler.convert_to_http_exception(taxonomy_error)
+        
+        # Log successful operation
+        logger.log_operation_success(
+            "get_taxonomy_by_id",
+            result_summary={
+                "taxonomy_id": taxonomy_id,
+                "merchant_id": document.get("merchant_id"),
+                "has_data": bool(document)
+            }
+        )
+        
+        # Return standardized SCM response format
+        return {
+            "success": True,
+            "message": "Taxonomy document retrieved successfully",
+            "data": document,
+            "metadata": {
+                "taxonomy_id": taxonomy_id,
+                "merchant_id": document.get("merchant_id"),
+                "timestamp": document.get("updated_at") or document.get("created_at")
+            }
+        }
+        
+    except TaxonomyError as e:
+        # Handle structured taxonomy errors
+        raise TaxonomyErrorHandler.convert_to_http_exception(
+            e, correlation_id=e.correlation_id
+        )
+        
+    except HTTPException:
+        # Re-raise HTTP exceptions
+        raise
+        
+    except Exception as e:
+        # Handle unexpected errors with proper logging and structured response
+        raise TaxonomyErrorHandler.convert_to_http_exception(
+            e, correlation_id=str(uuid.uuid4())
+        )
+
+
 @router.delete("/{taxonomy_id}", status_code=status.HTTP_200_OK)
 async def delete_taxonomy_entry(
     taxonomy_id: str = Path(..., description="Taxonomy document ID to delete"),

app/taxonomy/models/model.py

@@ -482,7 +482,7 @@ class TaxonomyModel:
                 "job_role", "specializations", "languages", "customer_group",
                 "pos_tender_modes", "payment_types", "payment_methods",
                 "asset_location", "asset_category", "stock_bin_location",
-                "branch_types", "uom_conversions"
+                "branch_types", "expense_types", "uom_conversions"
             ]
             
             # Find fields that have data

app/taxonomy/schemas/schema.py

@@ -64,79 +64,88 @@ class TaxonomyInfo(BaseModel):
     """
     Comprehensive taxonomy information schema for merchant-specific categorization.
     Supports all taxonomy categories including product, employee, customer, and operational taxonomies.
+    Based on the complete taxonomy structure from the provided JSON example.
     """
     merchant_id: Optional[str] = Field(None, description="Merchant identifier (set from JWT)")
     
     # Product Taxonomies
     brands: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Product brands taxonomy"
+        description="Product brands taxonomy (e.g., L'Oréal Professional, Schwarzkopf, Kerastase)"
     )
     categories: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Product categories taxonomy"
+        description="Product categories taxonomy (e.g., Hair, Skin, Nails, Spa, Makeup)"
     )
     lines: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Product lines taxonomy"
+        description="Product lines taxonomy (e.g., Hair Care, Hair Styling, Facials)"
     )
     classes: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Product classes taxonomy"
+        description="Product classes taxonomy (e.g., Premium, Luxury, Basic, VIP)"
     )
     subcategories: Optional[Dict[str, List[str]]] = Field(
         default_factory=dict, 
-        description="Product subcategories mapped to parent categories"
+        description="Product subcategories mapped to parent categories (e.g., Hair: [Hair Cut, Hair Color])"
     )
     
     # Employee Taxonomies
     job_role: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Employee job roles taxonomy"
+        description="Employee job roles taxonomy (e.g., Senior Stylist, Director, Massage therapist)"
     )
     specializations: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Employee specializations taxonomy"
+        description="Employee specializations taxonomy (e.g., Hairdresser, Nail technician, Esthetician)"
     )
     languages: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Languages taxonomy"
+        description="Languages taxonomy (e.g., English, Hindi, Tamil)"
     )
     
     # Customer Taxonomies
     customer_group: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Customer group taxonomy"
+        description="Customer group taxonomy (e.g., VIP, Regular, Premium, Enterprise, Gold)"
     )
     
-    # Operational Taxonomies
+    # Operational Taxonomies - POS & Payment
     pos_tender_modes: Optional[List[str]] = Field(
         default_factory=list, 
-        description="POS tender modes taxonomy"
+        description="POS tender modes taxonomy (e.g., Cash, Credit Card, Debit Card, Mobile Payment)"
     )
     payment_types: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Payment types taxonomy"
+        description="Payment types taxonomy (e.g., Cash and Carry, Credit)"
     )
     payment_methods: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Payment methods taxonomy"
+        description="Payment methods taxonomy (e.g., Bank Transfer, Cash, Cheque)"
     )
+    
+    # Operational Taxonomies - Asset & Inventory
     asset_location: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Asset location taxonomy"
+        description="Asset location taxonomy (e.g., Store Floor, Warehouse, Back Office)"
     )
     asset_category: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Asset category taxonomy"
+        description="Asset category taxonomy (e.g., Electronics, Furniture, Equipment)"
     )
     stock_bin_location: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Stock bin location taxonomy"
+        description="Stock bin location taxonomy (e.g., A1-01, B2-15, C3-07, Receiving)"
     )
+    
+    # Operational Taxonomies - Business Structure
     branch_types: Optional[List[str]] = Field(
         default_factory=list, 
-        description="Branch types taxonomy"
+        description="Branch types taxonomy (e.g., Flagship, Outlet, Pop-up, Franchise)"
+    )
+    expense_types: Optional[List[str]] = Field(
+        default_factory=list, 
+        description="Expense types taxonomy (e.g., Travel, Office Supplies)"
     )
     
     # UOM Conversions
@@ -184,7 +193,7 @@ class TaxonomyInfo(BaseModel):
     @validator('brands', 'categories', 'lines', 'classes', 'job_role', 'specializations', 
               'languages', 'customer_group', 'pos_tender_modes', 'payment_types', 
               'payment_methods', 'asset_location', 'asset_category', 'stock_bin_location', 
-              'branch_types')
+              'branch_types', 'expense_types')
     def validate_string_lists(cls, v):
         if v is None:
             return []
@@ -263,7 +272,7 @@ class TaxonomyListRequest(BaseModel):
                 'job_role', 'specializations', 'languages', 'customer_group',
                 'pos_tender_modes', 'payment_types', 'payment_methods',
                 'asset_location', 'asset_category', 'stock_bin_location',
-                'branch_types', 'uom_conversions'
+                'branch_types', 'expense_types', 'uom_conversions'
             }
             
             clean_type = v.strip()

app/taxonomy/services/service.py

@@ -180,7 +180,8 @@ class TaxonomyService:
                 "brands", "categories", "lines", "classes", "job_role", 
                 "specializations", "languages", "customer_group", 
                 "pos_tender_modes", "payment_types", "payment_methods",
-                "asset_location", "asset_category", "stock_bin_location", "branch_types"
+                "asset_location", "asset_category", "stock_bin_location", 
+                "branch_types", "expense_types"
             ]
             
             for field in list_fields:
@@ -528,7 +529,7 @@ class TaxonomyService:
                     "job_role", "specializations", "languages", "customer_group",
                     "pos_tender_modes", "payment_types", "payment_methods",
                     "asset_location", "asset_category", "stock_bin_location",
-                    "branch_types", "uom_conversions"
+                    "branch_types", "expense_types", "uom_conversions"
                 ]
                 
                 for field in taxonomy_fields:
@@ -651,7 +652,8 @@ class TaxonomyService:
                 "customer_group",
                 # Operational taxonomies
                 "pos_tender_modes", "payment_types", "payment_methods",
-                "asset_location", "asset_category", "stock_bin_location", "branch_types",
+                "asset_location", "asset_category", "stock_bin_location", 
+                "branch_types", "expense_types",
                 # UOM conversions
                 "uom_conversions"
             }
@@ -709,7 +711,8 @@ class TaxonomyService:
                 "customer_group",
                 # Operational taxonomies
                 "pos_tender_modes", "payment_types", "payment_methods",
-                "asset_location", "asset_category", "stock_bin_location", "branch_types",
+                "asset_location", "asset_category", "stock_bin_location", 
+                "branch_types", "expense_types",
                 # UOM conversions
                 "uom_conversions"
             }

test_complete_taxonomy_implementation.py

@@ -0,0 +1,591 @@
+#!/usr/bin/env python3
+"""
+Complete end-to-end taxonomy implementation test script.
+Tests all taxonomy categories from the provided JSON structure.
+
+This script demonstrates:
+1. Creating taxonomy data with all categories
+2. Using projection lists for performance optimization
+3. Filtering by specific taxonomy types
+4. UOM conversions management
+5. CRUD operations on taxonomy data
+
+Based on the JSON structure:
+{
+  "merchant_id": "company_cuatro_beauty_ltd",
+  "brands": ["L'Oréal Professional", "Schwarzkopf", "Kerastase", ...],
+  "categories": ["Hair", "Skin", "Nails", "Spa", "Makeup", ...],
+  "lines": ["Hair Care", "Hair Styling", "Facials", ...],
+  "classes": ["Premium", "Luxury", "Basic", "VIP"],
+  "subcategories": {"Hair": ["Hair Cut", "Hair Color", ...], ...},
+  "specializations": ["Hairdresser", "Nail technician", ...],
+  "job_role": ["Senior Stylist", "Director", ...],
+  "languages": ["English", "Hindi", "Tamil"],
+  "customer_group": ["VIP", "Regular", "Premium", ...],
+  "pos_tender_modes": ["Cash", "Credit Card", ...],
+  "payment_types": ["Cash and Carry", "Credit"],
+  "payment_methods": ["Bank Transfer", "Cash", "Cheque"],
+  "asset_location": ["Store Floor", "Warehouse", ...],
+  "asset_category": ["Electronics", "Furniture", "Equipment"],
+  "stock_bin_location": ["A1-01", "B2-15", ...],
+  "branch_types": ["Flagship", "Outlet", "Pop-up", "Franchise"],
+  "expense_types": ["Travel", "Office Supplies"],
+  "uom_conversions": [...]
+}
+"""
+
+import asyncio
+import json
+import sys
+import os
+from datetime import datetime
+from typing import Dict, List, Any
+
+# Add the app directory to Python path
+sys.path.append(os.path.join(os.path.dirname(__file__), 'app'))
+
+from motor.motor_asyncio import AsyncIOMotorClient
+from app.taxonomy.services.service import TaxonomyService
+from app.taxonomy.models.model import TaxonomyModel
+from app.taxonomy.schemas.schema import TaxonomyInfo, TaxonomyListRequest, UOMConversionGroup, UOMConversionDetail
+from app.constants.collections import SCM_TAXONOMY_COLLECTION
+from app.core.config import settings as app_settings
+
+
+class TaxonomyTestRunner:
+    """Complete taxonomy implementation test runner."""
+    
+    def __init__(self):
+        self.client = None
+        self.db = None
+        self.service = None
+        self.test_merchant_id = "company_cuatro_beauty_ltd"
+        
+    async def setup(self):
+        """Setup test environment."""
+        print("🔧 Setting up test environment...")
+        
+        # Create database connection
+        self.client = AsyncIOMotorClient(app_settings.MONGODB_URI)
+        self.db = self.client["scm_test_complete_taxonomy"]
+        
+        # Create service instance
+        self.service = TaxonomyService.__new__(TaxonomyService)
+        self.service.db = self.db
+        self.service.model = TaxonomyModel.__new__(TaxonomyModel)
+        self.service.model.db = self.db
+        self.service.model.collection = self.db[SCM_TAXONOMY_COLLECTION]
+        
+        # Clear any existing test data
+        await self.db[SCM_TAXONOMY_COLLECTION].delete_many({"merchant_id": self.test_merchant_id})
+        
+        print("✅ Test environment setup complete")
+    
+    async def cleanup(self):
+        """Cleanup test environment."""
+        print("🧹 Cleaning up test environment...")
+        try:
+            await self.db[SCM_TAXONOMY_COLLECTION].delete_many({"merchant_id": self.test_merchant_id})
+            self.client.close()
+            print("✅ Cleanup complete")
+        except Exception as e:
+            print(f"⚠️  Cleanup warning: {e}")
+    
+    def create_complete_taxonomy_data(self) -> TaxonomyInfo:
+        """Create complete taxonomy data based on the provided JSON structure."""
+        
+        # UOM conversions from the JSON
+        uom_conversions = [
+            UOMConversionGroup(
+                base_uom="g",
+                conversions=[
+                    UOMConversionDetail(
+                        alt_uom="kg",
+                        factor=1000.0,
+                        description="1 kg = 1000 g"
+                    )
+                ]
+            ),
+            UOMConversionGroup(
+                base_uom="ml",
+                conversions=[
+                    UOMConversionDetail(
+                        alt_uom="L",
+                        factor=1000.0,
+                        description="1 L = 1000 ml"
+                    ),
+                    UOMConversionDetail(
+                        alt_uom="bottle",
+                        factor=650.0,
+                        description="650 ml bottle"
+                    )
+                ]
+            ),
+            UOMConversionGroup(
+                base_uom="pcs",
+                conversions=[
+                    UOMConversionDetail(
+                        alt_uom="dozen",
+                        factor=12.0,
+                        description="1 dozen = 12 pcs"
+                    ),
+                    UOMConversionDetail(
+                        alt_uom="pack",
+                        factor=6.0,
+                        description="1 pack = 6 pcs (example)"
+                    )
+                ]
+            ),
+            UOMConversionGroup(
+                base_uom="hr",
+                conversions=[]
+            ),
+            UOMConversionGroup(
+                base_uom="L",
+                conversions=[
+                    UOMConversionDetail(
+                        alt_uom="bottle",
+                        factor=1.0,
+                        description="1 bottle = 1 L (example SKU)"
+                    )
+                ]
+            )
+        ]
+        
+        # Subcategories from the JSON
+        subcategories = {
+            "Hair": ["Hair Cut", "Hair Color", "Hair Spa", "Keratin Treatment", "Hair Smoothening"],
+            "Skin": ["Clean-up", "Facial", "De-Tan", "Peel Treatments", "Skin Brightening"],
+            "Nails": ["Manicure", "Pedicure", "Nail Art", "Gel Polish"],
+            "Spa": ["Head Massage", "Full Body Massage", "Aromatherapy", "Deep Tissue Massage"],
+            "Makeup": ["Bridal Makeup", "Party Makeup"],
+            "Foot": ["Pedicure"],
+            "H": ["Serum"]
+        }
+        
+        return TaxonomyInfo(
+            merchant_id=self.test_merchant_id,
+            
+            # Product Taxonomies
+            brands=[
+                "L'Oréal Professional", "Schwarzkopf", "Kerastase", "Olaplex", "Lotus", 
+                "b1", "g", " Services", "Brand1", "Brand2", "Brand3", "Brand4", 
+                "Glory", "NewBrand", "vb", ""
+            ],
+            categories=[
+                "Hair", "Skin", "Nails", "Spa", "Makeup", "Foot", "ea", "saddle", 
+                "d", "Glory", "Dummy123", "Alpha1", "Category1", "Hello", 
+                "test-category", "Child Hair Stylist", "Hair color", "hair sap"
+            ],
+            lines=[
+                "Hair Care", "Hair Styling", "Facials", "Body Treatments", 
+                "Manicure", "Pedicure", "Ayurveda", "GLoryt"
+            ],
+            classes=["Premium", "Luxury", "Basic", "Class1", "Class2", "VIP"],
+            subcategories=subcategories,
+            
+            # Employee Taxonomies
+            job_role=["Senior Stylist", "Director", "Massage therapist", "Esthetician"],
+            specializations=["Hairdresser", "Nail technician", "Massage therapist", "Esthetician", "hair style"],
+            languages=["English", "Hindi", "Tamil"],
+            
+            # Customer Taxonomies
+            customer_group=["VIP", "Regular", "Premium", "Enterprise", "Gold"],
+            
+            # Operational Taxonomies - POS & Payment
+            pos_tender_modes=["Cash", "Credit Card", "Debit Card", "Mobile Payment"],
+            payment_types=["Cash and Carry", "Credit"],
+            payment_methods=["Bank Transfer", "Cash", "Cheque"],
+            
+            # Operational Taxonomies - Asset & Inventory
+            asset_location=["Store Floor", "Warehouse", "Back Office"],
+            asset_category=["Electronics", "Furniture", "Equipment"],
+            stock_bin_location=["A1-01", "B2-15", "C3-07", "Receiving"],
+            
+            # Operational Taxonomies - Business Structure
+            branch_types=["Flagship", "Outlet", "Pop-up", "Franchise"],
+            expense_types=["Travel", "Office Supplies"],
+            
+            # UOM Conversions
+            uom_conversions=uom_conversions,
+            
+            # Metadata
+            created_by="AST011",
+            created_at=datetime(2025, 8, 19, 9, 50, 11, 927000),
+            updated_at=datetime(2025, 12, 12, 6, 31, 8, 509000)
+        )
+    
+    async def test_create_complete_taxonomy(self):
+        """Test 1: Create complete taxonomy data."""
+        print("\n📝 Test 1: Creating complete taxonomy data...")
+        
+        taxonomy_data = self.create_complete_taxonomy_data()
+        
+        result = await self.service.create_or_update_taxonomy(
+            data=taxonomy_data,
+            created_by="AST011"
+        )
+        
+        assert result["success"] is True
+        assert result["operation"] == "create"
+        assert "taxonomy_id" in result
+        
+        print(f"✅ Created taxonomy with ID: {result['taxonomy_id']}")
+        print(f"   Operation: {result['operation']}")
+        return result["taxonomy_id"]
+    
+    async def test_list_complete_taxonomy(self, taxonomy_id: str):
+        """Test 2: List complete taxonomy data without projection."""
+        print("\n📋 Test 2: Listing complete taxonomy data...")
+        
+        request = TaxonomyListRequest(merchant_id=self.test_merchant_id)
+        result = await self.service.list_taxonomy(request)
+        
+        assert result["success"] is True
+        assert result["projection_applied"] is False
+        assert result["merchant_id"] == self.test_merchant_id
+        
+        data = result["data"]
+        print(f"✅ Retrieved complete taxonomy data")
+        print(f"   Data type: {type(data)}")
+        print(f"   Has taxonomies: {'taxonomies' in data if isinstance(data, dict) else 'N/A'}")
+        
+        if isinstance(data, dict) and "taxonomies" in data:
+            taxonomies = data["taxonomies"]
+            print(f"   Available taxonomy types: {list(taxonomies.keys())}")
+            print(f"   Brands count: {len(taxonomies.get('brands', []))}")
+            print(f"   Categories count: {len(taxonomies.get('categories', []))}")
+            print(f"   UOM conversions count: {len(taxonomies.get('uom_conversions', []))}")
+        
+        return data
+    
+    async def test_projection_list_performance(self):
+        """Test 3: Test projection list for performance optimization."""
+        print("\n🚀 Test 3: Testing projection list performance...")
+        
+        # Test with specific fields projection
+        projection_fields = ["merchant_id", "brands", "categories", "job_role", "created_at"]
+        request = TaxonomyListRequest(
+            merchant_id=self.test_merchant_id,
+            projection_list=projection_fields
+        )
+        
+        result = await self.service.list_taxonomy(request)
+        
+        assert result["success"] is True
+        assert result["projection_applied"] is True
+        
+        data = result["data"]
+        print(f"✅ Projection applied successfully")
+        print(f"   Requested fields: {projection_fields}")
+        print(f"   Data type: {type(data)}")
+        
+        if isinstance(data, list) and data:
+            doc = data[0]
+            print(f"   Returned fields: {list(doc.keys())}")
+            
+            # Verify only requested fields are present (plus any defaults)
+            for field in projection_fields:
+                if field in ["brands", "categories", "job_role"] and doc.get(field):
+                    print(f"   ✓ {field}: {len(doc[field])} items")
+        
+        return data
+    
+    async def test_taxonomy_type_filtering(self):
+        """Test 4: Test filtering by specific taxonomy type."""
+        print("\n🔍 Test 4: Testing taxonomy type filtering...")
+        
+        # Test filtering by brands
+        request = TaxonomyListRequest(
+            merchant_id=self.test_merchant_id,
+            taxonomy_type="brands"
+        )
+        
+        result = await self.service.list_taxonomy(request)
+        
+        assert result["success"] is True
+        assert result["taxonomy_type"] == "brands"
+        
+        data = result["data"]
+        print(f"✅ Filtered by taxonomy type: brands")
+        print(f"   Data type: {type(data)}")
+        
+        if isinstance(data, list) and data:
+            doc = data[0]
+            print(f"   Document keys: {list(doc.keys())}")
+            if "data" in doc:
+                print(f"   Brands count: {len(doc['data'])}")
+                print(f"   Sample brands: {doc['data'][:3]}")
+        
+        # Test filtering by UOM conversions
+        request_uom = TaxonomyListRequest(
+            merchant_id=self.test_merchant_id,
+            taxonomy_type="uom_conversions"
+        )
+        
+        result_uom = await self.service.list_taxonomy(request_uom)
+        assert result_uom["success"] is True
+        
+        print(f"✅ Filtered by taxonomy type: uom_conversions")
+        
+        return data
+    
+    async def test_projection_with_taxonomy_type(self):
+        """Test 5: Test projection combined with taxonomy type filtering."""
+        print("\n🎯 Test 5: Testing projection + taxonomy type filtering...")
+        
+        request = TaxonomyListRequest(
+            merchant_id=self.test_merchant_id,
+            taxonomy_type="categories",
+            projection_list=["merchant_id", "categories", "created_at"]
+        )
+        
+        result = await self.service.list_taxonomy(request)
+        
+        assert result["success"] is True
+        assert result["projection_applied"] is True
+        assert result["taxonomy_type"] == "categories"
+        
+        data = result["data"]
+        print(f"✅ Combined projection + filtering applied")
+        print(f"   Taxonomy type: categories")
+        print(f"   Projection fields: merchant_id, categories, created_at")
+        print(f"   Data type: {type(data)}")
+        
+        if isinstance(data, list) and data:
+            doc = data[0]
+            print(f"   Returned fields: {list(doc.keys())}")
+        
+        return data
+    
+    async def test_uom_conversions_management(self):
+        """Test 6: Test UOM conversions CRUD operations."""
+        print("\n⚖️  Test 6: Testing UOM conversions management...")
+        
+        # Test getting UOM conversions
+        uom_result = await self.service.get_uom_conversions(
+            merchant_id=self.test_merchant_id
+        )
+        
+        assert uom_result["success"] is True
+        
+        uom_data = uom_result["data"]
+        print(f"✅ Retrieved UOM conversions")
+        print(f"   Conversion groups: {len(uom_data)}")
+        print(f"   Is default: {uom_result.get('is_default', False)}")
+        
+        # Print sample conversions
+        for i, group in enumerate(uom_data[:2]):  # Show first 2 groups
+            if isinstance(group, dict):
+                base_uom = group.get("base_uom")
+                conversions = group.get("conversions", [])
+                print(f"   Group {i+1}: {base_uom} -> {len(conversions)} conversions")
+                if conversions:
+                    sample = conversions[0]
+                    print(f"     Sample: {sample.get('alt_uom')} (factor: {sample.get('factor')})")
+        
+        return uom_data
+    
+    async def test_update_taxonomy_data(self):
+        """Test 7: Test updating taxonomy data."""
+        print("\n✏️  Test 7: Testing taxonomy data updates...")
+        
+        # Add new brands
+        update_data = TaxonomyInfo(
+            merchant_id=self.test_merchant_id,
+            brands=["New Brand 1", "New Brand 2", "Updated Brand"],
+            categories=["New Category"],
+            expense_types=["Marketing", "Training"],
+            created_by="AST014"
+        )
+        
+        result = await self.service.create_or_update_taxonomy(
+            data=update_data,
+            created_by="AST014"
+        )
+        
+        assert result["success"] is True
+        assert result["operation"] == "update"
+        
+        print(f"✅ Updated taxonomy data")
+        print(f"   Operation: {result['operation']}")
+        print(f"   Modified count: {result.get('modified_count', 0)}")
+        
+        # Verify the update
+        request = TaxonomyListRequest(
+            merchant_id=self.test_merchant_id,
+            projection_list=["brands", "categories", "expense_types"]
+        )
+        
+        verify_result = await self.service.list_taxonomy(request)
+        data = verify_result["data"]
+        
+        if isinstance(data, list) and data:
+            doc = data[0]
+            brands = doc.get("brands", [])
+            expense_types = doc.get("expense_types", [])
+            
+            print(f"   Updated brands count: {len(brands)}")
+            print(f"   Updated expense_types count: {len(expense_types)}")
+            
+            # Check if new items were added
+            new_brands = ["New Brand 1", "New Brand 2", "Updated Brand"]
+            new_expenses = ["Marketing", "Training"]
+            
+            for brand in new_brands:
+                if brand in brands:
+                    print(f"   ✓ Added brand: {brand}")
+            
+            for expense in new_expenses:
+                if expense in expense_types:
+                    print(f"   ✓ Added expense type: {expense}")
+        
+        return result
+    
+    async def test_delete_taxonomy_values(self):
+        """Test 8: Test deleting specific taxonomy values."""
+        print("\n🗑️  Test 8: Testing taxonomy value deletion...")
+        
+        # Delete specific brands using the delete flag
+        delete_data = TaxonomyInfo(
+            merchant_id=self.test_merchant_id,
+            brands=["New Brand 1", "Updated Brand"],  # These will be deleted
+            is_delete=True,
+            created_by="AST014"
+        )
+        
+        result = await self.service.create_or_update_taxonomy(
+            data=delete_data,
+            created_by="AST014"
+        )
+        
+        assert result["success"] is True
+        assert result["operation"] == "delete"
+        
+        print(f"✅ Deleted taxonomy values")
+        print(f"   Operation: {result['operation']}")
+        print(f"   Modified count: {result.get('modified_count', 0)}")
+        
+        # Verify the deletion
+        request = TaxonomyListRequest(
+            merchant_id=self.test_merchant_id,
+            projection_list=["brands"]
+        )
+        
+        verify_result = await self.service.list_taxonomy(request)
+        data = verify_result["data"]
+        
+        if isinstance(data, list) and data:
+            doc = data[0]
+            brands = doc.get("brands", [])
+            
+            print(f"   Remaining brands count: {len(brands)}")
+            
+            # Check if items were deleted
+            deleted_brands = ["New Brand 1", "Updated Brand"]
+            for brand in deleted_brands:
+                if brand not in brands:
+                    print(f"   ✓ Deleted brand: {brand}")
+                else:
+                    print(f"   ⚠️  Brand still exists: {brand}")
+        
+        return result
+    
+    async def test_performance_comparison(self):
+        """Test 9: Compare performance with and without projection."""
+        print("\n⚡ Test 9: Performance comparison...")
+        
+        import time
+        
+        # Test without projection (full data)
+        start_time = time.time()
+        request_full = TaxonomyListRequest(merchant_id=self.test_merchant_id)
+        result_full = await self.service.list_taxonomy(request_full)
+        full_time = time.time() - start_time
+        
+        # Test with projection (limited fields)
+        start_time = time.time()
+        request_projected = TaxonomyListRequest(
+            merchant_id=self.test_merchant_id,
+            projection_list=["merchant_id", "brands", "categories"]
+        )
+        result_projected = await self.service.list_taxonomy(request_projected)
+        projected_time = time.time() - start_time
+        
+        print(f"✅ Performance comparison completed")
+        print(f"   Full data query time: {full_time:.4f}s")
+        print(f"   Projected query time: {projected_time:.4f}s")
+        
+        # Calculate data size difference (rough estimate)
+        full_data = result_full["data"]
+        projected_data = result_projected["data"]
+        
+        if isinstance(full_data, dict) and isinstance(projected_data, list):
+            full_str = json.dumps(full_data, default=str)
+            projected_str = json.dumps(projected_data, default=str)
+            
+            full_size = len(full_str)
+            projected_size = len(projected_str)
+            
+            size_reduction = ((full_size - projected_size) / full_size) * 100 if full_size > 0 else 0
+            
+            print(f"   Full data size: {full_size} chars")
+            print(f"   Projected data size: {projected_size} chars")
+            print(f"   Size reduction: {size_reduction:.1f}%")
+        
+        return {
+            "full_time": full_time,
+            "projected_time": projected_time,
+            "full_data": full_data,
+            "projected_data": projected_data
+        }
+    
+    async def run_all_tests(self):
+        """Run all taxonomy tests."""
+        print("🚀 Starting Complete Taxonomy Implementation Tests")
+        print("=" * 60)
+        
+        try:
+            await self.setup()
+            
+            # Run all tests in sequence
+            taxonomy_id = await self.test_create_complete_taxonomy()
+            await self.test_list_complete_taxonomy(taxonomy_id)
+            await self.test_projection_list_performance()
+            await self.test_taxonomy_type_filtering()
+            await self.test_projection_with_taxonomy_type()
+            await self.test_uom_conversions_management()
+            await self.test_update_taxonomy_data()
+            await self.test_delete_taxonomy_values()
+            await self.test_performance_comparison()
+            
+            print("\n" + "=" * 60)
+            print("🎉 All tests completed successfully!")
+            print("\n📊 Test Summary:")
+            print("✅ Complete taxonomy creation")
+            print("✅ Full data retrieval")
+            print("✅ Projection list optimization")
+            print("✅ Taxonomy type filtering")
+            print("✅ Combined projection + filtering")
+            print("✅ UOM conversions management")
+            print("✅ Data updates")
+            print("✅ Value deletion")
+            print("✅ Performance comparison")
+            
+        except Exception as e:
+            print(f"\n❌ Test failed with error: {e}")
+            import traceback
+            traceback.print_exc()
+            
+        finally:
+            await self.cleanup()
+
+
+async def main():
+    """Main test runner."""
+    runner = TaxonomyTestRunner()
+    await runner.run_all_tests()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())