statezero 0.1.0b12__tar.gz → 0.1.0b24__tar.gz

{statezero-0.1.0b12 → statezero-0.1.0b24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statezero
-Version: 0.1.0b12
+Version: 0.1.0b24
 Summary: Connect your Python backend to a modern JavaScript SPA frontend with 90% less complexity.
 Author-email: Robert <robert.herring@statezero.dev>
 Project-URL: homepage, https://www.statezero.dev

{statezero-0.1.0b12 → statezero-0.1.0b24}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "statezero"
-version = "0.1.0b12"
+version = "0.1.0b24"
 description = "Connect your Python backend to a modern JavaScript SPA frontend with 90% less complexity."
 readme = "README.md"
 license = { file = "LICENSE" }

{statezero-0.1.0b12 → statezero-0.1.0b24}/statezero/adaptors/django/actions.py

@@ -125,6 +125,14 @@ class DjangoActionSchemaGenerator:
                 return "string"
             return "integer"
 
+        # Handle nested serializers (many=True creates a ListSerializer)
+        if isinstance(field, serializers.ListSerializer):
+            return "array"
+
+        # Handle nested serializers (single nested serializer)
+        if isinstance(field, serializers.Serializer):
+            return "object"
+
         type_mapping = {
             fields.BooleanField: "boolean",
             fields.CharField: "string",

{statezero-0.1.0b12 → statezero-0.1.0b24}/statezero/adaptors/django/extensions/custom_field_serializers/money_field.py

@@ -15,6 +15,14 @@ class MoneyFieldSerializer(serializers.Field):
         self.decimal_places = kwargs.pop("decimal_places", 2)
         super().__init__(**kwargs)
 
+    @classmethod
+    def get_prefetch_db_fields(cls, field_name: str):
+        """
+        Return all database fields required for this field to serialize.
+        MoneyField creates two database columns: field_name and field_name_currency.
+        """
+        return [field_name, f"{field_name}_currency"]
+
     def to_representation(self, value):
         djmoney_field = MoneyField(
             max_digits=self.max_digits, decimal_places=self.decimal_places

statezero-0.1.0b24/statezero/adaptors/django/middleware.py

@@ -0,0 +1,15 @@
+from django.utils.deprecation import MiddlewareMixin
+
+from statezero.core.context_storage import current_operation_id, current_canonical_id
+
+
+class OperationIDMiddleware(MiddlewareMixin):
+    def process_request(self, request):
+        # The header in Django is available via request.META (HTTP headers are prefixed with HTTP_)
+        op_id = request.META.get("HTTP_X_OPERATION_ID")
+        current_operation_id.set(op_id)
+
+        # Also read canonical_id from headers if provided by client
+        canonical_id = request.META.get("HTTP_X_CANONICAL_ID")
+        if canonical_id:
+            current_canonical_id.set(canonical_id)

statezero-0.1.0b24/statezero/adaptors/django/migrations/0001_initial.py

@@ -0,0 +1,63 @@
+# Generated manually for namespace subscription models
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='SocketConnection',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('socket_id', models.CharField(db_index=True, max_length=255, unique=True)),
+                ('connected_at', models.DateTimeField(default=django.utils.timezone.now)),
+                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'db_table': 'statezero_socket_connection',
+            },
+        ),
+        migrations.CreateModel(
+            name='NamespaceSubscription',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('model_name', models.CharField(db_index=True, max_length=255)),
+                ('namespace', models.JSONField()),
+                ('created_at', models.DateTimeField(default=django.utils.timezone.now)),
+                ('connection', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='subscriptions', to='statezero.socketconnection')),
+            ],
+            options={
+                'db_table': 'statezero_namespace_subscription',
+            },
+        ),
+        migrations.AddIndex(
+            model_name='socketconnection',
+            index=models.Index(fields=['socket_id'], name='statezero_s_socket__a1b2c3_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='socketconnection',
+            index=models.Index(fields=['user'], name='statezero_s_user_id_d4e5f6_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='namespacesubscription',
+            index=models.Index(fields=['model_name'], name='statezero_n_model_n_g7h8i9_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='namespacesubscription',
+            index=models.Index(fields=['connection'], name='statezero_n_connect_j1k2l3_idx'),
+        ),
+        migrations.AlterUniqueTogether(
+            name='namespacesubscription',
+            unique_together={('connection', 'model_name', 'namespace')},
+        ),
+    ]

statezero-0.1.0b24/statezero/adaptors/django/namespace_models.py

@@ -0,0 +1,61 @@
+"""
+Django implementation of namespace subscription models.
+"""
+from django.db import models
+from django.contrib.auth import get_user_model
+from django.utils import timezone
+
+
+User = get_user_model()
+
+
+class SocketConnection(models.Model):
+    """
+    Tracks active WebSocket connections.
+
+    Automatically cleaned up on disconnect.
+    """
+    socket_id = models.CharField(max_length=255, unique=True, db_index=True)
+    user = models.ForeignKey(User, on_delete=models.CASCADE, null=True, blank=True)
+    connected_at = models.DateTimeField(default=timezone.now)
+
+    class Meta:
+        app_label = 'statezero'
+        db_table = 'statezero_socket_connection'
+        indexes = [
+            models.Index(fields=['socket_id']),
+            models.Index(fields=['user']),
+        ]
+
+    def __str__(self):
+        user_str = f"user:{self.user.id}" if self.user else "anonymous"
+        return f"SocketConnection({self.socket_id}, {user_str})"
+
+
+class NamespaceSubscription(models.Model):
+    """
+    Tracks which namespaces each socket connection is subscribed to.
+
+    When deleted on disconnect, all subscriptions are automatically removed.
+    """
+    connection = models.ForeignKey(
+        SocketConnection,
+        on_delete=models.CASCADE,
+        related_name='subscriptions'
+    )
+    model_name = models.CharField(max_length=255, db_index=True)
+    namespace = models.JSONField()  # e.g., {'room_id': 5}
+    created_at = models.DateTimeField(default=timezone.now)
+
+    class Meta:
+        app_label = 'statezero'
+        db_table = 'statezero_namespace_subscription'
+        indexes = [
+            models.Index(fields=['model_name']),
+            models.Index(fields=['connection']),
+        ]
+        # Prevent duplicate subscriptions
+        unique_together = [['connection', 'model_name', 'namespace']]
+
+    def __str__(self):
+        return f"Subscription({self.connection.socket_id}, {self.model_name}, {self.namespace})"

statezero-0.1.0b24/statezero/adaptors/django/namespace_views.py

@@ -0,0 +1,360 @@
+"""
+Views for namespace subscription management.
+"""
+import logging
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from statezero.adaptors.django.namespace_models import (
+    SocketConnection,
+    NamespaceSubscription,
+)
+from statezero.adaptors.django.exception_handler import explicit_exception_handler
+from statezero.core.namespace_utils import extract_namespace_from_filter
+
+logger = logging.getLogger(__name__)
+
+
+class NamespaceSubscribeView(APIView):
+    """
+    Allow clients to subscribe to namespaces for selective event notifications.
+    """
+
+    def post(self, request):
+        """
+        Subscribe to a namespace.
+
+        Expected payload:
+        {
+            "socket_id": "socket-123",
+            "model_name": "django_app.Message",
+            "ast": {
+                "query": {
+                    "type": "read",
+                    "filter": {
+                        "type": "filter",
+                        "conditions": {"room_id": 5, "created_at__gte": "2024-01-01"}
+                    }
+                }
+            }
+        }
+
+        Or simplified without AST wrapper:
+        {
+            "socket_id": "socket-123",
+            "model_name": "django_app.Message",
+            "filter": {"room_id": 5, "created_at__gte": "2024-01-01"}
+        }
+        """
+        try:
+            socket_id = request.data.get('socket_id')
+            model_name = request.data.get('model_name')
+            ast = request.data.get('ast')
+            query_filter = request.data.get('filter')
+
+            if not socket_id:
+                return Response(
+                    {"error": "socket_id is required"},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+            if not model_name:
+                return Response(
+                    {"error": "model_name is required"},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+            # Extract filter from AST if provided
+            if ast and not query_filter:
+                query = ast.get('query', {})
+                filter_node = query.get('filter', {})
+                if filter_node and filter_node.get('type') == 'filter':
+                    query_filter = filter_node.get('conditions', {})
+
+            # Extract namespace from filter
+            if not query_filter:
+                return Response(
+                    {"error": "ast or filter is required"},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+            namespace = extract_namespace_from_filter(query_filter)
+
+            # Import namespace hash utility
+            from statezero.core.namespace_utils import get_namespace_hash
+            namespace_hash = get_namespace_hash(namespace)
+
+            # Get or create socket connection
+            connection, created = SocketConnection.objects.get_or_create(
+                socket_id=socket_id,
+                defaults={'user': request.user if request.user.is_authenticated else None}
+            )
+
+            if created:
+                logger.info(f"Created new socket connection: {socket_id}")
+
+            # Create or update subscription
+            subscription, created = NamespaceSubscription.objects.get_or_create(
+                connection=connection,
+                model_name=model_name,
+                namespace=namespace
+            )
+
+            if created:
+                logger.info(
+                    f"Created subscription for {socket_id} to {model_name} namespace {namespace}"
+                )
+
+            return Response({
+                "success": True,
+                "socket_id": socket_id,
+                "model_name": model_name,
+                "namespace": namespace,
+                "namespace_hash": namespace_hash,
+                "channel": f"{model_name}:{namespace_hash}",
+                "created": created
+            }, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            return explicit_exception_handler(e)
+
+
+class NamespaceUnsubscribeView(APIView):
+    """
+    Allow clients to unsubscribe from namespaces.
+    """
+
+    def post(self, request):
+        """
+        Unsubscribe from a namespace.
+
+        Expected payload:
+        {
+            "socket_id": "socket-123",
+            "model_name": "django_app.Message",
+            "ast": {...}  # or "filter": {...}
+        }
+        """
+        try:
+            socket_id = request.data.get('socket_id')
+            model_name = request.data.get('model_name')
+            ast = request.data.get('ast')
+            query_filter = request.data.get('filter')
+
+            if not socket_id or not model_name:
+                return Response(
+                    {"error": "socket_id and model_name are required"},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+            # Extract filter from AST if provided
+            if ast and not query_filter:
+                query = ast.get('query', {})
+                filter_node = query.get('filter', {})
+                if filter_node and filter_node.get('type') == 'filter':
+                    query_filter = filter_node.get('conditions', {})
+
+            # Extract namespace from filter
+            if not query_filter:
+                return Response(
+                    {"error": "ast or filter is required"},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+            namespace = extract_namespace_from_filter(query_filter)
+
+            # Find and delete the subscription
+            deleted_count, _ = NamespaceSubscription.objects.filter(
+                connection__socket_id=socket_id,
+                model_name=model_name,
+                namespace=namespace
+            ).delete()
+
+            if deleted_count > 0:
+                logger.info(
+                    f"Unsubscribed {socket_id} from {model_name} namespace {namespace}"
+                )
+
+            return Response({
+                "success": True,
+                "deleted": deleted_count > 0
+            }, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            return explicit_exception_handler(e)
+
+
+class PusherWebhookView(APIView):
+    """
+    Handle Pusher webhook events for connection lifecycle.
+
+    This is called by Pusher when events occur (client disconnect, etc).
+    Configure in Pusher dashboard: Settings > Webhooks
+    """
+
+    # Pusher webhooks don't need authentication (they use webhook signature)
+    permission_classes = []
+
+    def post(self, request):
+        """
+        Handle Pusher webhook events.
+
+        Pusher sends events like:
+        {
+            "time_ms": 1234567890,
+            "events": [
+                {
+                    "name": "channel_vacated",
+                    "channel": "presence-room-5",
+                    "socket_id": "socket-123.456"
+                }
+            ]
+        }
+        """
+        try:
+            # Validate webhook signature (optional but recommended)
+            if not self._validate_webhook(request):
+                logger.warning("Invalid Pusher webhook signature")
+                return Response(
+                    {"error": "Invalid signature"},
+                    status=status.HTTP_401_UNAUTHORIZED
+                )
+
+            events = request.data.get('events', [])
+
+            for event in events:
+                event_name = event.get('name')
+
+                # Handle different event types
+                if event_name == 'channel_vacated':
+                    # A channel has been vacated (last member left)
+                    self._handle_channel_vacated(event)
+
+                elif event_name == 'member_removed':
+                    # A member left a presence channel
+                    self._handle_member_removed(event)
+
+                elif event_name == 'member_added':
+                    # A member joined a presence channel
+                    self._handle_member_added(event)
+
+            return Response({"success": True}, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            logger.exception(f"Error handling Pusher webhook: {e}")
+            return Response(
+                {"error": str(e)},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _validate_webhook(self, request):
+        """
+        Validate Pusher webhook signature.
+
+        Pusher signs webhooks with your app secret.
+        See: https://pusher.com/docs/channels/server_api/webhooks/#authentication
+        """
+        from django.conf import settings
+        import hmac
+        import hashlib
+
+        # Get Pusher secret from STATEZERO_PUSHER settings
+        pusher_config = getattr(settings, 'STATEZERO_PUSHER', {})
+        webhook_secret = pusher_config.get('SECRET')
+
+        if not webhook_secret:
+            # If no webhook secret configured, skip validation (dev mode)
+            logger.warning("No STATEZERO_PUSHER['SECRET'] configured, skipping webhook validation")
+            return True
+
+        # Get signature from header
+        signature = request.headers.get('X-Pusher-Signature')
+        if not signature:
+            return False
+
+        # Compute expected signature
+        body = request.body.decode('utf-8')
+        expected = hmac.new(
+            webhook_secret.encode('utf-8'),
+            body.encode('utf-8'),
+            hashlib.sha256
+        ).hexdigest()
+
+        return hmac.compare_digest(signature, expected)
+
+    def _handle_channel_vacated(self, event):
+        """Handle channel_vacated event."""
+        channel = event.get('channel')
+        logger.info(f"Channel vacated: {channel}")
+        # Channel is empty, but we track per-socket, not per-channel
+
+    def _handle_member_removed(self, event):
+        """
+        Handle member_removed event.
+
+        This is the key event for cleanup - when a user disconnects.
+        """
+        user_id = event.get('user_id')  # From presence channel
+        socket_id = event.get('socket_id')  # May not be present in all events
+
+        if socket_id:
+            # Clean up by socket_id (most reliable)
+            deleted_count, _ = SocketConnection.objects.filter(
+                socket_id=socket_id
+            ).delete()
+
+            if deleted_count > 0:
+                logger.info(
+                    f"Cleaned up socket {socket_id} on member_removed event "
+                    f"({deleted_count} connections deleted)"
+                )
+
+    def _handle_member_added(self, event):
+        """Handle member_added event."""
+        user_id = event.get('user_id')
+        socket_id = event.get('socket_id')
+        logger.debug(f"Member added: user={user_id}, socket={socket_id}")
+        # We handle connection creation in NamespaceSubscribeView
+
+
+class SocketDisconnectView(APIView):
+    """
+    Manual disconnect endpoint (for testing or explicit cleanup).
+
+    In production, use PusherWebhookView which is called automatically.
+    """
+
+    def post(self, request):
+        """
+        Manually clean up all subscriptions for a socket.
+
+        Expected payload:
+        {
+            "socket_id": "socket-123"
+        }
+        """
+        try:
+            socket_id = request.data.get('socket_id')
+
+            if not socket_id:
+                return Response(
+                    {"error": "socket_id is required"},
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+
+            # Delete the connection (cascades to subscriptions)
+            deleted_count, _ = SocketConnection.objects.filter(
+                socket_id=socket_id
+            ).delete()
+
+            if deleted_count > 0:
+                logger.info(f"Manually cleaned up socket connection: {socket_id}")
+
+            return Response({
+                "success": True,
+                "deleted": deleted_count > 0
+            }, status=status.HTTP_200_OK)
+
+        except Exception as e:
+            return explicit_exception_handler(e)

{statezero-0.1.0b12 → statezero-0.1.0b24}/statezero/adaptors/django/orm.py

@@ -258,6 +258,26 @@ class DjangoORMAdapter(AbstractORMProvider):
             fields_map=fields_map,
         )
 
+    def bulk_create(
+        self,
+        model: Type[models.Model],
+        data_list: List[Dict[str, Any]],
+        serializer,
+        req,
+        fields_map,
+    ) -> List[models.Model]:
+        """Create multiple model instances using Django's bulk_create."""
+        # Create instances without saving to DB yet
+        instances = [model(**data) for data in data_list]
+
+        # Use Django's bulk_create for efficiency
+        created_instances = model.objects.bulk_create(instances)
+
+        # Emit bulk create event for cache invalidation and frontend notification
+        config.event_bus.emit_bulk_event(ActionType.BULK_CREATE, created_instances)
+
+        return created_instances
+
     def update_instance(
         self,
         model: Type[models.Model],
@@ -750,19 +770,15 @@ class DjangoORMAdapter(AbstractORMProvider):
         req: RequestType,
         model: Type,
         initial_ast: Dict[str, Any],
-        custom_querysets: Dict[str, Type[AbstractCustomQueryset]],
         registered_permissions: List[Type[AbstractPermission]],
     ) -> Any:
         """Assemble and return the base QuerySet for the given model."""
-        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.
+        Includes both database fields and additional_fields (computed fields).
         """
         model_config = registry.get_config(model)
         if model_config.fields and "__all__" != model_config.fields:
@@ -775,6 +791,14 @@ class DjangoORMAdapter(AbstractORMProvider):
             resolved_fields = resolved_fields.union(additional_fields)
         return resolved_fields
 
+    def get_db_fields(self, model: models.Model) -> Set[str]:
+        """
+        Return only actual database fields for the model.
+        Excludes read-only additional_fields (computed fields).
+        Used for deserialization - hooks can write to any DB field.
+        """
+        return set(field.name for field in model._meta.get_fields())
+
     def build_model_graph(
         self, model: Type[models.Model], model_graph: nx.DiGraph = None
     ) -> nx.DiGraph:

{statezero-0.1.0b12 → statezero-0.1.0b24}/statezero/adaptors/django/permissions.py

@@ -25,6 +25,7 @@ class AllowAllPermission(AbstractPermission):
             ActionType.DELETE,
             ActionType.READ,
             ActionType.UPDATE,
+            ActionType.BULK_CREATE,
         }
 
     def allowed_object_actions(self, request, obj, model: Type[ORMModel]) -> Set[ActionType]:  # type: ignore
@@ -33,6 +34,7 @@ class AllowAllPermission(AbstractPermission):
             ActionType.DELETE,
             ActionType.READ,
             ActionType.UPDATE,
+            ActionType.BULK_CREATE,
         }
     
     def _get_user_fields(self) -> Set[str]:
@@ -74,6 +76,7 @@ class IsAuthenticatedPermission(AbstractPermission):
             ActionType.DELETE,
             ActionType.READ,
             ActionType.UPDATE,
+            ActionType.BULK_CREATE,
         }
 
     def allowed_object_actions(
@@ -86,6 +89,7 @@ class IsAuthenticatedPermission(AbstractPermission):
             ActionType.DELETE,
             ActionType.READ,
             ActionType.UPDATE,
+            ActionType.BULK_CREATE,
         }
     
     def _get_user_fields(self) -> Set[str]:
@@ -134,6 +138,7 @@ class IsStaffPermission(AbstractPermission):
             ActionType.DELETE,
             ActionType.READ,
             ActionType.UPDATE,
+            ActionType.BULK_CREATE,
         }
 
     def allowed_object_actions(
@@ -146,6 +151,7 @@ class IsStaffPermission(AbstractPermission):
             ActionType.DELETE,
             ActionType.READ,
             ActionType.UPDATE,
+            ActionType.BULK_CREATE,
         }
     
     def _get_user_fields(self) -> Set[str]: