statezero 0.1.0b1__py3-none-any.whl

statezero/adaptors/django/orm.py

@@ -0,0 +1,915 @@
+import logging
+from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Type, Union
+
+import networkx as nx
+from django.apps import apps
+from django.db import models
+from django.db.models import Avg, Count, Max, Min, Q, Sum, QuerySet
+from django.db.models.signals import post_delete, post_save, pre_delete, pre_save
+from django.dispatch import receiver
+from rest_framework import serializers
+
+
+from statezero.adaptors.django.config import config, registry
+from statezero.core.classes import FieldNode, ModelNode
+from statezero.core.event_bus import EventBus
+from statezero.core.exceptions import (MultipleObjectsReturned,
+                                       NotFound, PermissionDenied,
+                                       ValidationError)
+from statezero.core.interfaces import (AbstractCustomQueryset,
+                                       AbstractORMProvider, AbstractPermission)
+from statezero.core.types import ActionType, RequestType
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+
+
+# -------------------------------------------------------------------
+# AST Visitor for Django (builds Django Q objects)
+# -------------------------------------------------------------------
+class QueryASTVisitor:
+    SUPPORTED_OPERATORS: Set[str] = {
+        "contains",
+        "icontains",
+        "startswith",
+        "istartswith",
+        "endswith",
+        "iendswith",
+        "lt",
+        "gt",
+        "lte",
+        "gte",
+        "in",
+        "eq",
+        "exact",
+        "isnull",
+    }
+
+    def __init__(self, model: Type[models.Model]) -> None:
+        self.model = model
+
+    def visit(self, node: Dict[str, Any]) -> Q:
+        """Process an AST node and return a Django Q object."""
+        if not node:
+            return Q()
+
+        node_type: str = node.get("type")
+        if not node_type:
+            # Handle implicit filter nodes (raw dict conditions)
+            if isinstance(node, dict) and "conditions" in node:
+                return self.visit_filter(node)
+            return Q()
+
+        method = getattr(self, f"visit_{node_type}", None)
+        if not method:
+            raise ValidationError(f"Unsupported AST node type: {node_type}")
+        return method(node)
+
+    def _combine(
+        self, children: List[Dict[str, Any]], combine_func: Callable[[Q, Q], Q]
+    ) -> Q:
+        """Combine multiple Q objects using the provided function (AND/OR)."""
+        if not children:
+            return Q()  # Return an identity filter when no children exist.
+        q = self.visit(children[0])
+        for child in children[1:]:
+            q = combine_func(q, self.visit(child))
+        return q
+
+    def _process_field_lookup(self, field: str, value: Any) -> Tuple[str, Any]:
+        """
+        This used to contain logic, right now it just passes through the field and value.
+        
+        Args:
+            field: The field lookup string (e.g., 'datetime_field__hour__gt')
+            value: The value to filter by
+            
+        Returns:
+            A tuple of (lookup, value)
+        """            
+        return field, value
+
+    def visit_filter(self, node: Dict[str, Any]) -> Q:
+        """Process a filter node, handling both conditions and Q objects."""
+        q = Q()
+
+        # Process direct conditions
+        conditions: Dict[str, Any] = node.get("conditions", {})
+        for field, value in conditions.items():
+            lookup, processed_value = self._process_field_lookup(field, value)
+            q &= Q(**{lookup: processed_value})
+
+        # Handle Q list format for OR conditions
+        q_objects = node.get("Q", [])
+        if q_objects:
+            q_combined = None
+            for q_condition in q_objects:
+                q_part = Q()
+                for field, value in q_condition.items():
+                    lookup, processed_value = self._process_field_lookup(field, value)
+                    q_part &= Q(**{lookup: processed_value})
+                if q_combined is None:
+                    q_combined = q_part
+                else:
+                    q_combined |= q_part
+            if q_combined:
+                q &= q_combined
+        return q
+
+    def visit_exclude(self, node: Dict[str, Any]) -> Q:
+        """Process an exclude node by negating the inner filter."""
+        # Handle child nodes if present
+        if "child" in node and node["child"]:
+            inner_q = self.visit(node["child"])
+            return ~inner_q
+
+        # Otherwise, treat it as a filter but negate the result
+        return ~self.visit_filter(node)
+
+    def visit_and(self, node: Dict[str, Any]) -> Q:
+        """Process an AND node by combining all children with AND."""
+        return self._combine(node.get("children", []), lambda a, b: a & b)
+
+    def visit_or(self, node: Dict[str, Any]) -> Q:
+        """Process an OR node by combining all children with OR."""
+        return self._combine(node.get("children", []), lambda a, b: a | b)
+    
+    def visit_search(self, node: Dict[str, Any]) -> Q:
+        """
+        Process a search node.
+        Since search is applied as a query modifier in the AST parser and via the ORM adapter,
+        simply return an empty Q object.
+        """
+        return Q()
+
+# -------------------------------------------------------------------
+# Django ORM Adapter (implements our generic engine/provider)
+# -------------------------------------------------------------------
+def check_object_permissions(
+    req: Any,
+    instance: Any,
+    action: ActionType,
+    permissions: List[Type[AbstractPermission]],
+    model: Type,
+) -> None:
+    """
+    Check if the given action is allowed on the instance using each permission class.
+    Raises PermissionDenied if none of the permissions grant access.
+    """
+    allowed_obj_actions = set()
+    for perm_cls in permissions:
+        perm = perm_cls()
+        allowed_obj_actions |= perm.allowed_object_actions(req, instance, model)
+    if action not in allowed_obj_actions:
+        raise PermissionDenied(
+            f"Object-level permission denied: Missing {action.value} on object {instance}"
+        )
+
+
+def check_bulk_permissions(
+    req: Any,
+    items: models.QuerySet,
+    action: ActionType,
+    permissions: List[Type[AbstractPermission]],
+    model: Type,
+) -> None:
+    """
+    If the queryset contains one or fewer items, perform individual permission checks.
+    Otherwise, loop over permission classes and call bulk_operation_allowed.
+    If none allow the bulk operation, raise PermissionDenied.
+    """
+    if items.count() <= 1:
+        for instance in items:
+            check_object_permissions(req, instance, action, permissions, model)
+    else:
+        allowed = False
+        for perm_cls in permissions:
+            perm = perm_cls()
+            # Assume bulk_operation_allowed is defined on all permission classes.
+            if perm.bulk_operation_allowed(req, items, action, model):
+                allowed = True
+                break
+        if not allowed:
+            raise PermissionDenied(
+                f"Bulk {action.value} operation not permitted on queryset"
+            )
+
+
+class DjangoORMAdapter(AbstractORMProvider):
+    def __init__(self) -> None:
+        self.queryset: Optional[Any] = None  # Django QuerySet
+        self.model: Optional[Type[models.Model]] = None
+
+    def set_queryset(self, queryset: Any) -> None:
+        self.queryset = queryset
+        self.model = queryset.model
+
+    # --- QueryEngine Methods ---
+    def filter_node(self, node: Dict[str, Any]) -> None:
+        """Apply a filter node to the queryset."""
+        assert self.model is not None, "Model must be set before filtering."
+        visitor = QueryASTVisitor(self.model)
+        q_object = visitor.visit(node)
+        self.queryset = self.queryset.filter(q_object)
+
+    def search_node(self, search_query: str, search_fields: Set[str]) -> None:
+        """
+        Update the current queryset by applying a full-text search.
+        Assumes that the queryset and model are already set.
+        Uses the search_provider from the global configuration.
+        """
+        # Ensure that a model is set (queryset should already be there as well).
+        assert self.model is not None, "Model must be set before applying search."
+        self.queryset = config.search_provider.search(self.queryset, search_query, search_fields)
+
+    def exclude_node(self, node: Dict[str, Any]) -> None:
+        """Apply an exclude node to the queryset."""
+        assert self.model is not None, "Model must be set before filtering."
+        visitor = QueryASTVisitor(self.model)
+
+        # Handle both direct exclude nodes and exclude nodes with a child filter
+        if "child" in node:
+            # If there's a child node, visit it and exclude the result
+            q_object = visitor.visit(node["child"])
+        else:
+            # Otherwise, treat it as a standard filter node to be negated
+            q_object = visitor.visit(node)
+
+        self.queryset = self.queryset.exclude(q_object)
+
+    def create(self, data: Dict[str, Any], serializer, req, fields_map) -> models.Model:
+        assert self.model is not None, "Model must be set before creating."
+        # Use the provided serializer's save method
+        return serializer.save(
+            model=self.model,
+            data=data,
+            instance=None,
+            partial=False,
+            request=req,
+            fields_map=fields_map
+        )
+
+    def update_instance(
+        self,
+        ast: Dict[str, Any],
+        req: RequestType,
+        permissions: List[Type[AbstractPermission]],
+        serializer,
+        fields_map
+    ) -> models.Model:
+        data = ast.get("data", {})
+        filter_ast = ast.get("filter")
+        if not filter_ast:
+            raise ValueError("Filter is required for update_instance operation")
+
+        visitor = QueryASTVisitor(self.model)
+        q_obj = visitor.visit(filter_ast)
+        instance = self.model.objects.get(q_obj)
+
+        # Check object-level permissions for update.
+        for perm_cls in permissions:
+            perm = perm_cls()
+            allowed = perm.allowed_object_actions(req, instance, self.model)
+            if ActionType.UPDATE not in allowed:
+                raise PermissionDenied(f"Update not permitted on {instance}")
+
+        # Use the provided serializer's save method for the update
+        return serializer.save(
+            model=self.model,
+            data=data,
+            instance=instance,
+            partial=True,
+            request=req,
+            fields_map=fields_map
+        )
+
+    def delete_instance(
+        self,
+        ast: Dict[str, Any],
+        req: RequestType,
+        permissions: List[Type[AbstractPermission]],
+    ) -> int:
+        filter_ast = ast.get("filter")
+        if not filter_ast:
+            raise ValueError("Filter is required for delete_instance operation")
+
+        visitor = QueryASTVisitor(self.model)
+        q_obj = visitor.visit(filter_ast)
+        instance = self.model.objects.get(q_obj)
+
+        # Check object-level permissions.
+        for perm_cls in permissions:
+            perm = perm_cls()
+            allowed = perm.allowed_object_actions(req, instance, self.model)
+            if ActionType.DELETE not in allowed:
+                raise PermissionDenied(f"Delete not permitted on {instance}")
+
+        instance.delete()
+        return 1
+    
+    def get_pk_list(queryset: QuerySet):
+        """
+        Gets a list of primary key values from a QuerySet, handling different PK field names.
+
+        Args:
+            queryset: The Django QuerySet.
+
+        Returns:
+            A list of primary key values.
+        """
+        model = queryset.model
+        pk_field_name = model._meta.pk.name  # Dynamically get the PK field name
+        pk_list = queryset.values_list(pk_field_name, flat=True)
+        return list(pk_list)
+
+    def update(
+        self,
+        node: Dict[str, Any],
+        req: RequestType,
+        permissions: List[Type[AbstractPermission]],
+        readable_fields: Set[str] = None
+    ) -> Tuple[int, List[Dict[str, Union[int, str]]]]:
+        """
+        Update operations with support for F expressions.
+        Includes permission checks for fields referenced in F expressions.
+        """
+        assert self.model is not None, "Model must be set before updating."
+        data: Dict[str, Any] = node.get("data", {})
+        filter_ast: Optional[Dict[str, Any]] = node.get("filter")
+        
+        # Start with self.queryset which already has permission filtering
+        qs: QuerySet = self.queryset
+        if filter_ast:
+            visitor = QueryASTVisitor(self.model)
+            q_obj = visitor.visit(filter_ast)
+            qs = qs.filter(q_obj)
+
+        # Check bulk update permissions
+        check_bulk_permissions(req, qs, ActionType.UPDATE, permissions, self.model)
+
+        model = qs.model
+        
+        # Get the fields to update (keys from data plus primary key)
+        update_fields = list(data.keys())
+        update_fields.append(model._meta.pk.name)
+
+        # Process any F expressions in the update data
+        processed_data = {}
+        from statezero.adaptors.django.f_handler import FExpressionHandler
+        
+        for key, value in data.items():
+            if isinstance(value, dict) and value.get('__f_expr'):
+                # It's an F expression - check permissions and process it
+                try:
+                    # Extract field names referenced in the F expression
+                    referenced_fields = FExpressionHandler.extract_referenced_fields(value)
+                    
+                    # Check that user has READ permissions for all referenced fields
+                    for field in referenced_fields:
+                        if field not in readable_fields:
+                            raise PermissionDenied(
+                                f"No permission to read field '{field}' referenced in F expression"
+                            )
+                    
+                    # Process the F expression now that permissions are verified
+                    processed_data[key] = FExpressionHandler.process_expression(value)
+                except ValueError as e:
+                    logger.error(f"Error processing F expression for field {key}: {e}")
+                    raise ValidationError(f"Invalid F expression for field {key}: {str(e)}")
+            else:
+                # Regular value, use as-is
+                processed_data[key] = value
+        
+        # Execute the update with processed expressions
+        rows_updated = qs.update(**processed_data)
+
+        # After update, fetch the updated instances
+        updated_instances = list(qs.only(*update_fields))
+        
+        # Triggers cache invalidation and broadcast to the frontend
+        config.event_bus.emit_bulk_event(ActionType.BULK_UPDATE, updated_instances)
+
+        return rows_updated, updated_instances
+
+    def delete(
+        self,
+        node: Dict[str, Any],
+        req: RequestType,
+        permissions: List[Type[AbstractPermission]],
+    ) -> Tuple[int, Tuple[int]]:
+        assert self.model is not None, "Model must be set before deleting."
+        filter_ast: Optional[Dict[str, Any]] = node.get("filter")
+        # Start with self.queryset which already has permission filtering
+        qs: QuerySet = self.queryset
+        if filter_ast:
+            visitor = QueryASTVisitor(self.model)
+            q_obj = visitor.visit(filter_ast)
+            qs = qs.filter(q_obj)
+
+        check_bulk_permissions(req, qs, ActionType.DELETE, permissions, self.model)
+        
+        # TODO: this should be a values list, but we need to check the bulk event emitter code
+        model = qs.model
+        pk_field_name = model._meta.pk.name
+        instances = list(qs.only(pk_field_name))
+        
+        deleted, _ = qs.delete()
+
+        # Triggers cache invalidation and broadcast to the frontend
+        config.event_bus.emit_bulk_event(ActionType.BULK_DELETE, instances)
+
+        # Dynamically create a Meta inner class
+        Meta = type("Meta", (), {
+            "model": model,
+            "fields": [pk_field_name],  # Only include the PK field
+        })
+        
+        # Create the serializer class
+        serializer_class = type(
+            f"Dynamic{model.__name__}PkSerializer", 
+            (serializers.ModelSerializer,), 
+            {"Meta": Meta}
+        )
+
+        serializer = serializer_class(instances, many=True)
+                
+        return deleted, serializer.data
+
+    def get(
+        self,
+        node: Dict[str, Any],
+        req: RequestType,
+        permissions: List[Type[AbstractPermission]],
+    ) -> models.Model:
+        """
+        Retrieve a single model instance with permission checks.
+
+        Args:
+            node: The query AST node
+            req: The request object
+            permissions: List of permission classes to check
+
+        Returns:
+            A single model instance
+
+        Raises:
+            NotFound: If no object matches the query
+            PermissionDenied: If the user doesn't have permission to read the object
+            MultipleObjectsReturned: If multiple objects match the query
+        """
+        assert self.model is not None, "Model must be set before retrieving."
+        filter_ast: Optional[Dict[str, Any]] = node.get("filter")
+
+        if filter_ast:
+            visitor = QueryASTVisitor(self.model)
+            q_obj = visitor.visit(filter_ast)
+            try:
+                instance = self.queryset.filter(q_obj).get()
+            except self.model.DoesNotExist:
+                raise NotFound(f"No {self.model.__name__} matches the given query.")
+            except self.model.MultipleObjectsReturned:
+                raise MultipleObjectsReturned(
+                    f"Multiple {self.model.__name__} instances match the given query."
+                )
+        else:
+            try:
+                instance = self.queryset.get()
+            except self.model.DoesNotExist:
+                raise NotFound(f"No {self.model.__name__} matches the given query.")
+            except self.model.MultipleObjectsReturned:
+                raise MultipleObjectsReturned(
+                    f"Multiple {self.model.__name__} instances match the given query."
+                )
+
+        # Check object-level permissions for reading
+        check_object_permissions(
+            req, instance, ActionType.READ, permissions, self.model
+        )
+
+        return instance
+
+    def _normalize_foreign_keys(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        For each key in data, if the value is a model instance, replace it with its primary key.
+        """
+        normalized = {}
+        for key, value in data.items():
+            # Check for model instance by looking for the _meta attribute.
+            if hasattr(value, "_meta"):
+                normalized[key] = value.pk
+            else:
+                normalized[key] = value
+        return normalized
+
+    def get_or_create(
+        self,
+        node: Dict[str, Any],
+        serializer,
+        req: RequestType,
+        permissions: List[Type[AbstractPermission]],
+        create_fields_map
+    ) -> Tuple[models.Model, bool]:
+        """
+        Get an existing object, or create it if it doesn't exist, with object-level permission checks.
+        """
+        lookup = node.get("lookup", {})
+        defaults = node.get("defaults", {})
+
+        # Merge lookup and defaults and normalize foreign key values
+        merged_data = self._normalize_foreign_keys({**lookup, **defaults})
+
+        # Check if an instance exists
+        try:
+            instance = self.queryset.get(**lookup)
+            created = False
+
+            # Check object-level permission to read the existing object
+            check_object_permissions(
+                req, instance, ActionType.READ, permissions, self.model
+            )
+        except self.model.DoesNotExist:
+            # Object doesn't exist, we'll create it
+            instance = None
+            created = True
+        except self.model.MultipleObjectsReturned as e:
+            raise MultipleObjectsReturned(
+                f"Multiple {self.model.__name__} instances match the given lookup parameters"
+            )
+
+        # If the instance exists, we don't need to update it, just return it
+        if not created:
+            return instance, created
+
+        # Only create a new instance if it doesn't exist
+        instance = serializer.save(
+            model=self.model,
+            data=merged_data,
+            instance=None,  # No instance for creation
+            partial=False,   # Not a partial update for creation
+            request=req,
+            fields_map=create_fields_map
+        )
+
+        return instance, created
+
+    def update_or_create(
+        self,
+        node: Dict[str, Any],
+        req: RequestType,
+        serializer,
+        permissions: List[Type[AbstractPermission]],
+        update_fields_map,
+        create_fields_map
+    ) -> Tuple[models.Model, bool]:
+        """
+        Update an existing object, or create it if it doesn't exist, with object-level permission checks.
+        """
+        lookup = node.get("lookup", {})
+        defaults = node.get("defaults", {})
+
+        # Merge lookup and defaults and normalize foreign key values
+        merged_data = self._normalize_foreign_keys({**lookup, **defaults})
+
+        # Determine if the instance exists
+        try:
+            instance = self.queryset.get(**lookup)
+            created = False
+
+            # Perform object-level permission check before update
+            check_object_permissions(
+                req, instance, ActionType.UPDATE, permissions, self.model
+            )
+        except self.model.DoesNotExist:
+            # Object doesn't exist, we'll create it
+            instance = None
+            created = True
+        except self.model.MultipleObjectsReturned as e:
+            raise MultipleObjectsReturned(
+                f"Multiple {self.model.__name__} instances match the given lookup parameters"
+            )
+        
+        fields_map_to_use = create_fields_map if created else update_fields_map
+
+        # Use the serializer's save method, which handles validation and saving
+        instance = serializer.save(
+            model=self.model,
+            data=merged_data,
+            instance=instance,
+            request=req,
+            fields_map=fields_map_to_use
+        )
+
+        return instance, created
+
+    def first(self) -> Optional[models.Model]:
+        return self.queryset.first() if self.queryset is not None else None
+
+    def last(self) -> Optional[models.Model]:
+        return self.queryset.last() if self.queryset is not None else None
+
+    def exists(self) -> bool:
+        return self.queryset.exists() if self.queryset is not None else False
+
+    def aggregate(self, agg_list: List[Dict[str, Any]]) -> Dict[str, Any]:
+        agg_expressions = {}
+        for agg in agg_list:
+            func = agg.get("function")
+            field = agg.get("field")
+            alias = agg.get("alias")
+            if func == "count":
+                agg_expressions[alias] = Count(field)
+            elif func == "sum":
+                agg_expressions[alias] = Sum(field)
+            elif func == "avg":
+                agg_expressions[alias] = Avg(field)
+            elif func == "min":
+                agg_expressions[alias] = Min(field)
+            elif func == "max":
+                agg_expressions[alias] = Max(field)
+            else:
+                raise ValidationError(f"Unknown aggregate function: {func}")
+        result = self.queryset.aggregate(**agg_expressions)
+        return {"data": result, "metadata": {"aggregated": True}}
+
+    def count(self, field: str) -> int:
+        result = self.queryset.aggregate(result=Count(field))["result"]
+        return int(result) if result is not None else 0
+
+    def sum(self, field: str) -> Optional[Union[int, float]]:
+        return self.queryset.aggregate(result=Sum(field))["result"]
+
+    def avg(self, field: str) -> Optional[float]:
+        result = self.queryset.aggregate(result=Avg(field))["result"]
+        return float(result) if result is not None else None
+
+    def min(self, field: str) -> Optional[Union[int, float, str]]:
+        return self.queryset.aggregate(result=Min(field))["result"]
+
+    def max(self, field: str) -> Optional[Union[int, float, str]]:
+        return self.queryset.aggregate(result=Max(field))["result"]
+
+    def order_by(self, order_list: List[str]) -> None:
+        self.queryset = self.queryset.order_by(*order_list)
+
+    def select_related(self, related_fields: List[str]) -> None:
+        self.queryset = self.queryset.select_related(*related_fields)
+
+    def prefetch_related(self, related_fields: List[str]) -> None:
+        self.queryset = self.queryset.prefetch_related(*related_fields)
+
+    def select_fields(self, fields: List[str]) -> None:
+        self.queryset = self.queryset.values(*fields)
+
+    def fetch_list(
+        self,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+        req: RequestType = None,
+        permissions: List[Type[AbstractPermission]] = None,
+    ) -> QuerySet:
+        """
+        Fetch a list of model instances with bulk permission checks.
+
+        Args:
+            offset: The offset for pagination
+            limit: The limit for pagination
+            req: The request object
+            permissions: List of permission classes to check
+
+        Returns:
+            A list of model instances after permission checks
+        """
+        offset = offset or 0
+
+        # First, get the paginated queryset
+        if limit is None:
+            qs = self.queryset[offset:]
+        else:
+            qs = self.queryset[offset : offset + limit]
+
+        # If permissions are provided, perform bulk permission checks
+        if req is not None and permissions:
+            # Use the existing bulk permission check function
+            check_bulk_permissions(req, qs, ActionType.READ, permissions, self.model)
+
+        return qs
+
+    def _build_conditions(self, conditions: dict) -> Q:
+        visitor = QueryASTVisitor(self.model)
+        fake_ast = {"type": "filter", "conditions": conditions}
+        return visitor.visit(fake_ast)
+
+    # --- AbstractORMProvider Methods ---
+    def get_queryset(
+        self,
+        req: RequestType,
+        model: Type,
+        initial_ast: Dict[str, Any],
+        custom_querysets: Dict[str, Type[AbstractCustomQueryset]],
+        registered_permissions: List[Type[AbstractPermission]],
+    ) -> Any:
+        custom_name = initial_ast.get("custom_queryset")
+        if custom_name and custom_name in custom_querysets:
+            custom_queryset_class = custom_querysets[custom_name]
+            return custom_queryset_class().get_queryset(req)
+        return model.objects.all()
+    
+    def get_fields(self, model: models.Model) -> Set[str]:
+        """
+        Return a set of the model fields.
+        """
+        model_config = registry.get_config(model)
+        if model_config.fields and "__all__" != model_config.fields:
+            resolved_fields = model_config.fields
+        else:
+            resolved_fields = set((field.name for field in model._meta.get_fields()))
+            additional_fields = set((field.name for field in model_config.additional_fields))
+            resolved_fields = resolved_fields.union(additional_fields)
+        return resolved_fields
+
+    def build_model_graph(
+        self, model: Type[models.Model], model_graph: nx.DiGraph = None
+    ) -> nx.DiGraph:
+        """
+        Build a directed graph of models and their fields, focusing on direct relationships.
+        
+        Args:
+            model: The Django model to build the graph for
+            model_graph: An existing graph to add to (optional)
+            
+        Returns:
+            nx.DiGraph: The model graph
+        """
+        from django.db.models.fields.related import RelatedField, ForeignObjectRel
+        
+        if model_graph is None:
+            model_graph = nx.DiGraph()
+            
+        # Use the adapter's get_model_name method.
+        model_name = self.get_model_name(model)
+        
+        # Add the model node if it doesn't exist.
+        if not model_graph.has_node(model_name):
+            model_graph.add_node(
+                model_name, data=ModelNode(model_name=model_name, model=model)
+            )
+        
+        # Iterate over all fields in the model.
+        for field in model._meta.get_fields():
+            field_name = field.name
+            
+            # Skip reverse relations for validation purposes
+            # These are relationships defined on other models pointing to this model
+            if isinstance(field, ForeignObjectRel):
+                continue
+                
+            field_node = f"{model_name}::{field_name}"
+            field_node_data = FieldNode(
+                model_name=model_name,
+                field_name=field_name,
+                is_relation=field.is_relation,
+                related_model=(
+                    self.get_model_name(field.related_model)
+                    if field.is_relation and field.related_model
+                    else None
+                ),
+            )
+            model_graph.add_node(field_node, data=field_node_data)
+            model_graph.add_edge(model_name, field_node)
+            
+            if field.is_relation and field.related_model:
+                related_model = field.related_model
+                related_model_name = self.get_model_name(related_model)
+                if not model_graph.has_node(related_model_name):
+                    self.build_model_graph(related_model, model_graph)
+                model_graph.add_edge(field_node, related_model_name)
+        
+        # Add additional (computed) fields from the model's configuration.
+        try:
+            from statezero.adaptors.django.config import registry
+            
+            config = registry.get_config(model)
+            for additional_field in config.additional_fields:
+                add_field_name = additional_field.name
+                add_field_node = f"{model_name}::{add_field_name}"
+                is_rel = False
+                related_model_name = None
+                if isinstance(
+                    additional_field.field,
+                    (models.ForeignKey, models.OneToOneField, models.ManyToManyField),
+                ):
+                    is_rel = True
+                    related = getattr(additional_field.field, "related_model", None)
+                    if related:
+                        related_model_name = self.get_model_name(related)
+                add_field_node_data = FieldNode(
+                    model_name=model_name,
+                    field_name=add_field_name,
+                    is_relation=is_rel,
+                    related_model=related_model_name,
+                )
+                model_graph.add_node(add_field_node, data=add_field_node_data)
+                model_graph.add_edge(model_name, add_field_node)
+        except ValueError:
+            pass
+        
+        return model_graph
+
+    def register_event_signals(self, event_bus: EventBus) -> None:
+        def pre_save_receiver(sender, instance, **kwargs):
+            if not instance.pk:
+                return # It can't be used for cache invalidation, cause there's no pk
+            
+            action = ActionType.PRE_UPDATE
+            try:
+                event_bus.emit_event(action, instance)
+            except Exception as e:
+                logger.exception(
+                    "Error emitting event %s for instance %s: %s", action, instance, e
+                )
+
+        def post_save_receiver(sender, instance, created, **kwargs):
+            action = ActionType.CREATE if created else ActionType.UPDATE
+            try:
+                event_bus.emit_event(action, instance)
+            except Exception as e:
+                logger.exception(
+                    "Error emitting event %s for instance %s: %s", action, instance, e
+                )
+                
+        def pre_delete_receiver(sender, instance, **kwargs):
+            try:
+                # Use PRE_DELETE action type for cache invalidation before DB operation
+                event_bus.emit_event(ActionType.PRE_DELETE, instance)
+            except Exception as e:
+                logger.exception(
+                    "Error emitting PRE_DELETE event for instance %s: %s", instance, e
+                )
+
+        def post_delete_receiver(sender, instance, **kwargs):
+            try:
+                event_bus.emit_event(ActionType.DELETE, instance)
+            except Exception as e:
+                logger.exception(
+                    "Error emitting DELETE event for instance %s: %s", instance, e
+                )
+
+        from statezero.adaptors.django.config import config, registry
+
+        for model in registry._models_config.keys():
+            model_name = config.orm_provider.get_model_name(model)
+            
+            # Register pre_save signals (new)
+            uid_pre_save = f"statezero:{model_name}:pre_save"
+            pre_save.disconnect(sender=model, dispatch_uid=uid_pre_save)
+            receiver(pre_save, sender=model, weak=False, dispatch_uid=uid_pre_save)(
+                pre_save_receiver
+            )
+            
+            # Register post_save signals
+            uid_save = f"statezero:{model_name}:post_save"
+            post_save.disconnect(sender=model, dispatch_uid=uid_save)
+            receiver(post_save, sender=model, weak=False, dispatch_uid=uid_save)(
+                post_save_receiver
+            )
+            
+            # Register pre_delete signals
+            uid_pre_delete = f"statezero:{model_name}:pre_delete"
+            pre_delete.disconnect(sender=model, dispatch_uid=uid_pre_delete)
+            receiver(pre_delete, sender=model, weak=False, dispatch_uid=uid_pre_delete)(
+                pre_delete_receiver
+            )
+            
+            # Register post_delete signals
+            uid_delete = f"statezero:{model_name}:post_delete"
+            post_delete.disconnect(sender=model, dispatch_uid=uid_delete)
+            receiver(post_delete, sender=model, weak=False, dispatch_uid=uid_delete)(
+                post_delete_receiver
+            )
+
+    def get_model_by_name(self, model_name: str) -> Type[models.Model]:
+        try:
+            app_label, model_cls = model_name.split(".")
+            model = apps.get_model(app_label, model_cls)
+            if model is None:
+                raise NotFound(f"Unknown model: {model_name}")
+            return model
+        except ValueError:
+            raise NotFound(
+                f"Model name '{model_name}' must be in the format 'app_label.ModelName'"
+            )
+
+    def get_model_name(
+        self, model: Union[models.Model, Type[models.Model]]
+    ) -> str:  # type:ignore
+        if not isinstance(model, type):
+            model = model.__class__
+        if hasattr(model, "_meta"):
+            return f"{model._meta.app_label}.{model._meta.model_name}"
+        raise ValueError(
+            f"Cannot determine model name from {model} of type {type(model)}: _meta attribute is missing from the model."
+        )
+    
+    def get_user(self, request):
+        """ Return the user """
+        return request.user