Migrate to terminusb for Distributed system support like github

Makefile

@@ -1,9 +1,11 @@
-.PHONY: help install-backend run-backend install-frontend run-frontend install
+.PHONY: help install-backend run-backend install-frontend run-frontend install start-db stop-db
 
 help:
 	@echo "Commands:"
 	@echo "  install          : Install all dependencies for backend and frontend."
 	@echo "  install-backend  : Install backend dependencies."
+	@echo "  start-db         : Start TerminusDB (Docker) on http://localhost:6363."
+	@echo "  stop-db          : Stop TerminusDB."
 	@echo "  run-backend      : Start backend development server on http://localhost:8000."
 	@echo "  run-rpc          : Start JSON-RPC server on http://localhost:8050/api/v1/jsonrpc."
 	@echo "  run-servers      : Start backend and JSON-RPC servers."
@@ -20,12 +22,12 @@ install-backend:
 	@uv pip install -r src/backend/requirements.txt --python .venv/bin/python
 
 start-db:
-	@echo ">>> Starting ArangoDB..."
-	@docker-compose -f src/backend/docker-compose.yml --env-file src/backend/.env up -d
+	@echo ">>> Starting TerminusDB..."
+	@docker compose -f src/backend/docker-compose.yml --env-file src/backend/.env up -d
 
 stop-db:
-	@echo ">>> Stopping ArangoDB..."
-	@docker-compose -f src/backend/docker-compose.yml --env-file src/backend/.env down
+	@echo ">>> Stopping TerminusDB..."
+	@docker compose -f src/backend/docker-compose.yml --env-file src/backend/.env down
 
 run-backend: start-db
 	@echo ">>> Starting backend development server..."

src/backend/.env.example

@@ -1,9 +1,12 @@
 # .env.example
 APP_ENV=development
-ARANGO_HOST=http://localhost:8529
-ARANGO_USER=app_user
-ARANGO_PASSWORD=app_password
-ARANGO_DB=_system
-ARANGO_ROOT_PASSWORD=password
+TERMINUS_HOST=http://localhost:6363
+TERMINUS_DB=v_noc
+TERMINUS_USER=admin
+TERMINUS_KEY=root
+TERMINUS_TEAM=admin
+
+# TerminusDB Docker admin password (must match TERMINUS_KEY for API auth)
+TERMINUSDB_ADMIN_PASS=root
 
 PORT=8000

src/backend/app/api/dependencies.py

@@ -1,76 +1,84 @@
-from fastapi import Depends
+from typing import Optional
+from fastapi import Depends, Header, Query, HTTPException
 from app.core.repository import Repositories
 from app.core.services.project_service import ProjectService
-from app.db.client import get_db
-from arangoasync.database import AsyncDatabase
-from app.core.services.container_service import ContainerService
-from app.core.services.file_service import FileService
-from app.core.services.class_service import ClassService
-from app.core.services.function_service import FunctionService
+from app.core.services.code_element_service import CodeElementService
+
 from app.core.services.call_service import CallService
 from app.core.services.log_service import LogService
 from app.core.services.group_service import GroupService
 from app.core.services.document_service import DocumentService
-
-
-def get_group_service(
-    db: AsyncDatabase = Depends(get_db),
-) -> GroupService:
-    repos = Repositories(db)
-    return GroupService(repos)
+from app.db.client import get_terminus_client
+from app.db.async_terminus_client import AsyncClient
+from app.core.model.nodes import ProjectNode
+from app.db.context import RequestDbContext, ProjectUoW
 
 
 def get_project_service(
-    db: AsyncDatabase = Depends(get_db),
+    db: AsyncClient = Depends(get_terminus_client),
 ) -> ProjectService:
