statezero 0.1.0b5__tar.gz → 0.1.0b20__tar.gz

{statezero-0.1.0b5 → statezero-0.1.0b20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statezero
-Version: 0.1.0b5
+Version: 0.1.0b20
 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
@@ -222,7 +222,7 @@ npm i @statezero/core
 ### Generate TypeScript Models
 
 ```bash
-npx statezero sync-models
+npx statezero sync
 ```
 
 ## Why Choose StateZero Over...
@@ -240,15 +240,3 @@ npx statezero sync-models
 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.0b5 → statezero-0.1.0b20}/README.md

@@ -192,7 +192,7 @@ npm i @statezero/core
 ### Generate TypeScript Models
 
 ```bash
-npx statezero sync-models
+npx statezero sync
 ```
 
 ## Why Choose StateZero Over...
@@ -209,16 +209,4 @@ npx statezero sync-models
 
 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.0b5 → statezero-0.1.0b20}/pyproject.toml

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

statezero-0.1.0b20/statezero/adaptors/django/actions.py

@@ -0,0 +1,248 @@
+import os
+from django.apps import apps
+from rest_framework.response import Response
+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"""
+
+    @staticmethod
+    def generate_actions_schema():
+        """Generate schema for all registered actions matching StateZero model schema format"""
+        actions_schema = {}
+        all_app_configs = list(apps.get_app_configs())
+
+        for action_name, action_config in action_registry.get_actions().items():
+            func = action_config.get("function")
+            if not func:
+                raise ValueError(
+                    f"Action '{action_name}' is missing a function and cannot be processed."
+                )
+
+            func_path = os.path.abspath(func.__code__.co_filename)
+            found_app = None
+
+            for app_config in all_app_configs:
+                app_path = os.path.abspath(app_config.path)
+                if func_path.startswith(app_path + os.sep):
+                    if not found_app or len(app_path) > len(
+                        os.path.abspath(found_app.path)
+                    ):
+                        found_app = app_config
+
+            if not found_app:
+                raise LookupError(
+                    f"Action '{action_name}' from file '{func_path}' does not belong to any "
+                    f"installed Django app. Please ensure the parent app is in INSTALLED_APPS."
+                )
+
+            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"]
+            )
+
+            # Serialize display metadata if present
+            display_data = None
+            if action_config.get("display"):
+                display_data = DjangoActionSchemaGenerator._serialize_display_metadata(
+                    action_config["display"]
+                )
+
+            schema_info = {
+                "action_name": action_name,
+                "app": app_name,
+                "title": action_name.replace("_", " ").title(),
+                "docstring": docstring,
+                "class_name": "".join(
+                    word.capitalize() for word in action_name.split("_")
+                ),
+                "input_properties": input_properties,
+                "response_properties": response_properties,
+                "relationships": {**input_relationships, **response_relationships},
+                "permissions": [
+                    perm.__name__ for perm in action_config.get("permissions", [])
+                ],
+                "display": display_data,
+            }
+            actions_schema[action_name] = schema_info
+
+        return Response({"actions": actions_schema, "count": len(actions_schema)})
+
+    @staticmethod
+    def _get_serializer_schema(serializer_class):
+        if not serializer_class:
+            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")
+                    or field_name.replace("_", " ").title(),
+                    "required": field.required,
+                    "description": getattr(field, "help_text", None),
+                    "nullable": getattr(field, "allow_null", False),
+                    "format": DjangoActionSchemaGenerator._get_field_format(field),
+                    "max_length": getattr(field, "max_length", None),
+                    "choices": DjangoActionSchemaGenerator._get_field_choices(field),
+                    "default": DjangoActionSchemaGenerator._get_field_default(field),
+                    "validators": [],
+                    "max_digits": getattr(field, "max_digits", None),
+                    "decimal_places": getattr(field, "decimal_places", None),
+                    "read_only": field.read_only,
+                    "ref": None,
+                }
+                if hasattr(field, "max_value") and field.max_value is not None:
+                    field_info["max_value"] = field.max_value
+                if hasattr(field, "min_value") and field.min_value is not None:
+                    field_info["min_value"] = field.min_value
+                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, relationships
+        except Exception as 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"
+
+        # 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",
+            fields.EmailField: "string",
+            fields.URLField: "string",
+            fields.UUIDField: "string",
+            fields.IntegerField: "integer",
+            fields.FloatField: "number",
+            fields.DecimalField: "string",
+            fields.DateField: "string",
+            fields.DateTimeField: "string",
+            fields.TimeField: "string",
+            fields.JSONField: "object",
+            fields.DictField: "object",
+            fields.ListField: "array",
+            serializers.ManyRelatedField: "array",
+        }
+        return type_mapping.get(type(field), "string")
+
+    @staticmethod
+    def _get_field_format(field):
+        format_mapping = {
+            fields.EmailField: "email",
+            fields.URLField: "uri",
+            fields.UUIDField: "uuid",
+            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))
+
+    @staticmethod
+    def _get_field_choices(field):
+        if hasattr(field, "choices") and field.choices:
+            choices = field.choices
+            
+            # Handle dict format: {'low': 'Low', 'high': 'High'}
+            if isinstance(choices, dict):
+                return choices
+            
+            # Handle list/tuple format: [('low', 'Low'), ('high', 'High')]
+            elif isinstance(choices, (list, tuple)):
+                try:
+                    # 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 "
+                        f"like [('value', 'display')], but got: {choices}. Error: {e}"
+                    )
+            
+            # Handle unexpected format
+            else:
+                raise ValueError(
+                    f"Unsupported choice format for field '{field}'. Expected dict or list of tuples, "
+                    f"but got {type(choices)}: {choices}"
+                )
+        
+        return None
+
+    @staticmethod
+    def _get_field_default(field):
+        if hasattr(field, "default"):
+            default = field.default
+            if default is fields.empty:
+                return None
+            if callable(default):
+                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
+
+    @staticmethod
+    def _serialize_display_metadata(display):
+        """Convert DisplayMetadata dataclass to dict for JSON serialization"""
+        from dataclasses import asdict, is_dataclass
+
+        if display is None:
+            return None
+
+        if is_dataclass(display):
+            return asdict(display)
+
+        # If it's already a dict, return as-is
+        if isinstance(display, dict):
+            return display
+
+        return None

statezero-0.1.0b20/statezero/adaptors/django/apps.py

@@ -0,0 +1,137 @@
+import importlib
+import logging
+import os
+
+from django.apps import AppConfig as DjangoAppConfig
+from django.apps import apps
+from django.conf import settings
+
+from statezero.adaptors.django.config import config, registry
+
+# Attempt to import Rich for nicer console output.
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+except ImportError:
+    console = None
+
+logger = logging.getLogger(__name__)
+
+
+class StateZeroDjangoConfig(DjangoAppConfig):
+    name = "statezero.adaptors.django"
+    verbose_name = "StateZero Django Integration"
+    label = "statezero"
+
+    def ready(self):
+        # Import crud modules which register models in the registry.
+        if hasattr(settings, "CONFIG_FILE_PREFIX"):
+            config_file_prefix: str = settings.CONFIG_FILE_PREFIX
+            config_file_prefix = config_file_prefix.replace(".py", "")
+            if (not isinstance(config_file_prefix, str)) or (
+                len(config_file_prefix) < 1
+            ):
+                raise ValueError(
+                    f"If provided, CONFIG_FILE_PREFIX must be a string with at least one character. In your settings.py it is set to {settings.CONFIG_FILE_PREFIX}. Either delete the setting completely or use a valid file name like 'crud'"
+                )
+        else:
+            config_file_prefix = "crud"
+        for app_config_instance in apps.get_app_configs():
+            module_name = f"{app_config_instance.name}.{config_file_prefix}"
+            try:
+                importlib.import_module(module_name)
+                logger.debug(
+                    f"Imported {config_file_prefix} module from {app_config_instance.name}"
+                )
+            except ModuleNotFoundError:
+                pass
+
+        # Import actions modules which register actions in the action registry.
+        from statezero.core.actions import action_registry
+
+        for app_config_instance in apps.get_app_configs():
+            actions_module_name = f"{app_config_instance.name}.actions"
+            try:
+                importlib.import_module(actions_module_name)
+                logger.debug(f"Imported actions module from {app_config_instance.name}")
+            except ModuleNotFoundError:
+                pass
+
+        # Once all the apps are imported, initialize StateZero and provide the registry to the event bus.
+        config.initialize()
+        config.validate_exposed_models(
+            registry
+        )  # Raises an exception if a non StateZero model is implicitly exposed
+        config.event_bus.set_registry(registry)
+
+        # Print the list of published models and actions to confirm StateZero is running.
+        try:
+            published_models = []
+            for model in registry._models_config.keys():
+                # Use the ORM provider's get_model_name to get the namespaced model name.
+                model_name = model.__name__
+                published_models.append(model_name)
+
+            # Get registered actions
+            registered_actions = list(action_registry.get_actions().keys())
+
+            # Build base message for models
+            if published_models:
+                models_message = (
+                    "[bold green]StateZero is exposing models:[/bold green] [bold yellow]"
+                    + ", ".join(published_models)
+                    + "[/bold yellow]"
+                )
+            else:
+                models_message = "[bold yellow]StateZero is running but no models are registered.[/bold yellow]"
+
+            # Build message for actions (limit to first 10 to avoid cluttering console)
+            if registered_actions:
+                displayed_actions = registered_actions[:10]
+                actions_message = (
+                    "\n[bold green]StateZero is exposing actions:[/bold green] [bold cyan]"
+                    + ", ".join(displayed_actions)
+                )
+                if len(registered_actions) > 10:
+                    actions_message += (
+                        f" [dim](and {len(registered_actions) - 10} more)[/dim]"
+                    )
+                actions_message += "[/bold cyan]"
+            else:
+                actions_message = (
+                    "\n[bold yellow]No actions are registered.[/bold yellow]"
+                )
+
+            base_message = models_message + actions_message
+
+            # Append the npm command instruction only in debug mode.
+            if (published_models or registered_actions) and settings.DEBUG:
+                npm_message = (
+                    "\n[bold blue]Next step:[/bold blue] Run [italic]npm run sync[/italic] in your frontend project directory "
+                    "to generate or update the client-side code corresponding to these models and actions. "
+                    "Note: This command should only be executed in a development environment."
+                )
+                message = base_message + npm_message
+            else:
+                message = base_message
+
+            # Use Rich Panel for a boxed display if Rich is available.
+            if console:
+                final_message = Panel(message, expand=False)
+                console.print(final_message)
+            else:
+                # Fallback to simple demarcation lines if Rich isn't available.
+                demarcation = "\n" + "-" * 50 + "\n"
+                final_message = demarcation + message + demarcation
+                logger.info(final_message)
+        except Exception as e:
+            error_message = f"[bold red]Error retrieving published models and actions: {e}[/bold red]"
+            if console:
+                final_message = Panel(error_message, expand=False)
+                console.print(final_message)
+            else:
+                demarcation = "\n" + "-" * 50 + "\n"
+                final_message = demarcation + error_message + demarcation
+                logger.info(final_message)

{statezero-0.1.0b5 → statezero-0.1.0b20}/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.0b5 → statezero-0.1.0b20}/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.0b5 → statezero-0.1.0b20}/statezero/adaptors/django/orm.py

@@ -763,6 +763,7 @@ class DjangoORMAdapter(AbstractORMProvider):
     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 +776,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:
@@ -962,4 +971,103 @@ class DjangoORMAdapter(AbstractORMProvider):
 
     def get_user(self, request):
         """Return the user from the request."""
-        return request.user
+        return request.user
+
+    def validate(
+        self,
+        model: Type[models.Model],
+        data: Dict[str, Any],
+        validate_type: str,
+        partial: bool,
+        request: RequestType,
+        permissions: List[Type[AbstractPermission]],
+        serializer,
+    ) -> bool:
+        """
+        Fast validation without database queries.
+        Only checks model-level permissions and serializer validation.
+
+        Args:
+            model: Django model class
+            data: Data to validate
+            validate_type: 'create' or 'update'
+            partial: Whether to allow partial validation (only validate provided fields)
+            request: Request object
+            permissions: Permission classes
+            serializer: Serializer instance
+
+        Returns:
+            bool: True if validation passes
+
+        Raises:
+            ValidationError: For serializer validation failures
+            PermissionDenied: For permission failures
+        """
+        # Basic model-level permission check (no DB query)
+        required_action = (
+            ActionType.CREATE if validate_type == "create" else ActionType.UPDATE
+        )
+
+        has_permission = False
+        for permission_class in permissions:
+            perm_instance = permission_class()
+            allowed_actions = perm_instance.allowed_actions(request, model)
+            if required_action in allowed_actions:
+                has_permission = True
+                break
+
+        if not has_permission:
+            # Let StateZero exception handling deal with this
+            raise PermissionDenied(f"{validate_type.title()} not allowed")
+
+        # Get field permissions
+        allowed_fields = self._get_allowed_fields(
+            model, permissions, request, validate_type
+        )
+
+        # Filter data to only allowed fields
+        filtered_data = {k: v for k, v in data.items() if k in allowed_fields}
+
+        # Create minimal fields map for serializer
+        model_name = config.orm_provider.get_model_name(model)
+        fields_map = {model_name: allowed_fields}
+
+        # Validate using serializer with partial flag - let ValidationError bubble up naturally
+        serializer.deserialize(
+            model=model,
+            data=filtered_data,
+            partial=partial,
+            request=request,
+            fields_map=fields_map,
+        )
+
+        # Only return success case - exceptions handle failures
+        return True
+
+    def _get_allowed_fields(
+        self,
+        model: Type[models.Model],
+        permissions: List[Type[AbstractPermission]],
+        request: RequestType,
+        validate_type: str,
+    ) -> Set[str]:
+        """Helper to get allowed fields based on validate_type."""
+        allowed_fields = set()
+
+        for permission_class in permissions:
+            perm_instance = permission_class()
+
+            if validate_type == "create":
+                create_fields = perm_instance.create_fields(request, model)
+                if create_fields == "__all__":
+                    return config.orm_provider.get_fields(model)
+                elif isinstance(create_fields, set):
+                    allowed_fields.update(create_fields)
+            else:  # update
+                editable_fields = perm_instance.editable_fields(request, model)
+                if editable_fields == "__all__":
+                    return config.orm_provider.get_fields(model)
+                elif isinstance(editable_fields, set):
+                    allowed_fields.update(editable_fields)
+
+        return allowed_fields

{statezero-0.1.0b5 → statezero-0.1.0b20}/statezero/adaptors/django/query_optimizer.py

@@ -477,7 +477,34 @@ def optimize_query(queryset, fields=None, fields_map=None, depth=0, use_only=Tru
             related_fields_to_fetch = set()
 
             if fields_map and related_model_name in fields_map:
-                related_fields_to_fetch.update(fields_map[related_model_name])
+                # Process each field, checking for custom serializers
+                from statezero.adaptors.django.serializers import get_custom_serializer
+                related_meta = _get_model_meta(related_model)
+                for field_name in fields_map[related_model_name]:
+                    try:
+                        field_obj = related_meta.get_field(field_name)
+                        if not field_obj.is_relation:
+                            # Check if this field has a custom serializer with explicit DB field requirements
+                            custom_serializer = get_custom_serializer(field_obj.__class__)
+                            if custom_serializer and hasattr(custom_serializer, 'get_prefetch_db_fields'):
+                                # Use the explicit list from the custom serializer
+                                db_fields = custom_serializer.get_prefetch_db_fields(field_name)
+                                for db_field in db_fields:
+                                    related_fields_to_fetch.add(db_field)
+                                logger.debug(f"Using custom DB fields {db_fields} for field '{field_name}' in {related_model_name}")
+                            else:
+                                # No custom serializer, just add the field itself
+                                related_fields_to_fetch.add(field_name)
+                        else:
+                            # Relation field, add as-is
+                            related_fields_to_fetch.add(field_name)
+                    except FieldDoesNotExist:
+                        # Field doesn't exist, add it anyway (might be computed)
+                        related_fields_to_fetch.add(field_name)
+                    except Exception as e:
+                        logger.error(f"Error checking custom serializer for field '{field_name}' in {related_model_name}: {e}")
+                        # On error, add the field anyway to be safe
+                        related_fields_to_fetch.add(field_name)
             else:
                 # If no field restrictions are provided, get all fields
                 all_fields = [f.name for f in related_model._meta.get_fields() if f.concrete]
@@ -531,7 +558,18 @@ def optimize_query(queryset, fields=None, fields_map=None, depth=0, use_only=Tru
                     try:
                         field_obj = root_meta.get_field(field_name)
                         if not field_obj.is_relation:
-                           root_fields_to_fetch.add(field_name)
+                           # Check if this field has a custom serializer with explicit DB field requirements
+                           from statezero.adaptors.django.serializers import get_custom_serializer
+                           custom_serializer = get_custom_serializer(field_obj.__class__)
+                           if custom_serializer and hasattr(custom_serializer, 'get_prefetch_db_fields'):
+                               # Use the explicit list from the custom serializer
+                               db_fields = custom_serializer.get_prefetch_db_fields(field_name)
+                               for db_field in db_fields:
+                                   root_fields_to_fetch.add(db_field)
+                               logger.debug(f"Using custom DB fields {db_fields} for field '{field_name}'")
+                           else:
+                               # No custom serializer, just add the field itself
+                               root_fields_to_fetch.add(field_name)
                         elif isinstance(field_obj, (ForeignKey, OneToOneField)):
                              # If FK/O2O itself is requested directly, include its id field
                              root_fields_to_fetch.add(field_obj.attname)