statezero 0.1.0b9__tar.gz → 0.1.0b11__tar.gz

{statezero-0.1.0b9 → statezero-0.1.0b11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statezero
-Version: 0.1.0b9
+Version: 0.1.0b11
 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
@@ -240,15 +240,3 @@ npx statezero sync
 Check out the docs at [Statezero Docs](https://statezero.dev)
 
 Run `pip install statezero` and `npm i @statezero/core` to begin.
-
-## Pricing
-
-StateZero uses a no-rugpull license model:
-
-- **$0/month** for companies with revenue up to $3M
-- **$75/month** for companies with revenue up to $7.5M
-- **$200/month** for companies with revenue up to $20M
-- **$500/month** for companies with revenue up to $100M
-- **$1,000/month** for companies with revenue above $100M
-
-Lock in your rate forever by signing up early. We can't change your fee or cancel your license.

{statezero-0.1.0b9 → statezero-0.1.0b11}/README.md

@@ -209,16 +209,4 @@ npx statezero sync
 
 Check out the docs at [Statezero Docs](https://statezero.dev)
 
-Run `pip install statezero` and `npm i @statezero/core` to begin.
-
-## Pricing
-
-StateZero uses a no-rugpull license model:
-
-- **$0/month** for companies with revenue up to $3M
-- **$75/month** for companies with revenue up to $7.5M
-- **$200/month** for companies with revenue up to $20M
-- **$500/month** for companies with revenue up to $100M
-- **$1,000/month** for companies with revenue above $100M
-
-Lock in your rate forever by signing up early. We can't change your fee or cancel your license.
+Run `pip install statezero` and `npm i @statezero/core` to begin.

{statezero-0.1.0b9 → statezero-0.1.0b11}/pyproject.toml

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

{statezero-0.1.0b9 → statezero-0.1.0b11}/statezero/adaptors/django/actions.py

@@ -1,10 +1,10 @@
 import os
 from django.apps import apps
 from rest_framework.response import Response
-from rest_framework import fields
+from rest_framework import fields, serializers
+from django.db import models
 from statezero.core.actions import action_registry
 
-
 class DjangoActionSchemaGenerator:
     """Django-specific action schema generator that matches StateZero model schema format"""
 
@@ -41,6 +41,13 @@ class DjangoActionSchemaGenerator:
             app_name = found_app.label
             docstring = action_config.get("docstring")
 
+            input_properties, input_relationships = DjangoActionSchemaGenerator._get_serializer_schema(
+                action_config["serializer"]
+            )
+            response_properties, response_relationships = DjangoActionSchemaGenerator._get_serializer_schema(
+                action_config["response_serializer"]
+            )
+
             schema_info = {
                 "action_name": action_name,
                 "app": app_name,
@@ -49,12 +56,9 @@ class DjangoActionSchemaGenerator:
                 "class_name": "".join(
                     word.capitalize() for word in action_name.split("_")
                 ),
-                "input_properties": DjangoActionSchemaGenerator._get_serializer_schema(
-                    action_config["serializer"]
-                ),
-                "response_properties": DjangoActionSchemaGenerator._get_serializer_schema(
-                    action_config["response_serializer"]
-                ),
+                "input_properties": input_properties,
+                "response_properties": response_properties,
+                "relationships": {**input_relationships, **response_relationships},
                 "permissions": [
                     perm.__name__ for perm in action_config.get("permissions", [])
                 ],
@@ -66,11 +70,16 @@ class DjangoActionSchemaGenerator:
     @staticmethod
     def _get_serializer_schema(serializer_class):
         if not serializer_class:
-            return {}
+            return {}, {}
         try:
             serializer_instance = serializer_class()
             properties = {}
+            relationships = {}
             for field_name, field in serializer_instance.fields.items():
+                relation_info = DjangoActionSchemaGenerator._get_relation_info(field)
+                if relation_info:
+                    relationships[field_name] = relation_info
+                
                 field_info = {
                     "type": DjangoActionSchemaGenerator._get_field_type(field),
                     "title": getattr(field, "label")
@@ -95,12 +104,19 @@ class DjangoActionSchemaGenerator:
                 if hasattr(field, "min_length") and field.min_length is not None:
                     field_info["min_length"] = field.min_length
                 properties[field_name] = field_info
-            return properties
+            return properties, relationships
         except Exception as e:
-            return {"error": f"Could not inspect serializer: {str(e)}"}
+            print(f"Could not inspect serializer: {str(e)}")
+            raise e
 
     @staticmethod
     def _get_field_type(field):
+        if isinstance(field, serializers.PrimaryKeyRelatedField):
+            pk_field = field.queryset.model._meta.pk
+            if isinstance(pk_field, (models.UUIDField, models.CharField)):
+                return "string"
+            return "integer"
+
         type_mapping = {
             fields.BooleanField: "boolean",
             fields.CharField: "string",
@@ -116,6 +132,7 @@ class DjangoActionSchemaGenerator:
             fields.JSONField: "object",
             fields.DictField: "object",
             fields.ListField: "array",
+            serializers.ManyRelatedField: "array",
         }
         return type_mapping.get(type(field), "string")
 
@@ -128,6 +145,8 @@ class DjangoActionSchemaGenerator:
             fields.DateField: "date",
             fields.DateTimeField: "date-time",
             fields.TimeField: "time",
+            serializers.ManyRelatedField: "many-to-many",
+            serializers.PrimaryKeyRelatedField: "foreign-key",
         }
         return format_mapping.get(type(field))
 
@@ -138,12 +157,13 @@ class DjangoActionSchemaGenerator:
             
             # Handle dict format: {'low': 'Low', 'high': 'High'}
             if isinstance(choices, dict):
-                return list(choices.keys())
+                return choices
             
             # Handle list/tuple format: [('low', 'Low'), ('high', 'High')]
             elif isinstance(choices, (list, tuple)):
                 try:
-                    return [choice[0] for choice in choices]
+                    # Return dict with value->label mapping (same as model)
+                    return {str(choice[0]): choice[1] for choice in choices}
                 except (IndexError, TypeError) as e:
                     raise ValueError(
                         f"Invalid choice format for field '{field}'. Expected list of tuples "
@@ -169,3 +189,27 @@ class DjangoActionSchemaGenerator:
                 return None
             return default
         return None
+    
+    @staticmethod
+    def _get_relation_info(field):
+        relation_type = DjangoActionSchemaGenerator._get_field_format(field)
+        if not relation_type in ["foreign-key", "one-to-one", "many-to-many"]:
+            return None
+
+        if isinstance(field, serializers.PrimaryKeyRelatedField):
+            model = field.queryset.model
+            return {
+                "type": relation_type,
+                "model": f"{model._meta.app_label}.{model._meta.model_name}",
+                "class_name": model.__name__,
+                "primary_key_field": model._meta.pk.name,
+            }
+        if isinstance(field, serializers.ManyRelatedField):
+            model = field.child_relation.queryset.model
+            return {
+                "type": relation_type,
+                "model": f"{model._meta.app_label}.{model._meta.model_name}",
+                "class_name": model.__name__,
+                "primary_key_field": model._meta.pk.name,
+            }
+        return None

{statezero-0.1.0b9 → statezero-0.1.0b11}/statezero/adaptors/django/exception_handler.py

@@ -62,7 +62,7 @@ def map_exception(exc):
 def explicit_exception_handler(exc):
     """
     Extended explicit exception handler that builds a structured JSON response.
-    It maps known Django/DRF exceptions to your library's standard errors and
+    It maps known Django/DRF exceptions to StateZero's standard errors and
     uses jsonable_encoder to ensure the output is JSON serializable.
     """
     traceback.print_exc()

{statezero-0.1.0b9 → statezero-0.1.0b11}/statezero/core/ast_parser.py

@@ -416,7 +416,7 @@ class ASTParser:
         return handler(ast)
 
     def _apply_related(self, ast: Dict[str, Any]) -> None:
-        """UPDATED: Apply select_related and prefetch_related, updating current queryset."""
+        """ Apply select_related and prefetch_related, updating current queryset."""
         if "selectRelated" in ast and isinstance(ast["selectRelated"], list):
             self.current_queryset = self.engine.select_related(
                 self.current_queryset, ast["selectRelated"]
@@ -427,28 +427,28 @@ class ASTParser:
             )
 
     def _apply_filter(self, ast: Dict[str, Any]) -> None:
-        """UPDATED: Apply filter from AST to the queryset, updating current queryset."""
+        """ Apply filter from AST to the queryset, updating current queryset."""
         if "filter" in ast and ast["filter"]:
             self.current_queryset = self.engine.filter_node(
                 self.current_queryset, ast["filter"]
             )
 
     def _apply_exclude(self, ast: Dict[str, Any]) -> None:
-        """UPDATED: Apply exclude from AST to the queryset, updating current queryset."""
+        """ Apply exclude from AST to the queryset, updating current queryset."""
         if "exclude" in ast and ast["exclude"]:
             self.current_queryset = self.engine.exclude_node(
                 self.current_queryset, ast["exclude"]
             )
 
     def _apply_ordering(self, ast: Dict[str, Any]) -> None:
-        """UPDATED: Apply ordering, updating current queryset."""
+        """ Apply ordering, updating current queryset."""
         if "orderBy" in ast:
             self.current_queryset = self.engine.order_by(
                 self.current_queryset, ast["orderBy"]
             )
 
     def _apply_field_selection(self, ast: Dict[str, Any]) -> None:
-        """UPDATED: Apply field selection, updating current queryset."""
+        """ Apply field selection, updating current queryset."""
         if "fields" in ast and isinstance(ast["fields"], list):
             self.current_queryset = self.engine.select_fields(
                 self.current_queryset, ast["fields"]
@@ -456,7 +456,7 @@ class ASTParser:
 
     def _apply_search(self, ast: Dict[str, Any]) -> None:
         """
-        UPDATED: If search properties are present at the top level of the AST,
+        If search properties are present at the top level of the AST,
         apply the search using the adapter's search_node() method.
 
         Expects the AST to have a top-level "search" key containing:
@@ -489,7 +489,7 @@ class ASTParser:
         else:
             final_search_fields = config_search_fields
 
-        # UPDATED: Delegate to the ORM adapter's search_node() method with queryset.
+        # Delegate to the ORM adapter's search_node() method with queryset.
         self.current_queryset = self.engine.search_node(
             self.current_queryset, search_query, final_search_fields
         )
@@ -497,7 +497,7 @@ class ASTParser:
     # --- Operation Handlers with Hard-Coded Response Types ---
 
     def _handle_create(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass model explicitly to create method."""
+        """ Pass model explicitly to create method."""
         data = ast.get("data", {})
         validated_data = self.serializer.deserialize(
             model=self.model,
@@ -526,7 +526,7 @@ class ASTParser:
         }
 
     def _handle_update(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to update method."""
+        """ Pass current queryset to update method."""
         data = ast.get("data", {})
         validated_data = self.serializer.deserialize(
             model=self.model,
@@ -543,7 +543,7 @@ class ASTParser:
         # Get the readable fields for this model using our existing method
         readable_fields = self._get_operation_fields(self.model, "read")
 
-        # UPDATED: Update records and get the count and affected instance IDs
+        # Update records and get the count and affected instance IDs
         updated_count, updated_instances = self.engine.update(
             self.current_queryset,  # Pass current queryset
             ast,
@@ -570,7 +570,7 @@ class ASTParser:
         }
 
     def _handle_delete(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to delete method."""
+        """ Pass current queryset to delete method."""
         permissions = self.registry.get_config(self.model).permissions
         deleted_count, rows_deleted = self.engine.delete(
             self.current_queryset, ast, self.request, permissions
@@ -586,7 +586,7 @@ class ASTParser:
         }
 
     def _handle_update_instance(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass model explicitly to update_instance method."""
+        """ Pass model explicitly to update_instance method."""
         # Extract and deserialize the data.
         raw_data = ast.get("data", {})
         # Allow partial updates.
@@ -603,7 +603,7 @@ class ASTParser:
         # Retrieve permissions from the self.registry.
         permissions = self.registry.get_config(self.model).permissions
 
-        # UPDATED: Delegate to the engine's instance-based update method.
+        # Delegate to the engine's instance-based update method.
         updated_instance = self.engine.update_instance(
             self.model,
             ast,
@@ -628,7 +628,7 @@ class ASTParser:
 
     def _handle_delete_instance(self, ast: Dict[str, Any]) -> Dict[str, Any]:
         """
-        UPDATED: Handles deletion of a single instance.
+        Handles deletion of a single instance.
         Typically, no additional data deserialization is needed beyond the filter,
         so we simply verify that a filter is provided and then delegate to the engine.
         """
@@ -643,7 +643,7 @@ class ASTParser:
         # Retrieve permissions from the self.registry.
         permissions = self.registry.get_config(self.model).permissions
 
-        # UPDATED: Delegate to the engine's instance-based delete method.
+        # Delegate to the engine's instance-based delete method.
         deleted_count = self.engine.delete_instance(
             self.model, ast, self.request, permissions
         )
@@ -654,7 +654,7 @@ class ASTParser:
         }
 
     def _handle_get(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to get method."""
+        """ Pass current queryset to get method."""
         # Retrieve permissions from the registry
         permissions = self.registry.get_config(self.model).permissions
         record = self.engine.get(self.current_queryset, ast, self.request, permissions)
@@ -671,7 +671,7 @@ class ASTParser:
         }
 
     def _handle_get_or_create(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to get_or_create method."""
+        """ Pass current queryset to get_or_create method."""
         # Validate and split lookup/defaults (without extra wrapping)
         validated_lookup, validated_defaults = self._validate_and_split_lookup_defaults(
             ast, partial=True
@@ -684,7 +684,7 @@ class ASTParser:
         # Retrieve permissions from configuration
         permissions = self.registry.get_config(self.model).permissions
 
-        # UPDATED: Call the ORM layer and pass the serializer and request/permissions
+        # Call the ORM layer and pass the serializer and request/permissions
         record, created = self.engine.get_or_create(
             self.current_queryset,  # Pass current queryset
             {"lookup": ast.get("lookup", {}), "defaults": ast.get("defaults", {})},
@@ -710,7 +710,7 @@ class ASTParser:
         }
 
     def _handle_update_or_create(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to update_or_create method."""
+        """ Pass current queryset to update_or_create method."""
         # Validate and split lookup/defaults.
         validated_lookup, validated_defaults = self._validate_and_split_lookup_defaults(
             ast, partial=True
@@ -723,7 +723,7 @@ class ASTParser:
         # Retrieve permissions from configuration.
         permissions = self.registry.get_config(self.model).permissions
 
-        # UPDATED: Call the ORM update_or_create method, passing the serializer, request, and permissions.
+        # Call the ORM update_or_create method, passing the serializer, request, and permissions.
         record, created = self.engine.update_or_create(
             self.current_queryset,  # Pass current queryset
             {"lookup": ast.get("lookup", {}), "defaults": ast.get("defaults", {})},
@@ -750,7 +750,7 @@ class ASTParser:
         }
 
     def _handle_first(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to first method."""
+        """ Pass current queryset to first method."""
         record = self.engine.first(self.current_queryset)
         serialized = self.serializer.serialize(
             record,
@@ -765,7 +765,7 @@ class ASTParser:
         }
 
     def _handle_last(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to last method."""
+        """ Pass current queryset to last method."""
         record = self.engine.last(self.current_queryset)
         serialized = self.serializer.serialize(
             record,
@@ -780,7 +780,7 @@ class ASTParser:
         }
 
     def _handle_exists(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to exists method."""
+        """ Pass current queryset to exists method."""
         exists_flag = self.engine.exists(self.current_queryset)
         return {
             "data": exists_flag,
@@ -791,7 +791,7 @@ class ASTParser:
         }
 
     def _handle_aggregate(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to all aggregate methods."""
+        """ Pass current queryset to all aggregate methods."""
         op_type = ast.get("type")
         if op_type == "aggregate":
             aggs = ast.get("aggregates", {})
@@ -859,7 +859,7 @@ class ASTParser:
                 }
 
     def _handle_read(self, ast: Dict[str, Any]) -> Dict[str, Any]:
-        """UPDATED: Pass current queryset to fetch_list method."""
+        """ Pass current queryset to fetch_list method."""
         offset_raw = self.serializer_options.get("offset", 0)
         limit_raw = self.serializer_options.get("limit", self.config.default_limit)
         offset_val = int(offset_raw) if offset_raw is not None else None
@@ -868,7 +868,7 @@ class ASTParser:
         # Retrieve permissions from configuration
         permissions = self.registry.get_config(self.model).permissions
 
-        # UPDATED: Fetch list with bulk permission checks
+        # Fetch list with bulk permission checks
         rows = self.engine.fetch_list(
             self.current_queryset,  # Pass current queryset
             offset=offset_val,

{statezero-0.1.0b9 → statezero-0.1.0b11}/statezero/core/interfaces.py

@@ -30,12 +30,9 @@ class AbstractORMProvider(ABC):
     A merged ORM engine interface that combines both query building (filtering,
     ordering, aggregation, etc.) and ORM provider responsibilities (queryset assembly,
     event signal registration, model graph construction, etc.).
-
-    UPDATED: All query manipulation methods now take queryset parameters and return
-    new querysets instead of mutating internal state.
     """
 
-    # === Query Engine Methods (UPDATED: Now stateless) ===
+    # === Query Engine Methods ===
 
     @abstractmethod
     def validate(
@@ -145,7 +142,7 @@ class AbstractORMProvider(ABC):
         """
         pass
 
-    # === Aggregate Methods (UPDATED: Take queryset parameter) ===
+    # === Aggregate Methods ===
 
     @abstractmethod
     def aggregate(
@@ -201,7 +198,7 @@ class AbstractORMProvider(ABC):
         """Return True if the queryset has any results; otherwise False."""
         pass
 
-    # === CRUD Methods (UPDATED: Take model or queryset parameters explicitly) ===
+    # === CRUD Methods ===
 
     @abstractmethod
     def create(

statezero-0.1.0b11/statezero/core/types.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from enum import Enum, auto
+from typing import (Any, Callable, Dict, List, Optional, Set, Type, TypeVar,
+                    Union)
+
+# Django imports
+from django.db.models import Field as DjangoField
+from django.db.models import Model as DjangoModel
+from django.db.models.query import QuerySet as DjangoQuerySet
+from rest_framework.request import Request as DRFRequest
+
+# Type definitions, when we add FastAPI support, we wil turn these into unions
+ORMField = DjangoField
+ORMModel = DjangoModel
+ORMQuerySet = DjangoQuerySet
+RequestType = DRFRequest
+
+class ActionType(Enum):
+    CREATE = "create"
+    READ = "read"
+    UPDATE = "update"
+    DELETE = "delete"
+    BULK_UPDATE = "bulk_update"
+    BULK_DELETE = "bulk_delete"
+    # new pre-operation types
+    PRE_UPDATE = "pre_update"
+    PRE_DELETE = "pre_delete"

{statezero-0.1.0b9 → statezero-0.1.0b11}/statezero.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statezero
-Version: 0.1.0b9
+Version: 0.1.0b11
 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
@@ -240,15 +240,3 @@ npx statezero sync
 Check out the docs at [Statezero Docs](https://statezero.dev)
 
 Run `pip install statezero` and `npm i @statezero/core` to begin.
-
-## Pricing
-
-StateZero uses a no-rugpull license model:
-
-- **$0/month** for companies with revenue up to $3M
-- **$75/month** for companies with revenue up to $7.5M
-- **$200/month** for companies with revenue up to $20M
-- **$500/month** for companies with revenue up to $100M
-- **$1,000/month** for companies with revenue above $100M
-
-Lock in your rate forever by signing up early. We can't change your fee or cancel your license.

statezero-0.1.0b9/statezero/core/types.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from enum import Enum, auto
-from typing import (Any, Callable, Dict, List, Optional, Set, Type, TypeVar,
-                    Union)
-
-# Django imports
-try:
-    from django.db.models import Field as DjangoField
-    from django.db.models import Model as DjangoModel
-    from django.db.models.query import QuerySet as DjangoQuerySet
-    from rest_framework.request import Request as DRFRequest
-except ImportError:
-    DjangoField = None
-    DjangoQuerySet = None
-    DjangoModel = None
-    DRFRequest = object
-
-# SQLAlchemy imports
-try:
-    from sqlalchemy.ext.declarative import \
-        DeclarativeMeta as SQLAlchemyDeclarativeMeta
-    from sqlalchemy.orm.query import Query as SQLAlchemyQuery
-    from sqlalchemy.sql.schema import Column as SQLAlchemyColumn  # type:ignore
-except ImportError:
-    SQLAlchemyColumn = None
-    SQLAlchemyQuery = None
-    SQLAlchemyDeclarativeMeta = None
-
-# FastAPI & Flask imports
-try:
-    from fastapi import Request as FastAPIRequest
-except ImportError:
-    FastAPIRequest = object
-
-try:
-    from flask import Request as FlaskRequest
-except ImportError:
-    FlaskRequest = object
-
-# Type definitions
-# Explicitly list all possible types. Including 'object' as a fallback ensures the type remains valid
-ORMField = Union[object, DjangoField, SQLAlchemyColumn]
-ORMModel = Union[object, DjangoModel, SQLAlchemyDeclarativeMeta]
-ORMQuerySet = Union[Any, DjangoQuerySet, SQLAlchemyQuery]
-RequestType = Union[DRFRequest, FastAPIRequest, FlaskRequest]
-
-class HotPathActionType(Enum):
-    CREATED = "created"
-    COMPLETED = "completed"
-    REJECTED = "rejected"
-
-class ActionType(Enum):
-    CREATE = "create"
-    READ = "read"
-    UPDATE = "update"
-    DELETE = "delete"
-    BULK_UPDATE = "bulk_update"
-    BULK_DELETE = "bulk_delete"
-    # new pre-operation types
-    PRE_UPDATE = "pre_update"
-    PRE_DELETE = "pre_delete"