django-bulk-hooks 0.1.245__tar.gz → 0.1.247__tar.gz

{django_bulk_hooks-0.1.245 → django_bulk_hooks-0.1.247}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-bulk-hooks
-Version: 0.1.245
+Version: 0.1.247
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 Home-page: https://github.com/AugendLimited/django-bulk-hooks
 License: MIT

{django_bulk_hooks-0.1.245 → django_bulk_hooks-0.1.247}/django_bulk_hooks/queryset.py

@@ -172,21 +172,18 @@ class HookQuerySetMixin:
             logger.debug("update: running hooks with Salesforce-style behavior")
             ctx = HookContext(model_cls, bypass_hooks=False)
 
-            # For Subquery updates, we need to run hooks AFTER the database update and refresh
-            # For non-Subquery updates, we can run hooks before the database update as usual
+            # Run validation hooks first
+            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
+
+            # For Subquery updates, skip BEFORE_UPDATE hooks here - they'll run after refresh
             if not has_subquery:
-                # Run validation hooks first
-                engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
-                # Then run BEFORE_UPDATE hooks
+                # Then run BEFORE_UPDATE hooks for non-Subquery updates
                 engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
 
             # Persist any additional field mutations made by BEFORE_UPDATE hooks.
             # Build CASE statements per modified field not already present in kwargs.
-            modified_fields = (
-                self._detect_modified_fields(instances, originals)
-                if not has_subquery
-                else set()
-            )
+            # Note: For Subquery updates, this will be empty since hooks haven't run yet
+            modified_fields = self._detect_modified_fields(instances, originals)
             extra_fields = [f for f in modified_fields if f not in kwargs]
             if extra_fields:
                 case_statements = {}
@@ -384,7 +381,7 @@ class HookQuerySetMixin:
             raise
 
         # If we used Subquery objects, refresh the instances to get computed values
-        # and then run hooks so HasChanged conditions work correctly
+        # and run BEFORE_UPDATE hooks so HasChanged conditions work correctly
         if has_subquery and instances and not current_bypass_hooks:
             logger.debug(
                 "Refreshing instances with Subquery computed values before running hooks"
@@ -395,26 +392,47 @@ class HookQuerySetMixin:
                 obj.pk: obj for obj in model_cls._base_manager.filter(pk__in=pks)
             }
 
-            # Bulk update all instances in memory
+            # Bulk update all instances in memory and save pre-hook state
+            pre_hook_state = {}
             for instance in instances:
                 if instance.pk in refreshed_instances:
                     refreshed_instance = refreshed_instances[instance.pk]
-                    # Update all fields except primary key
+                    # Save current state before modifying for hook comparison
+                    pre_hook_values = {}
                     for field in model_cls._meta.fields:
                         if field.name != "id":
+                            pre_hook_values[field.name] = getattr(refreshed_instance, field.name)
                             setattr(
                                 instance,
                                 field.name,
                                 getattr(refreshed_instance, field.name),
                             )
+                    pre_hook_state[instance.pk] = pre_hook_values
 
-            # Now run the hooks with the refreshed instances containing computed values
-            logger.debug("Running hooks after Subquery refresh")
-            # Run validation hooks first
-            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
-            # Then run BEFORE_UPDATE hooks
+            # Now run BEFORE_UPDATE hooks with refreshed instances so conditions work
+            logger.debug("Running BEFORE_UPDATE hooks after Subquery refresh")
             engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
 
+            # Check if hooks modified any fields and persist them with bulk_update
+            hook_modified_fields = set()
+            for instance in instances:
+                if instance.pk in pre_hook_state:
+                    pre_hook_values = pre_hook_state[instance.pk]
+                    for field_name, pre_hook_value in pre_hook_values.items():
+                        current_value = getattr(instance, field_name)
+                        if current_value != pre_hook_value:
+                            hook_modified_fields.add(field_name)
+            
+            hook_modified_fields = list(hook_modified_fields)
+            if hook_modified_fields:
+                logger.debug(
+                    f"Running bulk_update for hook-modified fields: {hook_modified_fields}"
+                )
+                # Use bulk_update to persist hook modifications, bypassing hooks to avoid recursion
+                model_cls.objects.bulk_update(
+                    instances, hook_modified_fields, bypass_hooks=True
+                )
+
         # Salesforce-style: Always run AFTER_UPDATE hooks unless explicitly bypassed
         if not current_bypass_hooks:
             logger.debug("update: running AFTER_UPDATE")

{django_bulk_hooks-0.1.245 → django_bulk_hooks-0.1.247}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.1.245"
+version = "0.1.247"
 description = "Hook-style hooks for Django bulk operations like bulk_create and bulk_update."
 authors = ["Konrad Beck <konrad.beck@merchantcapital.co.za>"]
 readme = "README.md"