fix: initialize latestActionEpoch to 0 to prevent race condition

Author: adamghill

src/django_unicorn/static/unicorn/js/component.js

@@ -59,7 +59,7 @@ export class Component {
     this.initPolling();
 
     // epoch is the time in milliseconds when the packet was created
-    this.latestActionEpoch = new Date().getTime();
+    this.latestActionEpoch = 0;
 
     this.callCalls(args.calls);
   }

src/django_unicorn/views/action.py

@@ -1,6 +1,20 @@
-from typing import Any
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
 
 from django_unicorn.call_method_parser import parse_call_method_name
+from django_unicorn.components import UnicornView
+
+if TYPE_CHECKING:
+    from django_unicorn.views.request import ComponentRequest
+
+
+@dataclass
+class HandleResult:
+    component: UnicornView
+    is_refresh_called: bool = False
+    is_reset_called: bool = False
+    validate_all_fields: bool = False
+    return_data: Any = None
 
 
 class Action:
@@ -21,6 +35,32 @@ def __init__(self, data: dict[str, Any]):
     def __repr__(self):
         return f"Action(type='{self.action_type}', payload={self.payload})"
 
+    def __eq__(self, other):
+        if not isinstance(other, Action):
+            return False
+        return (
+            self.action_type == other.action_type and self.payload == other.payload and self.partials == other.partials
+        )
+
+    __hash__ = None
+
+    def to_json(self) -> dict:
+        return {
+            "type": self.action_type,
+            "payload": self.payload,
+            "partials": self.partials,
+        }
+
+    def handle(self, component_request: "ComponentRequest", component: UnicornView) -> HandleResult:
+        from django_unicorn.views.action_parsers import sync_input  # noqa: PLC0415
+
+        # Generic handler fallback
+        if self.action_type == "syncInput":
+            sync_input.handle(component_request, component, self.payload)
+            return HandleResult(component=component)
+
+        return HandleResult(component=component)
+
 
 class SyncInput(Action):
     __slots__ = ("name", "value")
@@ -33,6 +73,19 @@ def __init__(self, data: dict[str, Any]):
     def __repr__(self):
         return f"SyncInput(name='{self.name}', value='{self.value}')"
 
+    def __eq__(self, other):
+        if not isinstance(other, SyncInput):
+            return False
+        return super().__eq__(other) and self.name == other.name and self.value == other.value
+
+    __hash__ = None
+
+    def handle(self, component_request: "ComponentRequest", component: UnicornView) -> HandleResult:
+        from django_unicorn.views.action_parsers import sync_input  # noqa: PLC0415
+
+        sync_input.handle(component_request, component, self.payload)
+        return HandleResult(component=component)
+
 
 class CallMethod(Action):
     __slots__ = ("args", "kwargs", "method_name")
@@ -46,20 +99,67 @@ def __init__(self, data: dict[str, Any]):
     def __repr__(self):
         return f"CallMethod(method_name='{self.method_name}', args={self.args}, kwargs={self.kwargs})"
 
+    def __eq__(self, other):
+        if not isinstance(other, CallMethod):
+            return False
+        return (
+            super().__eq__(other)
+            and self.method_name == other.method_name
+            and self.args == other.args
+            and self.kwargs == other.kwargs
+        )
+
+    __hash__ = None
+
+    def handle(self, component_request: "ComponentRequest", component: UnicornView) -> HandleResult:
+        from django_unicorn.views.action_parsers import call_method  # noqa: PLC0415
+
+        (
+            component,
+            is_refresh_called,
+            is_reset_called,
+            validate_all_fields,
+            return_data,
+        ) = call_method.handle(component_request, component, self.payload)
+
+        return HandleResult(
+            component=component,
+            is_refresh_called=is_refresh_called,
+            is_reset_called=is_reset_called,
+            validate_all_fields=validate_all_fields,
+            return_data=return_data,
+        )
+
 
 class Reset(Action):
     __slots__ = ()
 
     def __repr__(self):
         return "Reset()"
 
+    def __eq__(self, other):
+        return isinstance(other, Reset) and super().__eq__(other)
+
+    __hash__ = None
+
+    def handle(self, component_request: "ComponentRequest", component: UnicornView) -> HandleResult:
+        return CallMethod(self.to_json()).handle(component_request, component)
+
 
 class Refresh(Action):
     __slots__ = ()
 
     def __repr__(self):
         return "Refresh()"
 
+    def __eq__(self, other):
+        return isinstance(other, Refresh) and super().__eq__(other)
+
+    __hash__ = None
+
+    def handle(self, component_request: "ComponentRequest", component: UnicornView) -> HandleResult:
+        return CallMethod(self.to_json()).handle(component_request, component)
+
 
 class Toggle(Action):
     __slots__ = ("args", "kwargs", "method_name")
@@ -73,3 +173,18 @@ def __init__(self, data: dict[str, Any]):
 
     def __repr__(self):
         return f"Toggle(args={self.args})"
+
+    def __eq__(self, other):
+        if not isinstance(other, Toggle):
+            return False
+        return (
+            super().__eq__(other)
+            and self.method_name == other.method_name
+            and self.args == other.args
+            and self.kwargs == other.kwargs
+        )
+
+    __hash__ = None
+
+    def handle(self, component_request: "ComponentRequest", component: UnicornView) -> HandleResult:
+        return CallMethod(self.to_json()).handle(component_request, component)