-    repos = Repositories(db)
-    return ProjectService(repos)
+    pow = ProjectUoW(db.clone(), None, RequestDbContext())
+    return ProjectService(pow)
 
 
-def get_container_service(
-    db: AsyncDatabase = Depends(get_db),
-) -> ContainerService:
-    repos = Repositories(db)
-    return ContainerService(repos)
+async def get_request_db_context(
+    branch: str = Header("main", alias="X-Vnoc-Branch"),
+    ref: Optional[str] = Query(
+        None, description="Specific commit/ref to query"),
+) -> RequestDbContext:
+    return RequestDbContext(branch=branch, ref=ref)
 
 
-def get_file_service(
-    db: AsyncDatabase = Depends(get_db),
-) -> FileService:
-    repos = Repositories(db)
-    return FileService(repos)
+async def get_project_node(
+    project_id: str = Query(..., description="The ID of the project"),
+    project_service: ProjectService = Depends(get_project_service),
+) -> ProjectNode:
+    project = await project_service.get(project_id)
+    return ProjectNode.from_raw_dict(project)
 
 
-def get_class_service(
-    db: AsyncDatabase = Depends(get_db),
-) -> ClassService:
-    repos = Repositories(db)
-    return ClassService(repos)
+async def get_project_uow(
+    base: AsyncClient = Depends(get_terminus_client),
+    project: ProjectNode = Depends(get_project_node),
+    ctx: RequestDbContext = Depends(get_request_db_context),
+):
+    """Async generator dependency. FastAPI enters it and passes the yielded ProjectUoW."""
+    try:
+        yield ProjectUoW(base, project, ctx)
+    finally:
+        pass
 
 
-def get_function_service(
-    db: AsyncDatabase = Depends(get_db),
-) -> FunctionService:
-    repos = Repositories(db)
-    return FunctionService(repos)
+def get_project_service_with_uow(
+    uow: ProjectUoW = Depends(get_project_uow),
+) -> ProjectService:
+    return ProjectService(uow)
+
+
+def get_group_service(
+    uow: ProjectUoW = Depends(get_project_uow)
+) -> GroupService:
+    return GroupService(uow)
 
 
 def get_call_service(
-    db: AsyncDatabase = Depends(get_db),
+    uow: ProjectUoW = Depends(get_project_uow)
 ) -> CallService:
-    repos = Repositories(db)
-    return CallService(repos)
+
+    return CallService(uow)
 
 
 def get_log_service(
-    db: AsyncDatabase = Depends(get_db),
+    uow: ProjectUoW = Depends(get_project_uow)
 ) -> LogService:
-    repos = Repositories(db)
-    return LogService(repos)
+    return LogService(uow)
+
+
+async def get_code_element_service(
+    uow: ProjectUoW = Depends(get_project_uow)
+) -> CodeElementService:
+    return CodeElementService(uow)
 
 
-def get_document_service(
-    db: AsyncDatabase = Depends(get_db),
-) -> DocumentService:
-    repos = Repositories(db)
-    return DocumentService(repos)
+def get_document_service(uow: ProjectUoW = Depends(get_project_uow)) -> DocumentService:
+    return DocumentService(uow)

src/backend/app/api/json_rpc/dependencies.py

@@ -1,82 +1,58 @@
-from fastapi import Depends, Body
-from arangoasync.database import AsyncDatabase
 from typing import Optional
-from app.db.client import get_db
-from app.core.repository import Repositories
-from app.core.services.project_service import ProjectService
-from app.core.services.file_service import FileService
-from app.core.services.class_service import ClassService
-from app.core.services.function_service import FunctionService
-from app.core.services.call_service import CallService
+from fastapi import Depends, Body
+
+from app.db.client import get_terminus_client
+from app.db.context import RequestDbContext, ProjectUoW
+from app.core.model.nodes import ProjectNode
 from app.core.services.log_service import LogService
 
+from app.api.dependencies import get_project_service
 
-def get_services(db: AsyncDatabase = Depends(get_db)):
-    repos = Repositories(db)
-    return (
-        ProjectService(repos),
-        FileService(repos),
-        ClassService(repos),
-        FunctionService(repos),
-        CallService(repos),
-        LogService(repos),
-    )
 
+def get_jsonrpc_request_db_context() -> RequestDbContext:
+    """JSON-RPC uses default branch/ref since params come from body."""
+    return RequestDbContext(branch="main", ref=None)
 
-async def get_project(
+
+def get_jsonrpc_project_id(
     project_id: str = Body(..., embed=True, alias="project_id"),
-    services=Depends(get_services),
-):
+) -> str:
+    return project_id
+
+
+async def get_jsonrpc_project_node(
+    project_id: str = Depends(get_jsonrpc_project_id),
+    project_service=Depends(get_project_service),
+) -> Optional[ProjectNode]:
     try:
