LIF-771: Expose export transformation group endpoint (LIF-Initiative#879)

Introduces a new export transformation group endpoint, enabling users to
download a given transformation group and it's transformations in a JSON
format suitable for external use.

There will be a follow up PR(s) to harden the endpoint and possibly
expand the testing, but this will allow the basic functionality so the
FE can be wired in.

##### Type of Change

- [x] New feature (non-breaking change which adds functionality)

##### Project Area(s) Affected

- [x] bases/
- [x] components/
- [x] API endpoints
- [ ] Documentation
- [x] Testing

---

##### Checklist

- [x] commit message follows commit guidelines (see
commitlint.config.mjs)
- [x] tests are included (unit and/or integration tests)
- [ ] documentation is changed or added (in /docs directory)
- [x] code passes linting checks (`uv run ruff check`)
- [x] code passes formatting checks (`uv run ruff format`)
- [ ] code passes type checking (`uv run ty check`)
- [x] pre-commit hooks have been run successfully
- [ ] database schema changes: migration files created and CHANGELOG.md
updated
- [ ] API changes: base (Python code) documentation in `docs/`
      and project README updated
- [ ] configuration changes: relevant folder README updated
- [ ] breaking changes: added to MIGRATION.md with upgrade instructions
      and CHANGELOG.md entry

##### Testing
<!-- Describe the testing you've done -->

- [x] Manual testing performed
- [x] Automated tests added/updated
- [ ] Integration testing completed

Author: cbeach47

bases/lif/mdr_restapi/transformation_endpoint.py

@@ -1,6 +1,8 @@
+import json
 from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, Depends, Query, Request, Response, status
+from fastapi.encoders import jsonable_encoder
 from lif.mdr_dto.transformation_dto import (
     CreateTransformationDTO,
     CreateTransformationGroupDTO,
@@ -225,6 +227,20 @@ async def get_all_transformation_groups(
     return {"total": total_count, "data": transformations}
 
 
+@router.get("/{transformation_group_id}/export")
+async def export_transformation_group(transformation_group_id: int, session: AsyncSession = Depends(get_session)):
+    _, group_data = await transformation_service.get_paginated_transformations_for_a_group(
+        session=session, group_id=transformation_group_id, pagination=False, make_exportable=True
+    )
+    # Normalize to JSON-safe Python objects
+    encoded = jsonable_encoder(group_data)
+    # Force download as .json
+    filename = f"transformation-group-{transformation_group_id}.json"
+    headers = {"Content-Disposition": f'attachment; filename="{filename}"'}
+    payload = json.dumps(encoded, indent=2)
+    return Response(content=payload, media_type="application/json", headers=headers)
+
+
 @router.get("/{transformation_group_id}", response_model=Dict[str, Any])
 async def get_all_transformations_for_a_group(
     request: Request,

components/lif/mdr_services/transformation_service.py

@@ -6,6 +6,7 @@
     DatamodelElementType,
     DataModelType,
     EntityAttributeAssociation,
+    ExpressionLanguageType,
     Transformation,
     TransformationAttribute,
     TransformationGroup,
@@ -1023,8 +1024,53 @@ async def get_transformation_group_by_id(session: AsyncSession, id: int):
     return transformation_group
 
 
+async def _resolve_entity_id_path_to_named_path(
+    session: AsyncSession, id_path: str, cache: dict[tuple[str, int], str]
+) -> str:
+    from lif.datatypes.mdr_sql_model import Attribute, Entity
+
+    ids = parse_transformation_path(id_path)
+    segments: list[str] = []
+
+    for i, raw_id in enumerate(ids):
+        is_last = i == len(ids) - 1
+        if not is_last and raw_id < 0:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Unable to export - invalid path '{id_path}': non-terminal ID '{raw_id}' must be positive",
+            )
+        is_attribute = is_last and raw_id < 0
+        cleaned_id = abs(raw_id)
+        cache_key = ("attribute" if is_attribute else "entity", cleaned_id)
+
+        if cache_key not in cache:
+            record = await session.get(Attribute, cleaned_id) if is_attribute else await session.get(Entity, cleaned_id)
+            record_type = cache_key[0].capitalize()
+            if not record:
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"Unable to export - {record_type} ID {cleaned_id} in path '{id_path}' not found",
+                )
+            if record.Deleted == True:
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"Unable to export - {record_type} ID {cleaned_id} in path '{id_path}' is deleted",
+                )
+            record_type_flag = "~" if is_attribute else ""
+            cache[cache_key] = f"{record.DataModelId}:{record_type_flag}{record.UniqueName}"
+
+        segments.append(cache[cache_key])
+
+    return ",".join(segments)
+
+
 async def get_paginated_transformations_for_a_group(
-    session: AsyncSession, group_id: int, offset: int = 0, limit: int = 10, pagination: bool = True
+    session: AsyncSession,
+    group_id: int,
+    offset: int = 0,
+    limit: int = 10,
+    pagination: bool = True,
+    make_exportable: bool = False,  # Only is honored when pagination is False and this is set to True.
 ):
     transformation_group = await get_transformation_group_by_id(session=session, id=group_id)
     transformation_group_dto = TransformationGroupDTO.from_orm(transformation_group)
@@ -1053,15 +1099,14 @@ async def get_paginated_transformations_for_a_group(
             .limit(limit)
         )
     else:
-        transformations_query = (
-            select(Transformation)
-            .where(Transformation.TransformationGroupId == group_id, Transformation.Deleted == False)
-            .order_by(Transformation.Id)
-        )
+        where_expressions = [Transformation.TransformationGroupId == group_id, Transformation.Deleted == False]
+        if make_exportable:
+            where_expressions.append(Transformation.ExpressionLanguage == ExpressionLanguageType.JSONata)
+        transformations_query = select(Transformation).where(*where_expressions).order_by(Transformation.Id)
 
     result = await session.execute(transformations_query)
     transformations = result.scalars().all()
-
+    entity_attribute_cache: dict[tuple[str, int], str] = {}
     for transformation in transformations:
         # Get related transformation attributes
         query = select(TransformationAttribute).where(
@@ -1101,6 +1146,11 @@ async def get_paginated_transformations_for_a_group(
                 EntityIdPath=transformation_attribute.EntityIdPath,
             )
 
+            if make_exportable:
+                attribute_dto.EntityIdPath = await _resolve_entity_id_path_to_named_path(
+                    session=session, id_path=transformation_attribute.EntityIdPath, cache=entity_attribute_cache
+                )
+
             # Assign based on the attribute type (Source or Target)
             if transformation_attribute.AttributeType == "Source":
                 source_attribute_dtos.append(attribute_dto)