src/django_unicorn/views/action_dispatcher.py

@@ -0,0 +1,158 @@
+import copy
+import logging
+
+import orjson
+from django.forms import ValidationError
+from django.http import HttpRequest
+
+from django_unicorn.components import UnicornView
+from django_unicorn.components.unicorn_template_response import get_root_element
+from django_unicorn.utils import html_element_to_string
+from django_unicorn.views.request import ComponentRequest
+from django_unicorn.views.response import ComponentResponse
+from django_unicorn.views.utils import set_property_from_data
+
+logger = logging.getLogger(__name__)
+
+
+class ActionDispatcher:
+    def __init__(self, request: HttpRequest, component_request: ComponentRequest):
+        self.request = request
+        self.component_request = component_request
+        self.component = None
+        self.partials = []
+        self.return_data = None
+        self.validate_all_fields = False
+        self.is_refresh_called = False
+        self.is_reset_called = False
+
+    def dispatch(self) -> dict:
+        self._create_component()
+        self._hydrate()
+        self._execute_actions()
+        self._process_safe_fields()
+        self._validate()
+        rendered_component = self._render()
+        return self._create_response(rendered_component)
+
+    def _create_component(self):
+        self.component = UnicornView.create(
+            component_id=self.component_request.id,
+            component_name=self.component_request.name,
+            request=self.request,
+        )
+
+        # Ensure request is attached to the component and its parent
+        if self.component.request is None:
+            self.component.request = self.request
+        if self.component.parent is not None and self.component.parent.request is None:
+            self.component.parent.request = self.request
+
+    def _hydrate(self):
+        if self.component_request.data is None:
+            raise AssertionError("Component request data is required")
+
+        self.original_data = copy.deepcopy(self.component_request.data)
+
+        self.component.pre_parse()
+
+        for property_name, property_value in self.component_request.data.items():
+            set_property_from_data(self.component, property_name, property_value, ignore_m2m=True)
+
+        self.component.post_parse()
+        self.component.hydrate()
+
+    def _execute_actions(self):
+        for action in self.component_request.action_queue:
+            if action.partials:
+                self.partials.extend(action.partials)
+
+            try:
+                result = action.handle(self.component_request, self.component)
+
+                # Update state from result
+                if result.component:
+                    self.component = result.component
+
+                self.is_refresh_called = self.is_refresh_called | result.is_refresh_called
+                self.is_reset_called = self.is_reset_called | result.is_reset_called
+                self.validate_all_fields = self.validate_all_fields | result.validate_all_fields
+                if result.return_data:
+                    self.return_data = result.return_data
+            except ValidationError as e:
+                self.component._handle_validation_error(e)
+
+        self.component.complete()
+
+    def _process_safe_fields(self):
+        # Reload frontend context variables to capture changes
+        self.component_request.data = orjson.loads(self.component.get_frontend_context_variables())
+        self.component._handle_safe_fields()
+
+    def _validate(self):
+        # Calculate updated data to support partial validation
+        updated_data = self.component_request.data
+        if not self.is_reset_called:
+            if not self.is_refresh_called:
+                updated_data = {}
+                for key, value in self.original_data.items():
+                    if value != self.component_request.data.get(key):
+                        updated_data[key] = self.component_request.data.get(key)
+
+            if self.validate_all_fields:
+                self.component.validate()
+            else:
+                self.component.validate(model_names=list(updated_data.keys()))
+
+    def _render(self) -> str:
+        if self.return_data and self.return_data.redirect:
+            return ""
+
+        rendered_component = self.component.render(request=self.request)
+        self.component.rendered(rendered_component)
+        return rendered_component
+
+    def _create_response(self, rendered_component: str) -> dict:
+        partial_doms = self._get_partial_doms(rendered_component) if rendered_component else []
+
+        self.component.last_rendered_dom = rendered_component
+
+        response = ComponentResponse(
+            self.component, self.component_request, return_data=self.return_data, partials=partial_doms
+        )
+        return response.get_data()
+
+    def _get_partial_doms(self, rendered_component: str) -> list[dict]:
+        partial_doms = []
+        if self.partials:
+            soup = get_root_element(rendered_component)
+
+            for partial in self.partials:
+                target = partial.get("target") or partial.get("key") or partial.get("id")
+                if not target:
+                    raise AssertionError("Partial target is required")
+
+                found = False
+                if soup.get("unicorn:key") == target:
+                    partial_doms.append({"key": target, "dom": html_element_to_string(soup, with_tail=False)})
+                    found = True
+                    continue
+
+                if soup.get("id") == target:
+                    partial_doms.append({"id": target, "dom": html_element_to_string(soup, with_tail=False)})
+                    found = True
+                    continue
+
+                for element in soup.iter():
+                    if element.get("unicorn:key") == target:
+                        partial_doms.append({"key": target, "dom": html_element_to_string(element, with_tail=False)})
+                        found = True
+                        break
+
+                if not found:
+                    for element in soup.iter():
+                        if element.get("id") == target:
+                            partial_doms.append({"id": target, "dom": html_element_to_string(element, with_tail=False)})
+                            found = True
+                            break
+        return partial_doms