-        project_service, *_ = services
+
         project = await project_service.get(project_id)
 
-        return project
+        return ProjectNode.from_raw_dict(project) if project else None
     except Exception as e:
         print("Error getting project", e)
         return None
 
 
-def get_function_services(services=Depends(get_services)):
-    _, _, _, function_service, _, _ = services
-    return function_service
-
-
-async def get_function(
-    function_id: str = Body(..., embed=True, alias="function_id"),
-    services=Depends(get_function_services),
+async def get_jsonrpc_project_uow(
+    base=Depends(get_terminus_client),
+    project: Optional[ProjectNode] = Depends(get_jsonrpc_project_node),
+    ctx: RequestDbContext = Depends(get_jsonrpc_request_db_context),
 ):
-    func_node = None
+    """Async generator dependency. FastAPI enters it and passes the yielded ProjectUoW."""
     try:
-        function_service = services
-
-        func_node = await function_service.get(function_id)
-
-    except Exception as e:
-        print("Error getting function", e)
+        yield ProjectUoW(base, project, ctx)
     finally:
-        return func_node
+        pass
 
 
-async def get_parent_function(
-    parent_function_id: Optional[str] = Body(
-        None, embed=True, alias="parent_function_id"
-    ),
-    services=Depends(get_function_services),
+async def get_project(
+    project_node: Optional[ProjectNode] = Depends(get_jsonrpc_project_node),
 ):
-    parent_func_node = None
-    try:
-        function_service = services
-
-        if parent_function_id is not None:
-            parent_func_node = await function_service.get(parent_function_id)
-
-    except Exception as e:
-        print("Error getting function", e)
-    finally:
-        return parent_func_node
+    return project_node
 
 
-def get_log_service(services=Depends(get_services)):
-    *_, log_service = services
-    return log_service
+def get_log_service(
+    uow: ProjectUoW = Depends(get_jsonrpc_project_uow),
+) -> LogService:
+    return LogService(uow)

src/backend/app/api/json_rpc/schemas.py

@@ -4,12 +4,7 @@
 
 from pydantic import BaseModel, ConfigDict, Field
 
-
-class LogEventType(str, Enum):
-    ENTER = "enter"
-    EXIT = "exit"
-    ERROR = "error"
-    LOG = "log"
+from app.core.model.logs import LogLevelName, LogEventType
 
 
 class RegisterLogsParams(BaseModel):
@@ -36,7 +31,7 @@ class RegisterLogsParams(BaseModel):
     message: str = Field(
         ..., description="Message"
     )
-    level_name: Optional[str] = Field(
+    level_name: Optional[LogLevelName] = Field(
         None, description="Log level name (e.g., info, warning, error)"
     )
     payload: Optional[Dict[str, Any]] = Field(

src/backend/app/api/root.py

@@ -1,11 +1,11 @@
 from fastapi import APIRouter
 from . import health
 from .v1 import project_routes
-from .v1 import container_routes
 from .v1 import code_routes
 from .v1 import logger_routes
 from .v1 import document_routes
-from .v1 import call_routes
+from .v1.versioning import router as versioning_router
+# from .v1 import call_routes
 from .v1 import group_routes
 
 router = APIRouter()
@@ -22,8 +22,8 @@ def get_root():
 router.include_router(project_routes.router,
                       prefix="/projects", tags=["projects"])
 
-router.include_router(
-    container_routes.router, prefix="/containers", tags=["containers"])
+# router.include_router(
+#     container_routes.router, prefix="/containers", tags=["containers"])
 
 router.include_router(
     code_routes.router, prefix="/code-elements", tags=["code-elements"]
@@ -34,6 +34,9 @@ def get_root():
 router.include_router(document_routes.router,
                       prefix="/documents", tags=["documents"])
 
-router.include_router(call_routes.router, prefix="/calls", tags=["calls"])
+router.include_router(
+    versioning_router, prefix="/versioning", tags=["versioning"])
+
+# router.include_router(call_routes.router, prefix="/calls", tags=["calls"])
 
 router.include_router(group_routes.router, prefix="/groups", tags=["groups"])