django-nativemojo 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

mojo/models/rest.py

@@ -1,12 +1,12 @@
 # from django.http import JsonResponse
 from mojo.helpers.response import JsonResponse
-from mojo.serializers.simple import GraphSerializer
-from mojo.serializers.manager import get_serializer_manager
-from mojo.helpers import modules
+from mojo.serializers import get_serializer_manager
 from mojo.helpers.settings import settings
+from mojo import errors as me
 from django.core.exceptions import ObjectDoesNotExist
 from django.db import transaction, models as dm
 import objict
+import datetime
 from mojo.helpers import dates, logit
 
 
@@ -14,6 +14,17 @@ logger = logit.get_logger("debug", "debug.log")
 ACTIVE_REQUEST = None
 LOGGING_CLASS = None
 MOJO_APP_STATUS_200_ON_ERROR = settings.MOJO_APP_STATUS_200_ON_ERROR
+MOJO_REST_LIST_PERM_DENY = settings.get("MOJO_REST_LIST_PERM_DENY", False)
+
+# use this when there is no ACTIVE_REQUEST
+SYSTEM_REQUEST = objict.objict()
+SYSTEM_REQUEST.user = objict.objict()
+SYSTEM_REQUEST.user.id = 1
+SYSTEM_REQUEST.user.username = "system"
+SYSTEM_REQUEST.user.email = ""
+SYSTEM_REQUEST.user.is_authenticated = True
+SYSTEM_REQUEST.user.has_permission = lambda perm: True
+SYSTEM_REQUEST.DATA = objict.objict()
 
 class MojoModel:
     """Base model class for REST operations with GraphSerializer integration."""
@@ -52,6 +63,17 @@ class MojoModel:
             return default
         return getattr(cls.RestMeta, name, default)
 
+    @classmethod
+    def get_rest_meta_graph(cls, graph_name):
+        graphs = cls.get_rest_meta_prop("GRAPHS", {})
+        if isinstance(graph_name, list):
+            for n in graph_name:
+                res = graphs.get(n, None)
+                if res is not None:
+                    return res
+            return None
+        return graphs.get(graph_name, None)
+
     @classmethod
     def rest_error_response(cls, request, status=500, **kwargs):
         """
@@ -121,6 +143,16 @@ class MojoModel:
         except ObjectDoesNotExist:
             return cls.rest_error_response(None, 404, error=f"{cls.__name__} not found")
 
+    @classmethod
+    def get_instance_from_request(cls, request, field_name=None):
+        if field_name is None:
+            field_name = cls.__name__.lower()
+        if field_name not in request.DATA:
+            field_name = f"{field_name}_id"
+            if field_name not in request.DATA:
+                return None
+        return cls.objects.filter(pk=request.DATA.get(field_name)).last()
+
     @classmethod
     def rest_check_permission(cls, request, permission_keys, instance=None):
         """
@@ -153,6 +185,25 @@ class MojoModel:
                 return False
 
         if instance is not None:
+            is_view = isinstance(permission_keys, list) and "VIEW_PERMS" in permission_keys
+            if not is_view and isinstance(permission_keys, str):
+                is_view = permission_keys == "VIEW_PERMS"
+            if is_view:
+                if hasattr(instance, "check_view_permission"):
+                    allowed = instance.check_view_permission(perms, request)
+                    if not allowed:
+                        cls.class_report_incident(
+                            details="Permission denied: view_permission_denied",
+                            event_type="view_permission_denied",
+                            request=request,
+                            perms=perms,
+                            permission_keys=permission_keys,
+                            branch="instance.check_view_permission",
+                            instance=repr(instance),
+                            request_path=getattr(request, "path", None),
+                        )
+                    return allowed
+
             if hasattr(instance, "check_edit_permission"):
                 allowed = instance.check_edit_permission(perms, request)
                 if not allowed:
@@ -167,12 +218,17 @@ class MojoModel:
                         request_path=getattr(request, "path", None),
                     )
                 return allowed
-            if "owner" in perms and getattr(instance, "user", None) is not None:
-                if instance.user.id == request.user.id:
+
+            if "owner" in perms:
+                owner_field = instance.get_rest_meta_prop("OWNER_FIELD", "user")
+                owner = getattr(instance, owner_field, None)
+                if owner is not None and owner.id == request.user.id:
                     return True
+            if hasattr(instance, "group"):
+                request.group = getattr(instance, "group", None)
 
         if request.group and hasattr(cls, "group"):
-            allowed = request.group.member_has_permission(request.user, perms)
+            allowed = request.group.user_has_permission(request.user, perms)
             if not allowed:
                 cls.class_report_incident(
                     details="Permission denied: group_member_permission_denied",
@@ -181,12 +237,13 @@ class MojoModel:
                     perms=perms,
                     permission_keys=permission_keys,
                     group=getattr(request, "group", None),
-                    branch="group.member_has_permission",
+                    branch="group.user_has_permission",
                     instance=repr(instance) if instance else None,
                     request_path=getattr(request, "path", None),
                 )
             return allowed
-
+        if request.user is None or not request.user.is_authenticated:
+            return False
         allowed = request.user.has_permission(perms)
         if not allowed:
             cls.class_report_incident(
@@ -263,10 +320,41 @@ class MojoModel:
         Returns:
             JsonResponse representing the list of resources.
         """
-        cls.debug("on_rest_handle_list")
+        # cls.debug("on_rest_handle_list")
         if cls.rest_check_permission(request, "VIEW_PERMS"):
             return cls.on_rest_list(request)
-        return cls.rest_error_response(request, 403, error=f"GET permission denied: {cls.__name__}")
+        else:
+            perms = cls.get_rest_meta_prop("VIEW_PERMS", [])
+            if perms and "owner" in perms and request.user.is_authenticated:
+                owner_field = cls.get_rest_meta_prop("OWNER_FIELD", "user")
+                q = {owner_field: request.user}
+                return cls.on_rest_list(request, cls.objects.filter(**q))
+        if MOJO_REST_LIST_PERM_DENY:
+            return cls.rest_error_response(request, 403, error=f"GET permission denied: {cls.__name__}")
+        return cls.on_rest_list_response(request, cls.objects.none())
+
+    def update_from_dict(self, dict_data):
+        request = ACTIVE_REQUEST or SYSTEM_REQUEST
+        return self.on_rest_save(request, dict_data)
+
+    @classmethod
+    def create_from_dict(cls, dict_data, **kwargs):
+        request = kwargs.pop('request', ACTIVE_REQUEST or SYSTEM_REQUEST)
+        instance = cls(**kwargs)
+        instance.on_rest_save(request, dict_data)
+        instance.on_rest_created()
+        if cls.get_rest_meta_prop("LOG_CHANGES", False):
+            instance.log(kind="model:created", log=f"{request.user.username} created {instance.pk}")
+        return instance
+
+    @classmethod
+    def create_from_request(cls, request, **kwargs):
+        instance = cls(**kwargs)
+        instance.on_rest_save(request, request.DATA)
+        instance.on_rest_created()
+        if cls.get_rest_meta_prop("LOG_CHANGES", False):
+            instance.log(kind="model:created", log=f"{ACTIVE_REQUEST.user.username} created {instance.pk}")
+        return instance
 
     @classmethod
     def on_rest_handle_create(cls, request):
@@ -279,10 +367,8 @@ class MojoModel:
         Returns:
             JsonResponse representing the result of the create operation.
         """
-        if cls.rest_check_permission(request, ["SAVE_PERMS", "VIEW_PERMS"]):
-            instance = cls()
-            instance.on_rest_save(request, request.DATA)
-            instance.on_rest_created()
+        if cls.rest_check_permission(request, ["CREATE_PERMS", "SAVE_PERMS", "VIEW_PERMS"]):
+            instance = cls.create_from_request(request)
             return instance.on_rest_get(request)
         return cls.rest_error_response(request, 403, error=f"CREATE permission denied: {cls.__name__}")
 
@@ -314,31 +400,62 @@ class MojoModel:
         Returns:
             JsonResponse representing the paginated and serialized list of objects.
         """
-        cls.debug("on_rest_list:start")
         if queryset is None:
             queryset = cls.objects.all()
-        if request.group is not None and hasattr(cls, "group"):
-            if "group" in request.DATA:
-                del request.DATA["group"]
-            queryset = queryset.filter(group=request.group)
+        # for better query perfomance we want raw request GET data
+        request.QUERY_PARAMS = request.GET.copy()
+        if request.group is not None:
+            GROUP_FIELD = cls.get_rest_meta_prop("GROUP_FIELD", None)
+            if GROUP_FIELD or hasattr(cls, "group"):
+                if "group" in request.QUERY_PARAMS:
+                    del request.QUERY_PARAMS["group"]
+                if GROUP_FIELD:
+                    q = {GROUP_FIELD: request.group}
+                else:
+                    q = {"group": request.group}
+                queryset = queryset.filter(**q)
         queryset = cls.on_rest_list_filter(request, queryset)
         queryset = cls.on_rest_list_date_range_filter(request, queryset)
         queryset = cls.on_rest_list_sort(request, queryset)
-        cls.debug("on_rest_list:end")
         return cls.on_rest_list_response(request, queryset)
 
     @classmethod
     def on_rest_list_response(cls, request, queryset):
         # Implement pagination
-        page_size = request.DATA.get_typed("size", 10, int)
-        page_start = request.DATA.get_typed("start", 0, int)
+        page_size = request.DATA.get_typed(["size", "limit"], 10, int)
+        page_start = request.DATA.get_typed(["start", "offset"], 0, int)
         page_end = page_start+page_size
         paged_queryset = queryset[page_start:page_end]
         graph = request.DATA.get("graph", "list")
+        format = request.DATA.get("download_format", "json")
+        count = queryset.count()
         # Use serializer manager for optimal performance
         manager = get_serializer_manager()
+        if format != "json":
+            format_key = format.split("_")[0]
+            serializer = manager.get_format_serializer(format_key)
+            formats = cls.get_rest_meta_prop("FORMATS")
+            if formats is not None and format in formats:
+                fields = formats[format]
+            else:
+                graph = cls.get_rest_meta_graph(["basic", "default"])
+                if not graph or not graph.get("fields"):
+                    raise me.ValueException("No valid graph found")
+                fields = graph.get("fields")
+            logger.info(f"Serializing queryset with fields: {fields}")
+            return serializer.serialize_queryset(queryset, fields=fields, filename=request.DATA.get("filename", f"{cls.__name__}.csv"))
         serializer = manager.get_serializer(paged_queryset, graph=graph, many=True)
-        return serializer.to_response(request, count=queryset.count(), start=page_start, size=page_size)
+        resp = serializer.to_response(request, count=count, start=page_start, size=page_size)
+        resp.log_context = {
+            "endpoint": "list",
+            "model": cls.__name__,
+            "page_size": page_size,
+            "page_start": page_start,
+            "page_end": page_end,
+            "graph": graph,
+            "count": count
+        }
+        return resp
 
     @classmethod
     def on_rest_list_date_range_filter(cls, request, queryset):
@@ -369,6 +486,22 @@ class MojoModel:
             queryset = queryset.filter(**{f"{dr_field}__lte": dr_end})
         return queryset
 
+    @classmethod
+    def normalize_rest_value(cls, request, field_name, value):
+        field = cls.get_model_field(field_name)
+        if field.get_internal_type() == "BooleanField":
+            if isinstance(value, str):
+                value = value.lower() in ("true", "1")
+            elif isinstance(value, int):
+                value = bool(value)
+            else:
+                value = bool(value)
+        elif value is not None:
+            if field.get_internal_type() in ["DateTimeField", "DateField"]:
+                if not isinstance(value, (datetime.datetime, datetime.date)):
+                    value = dates.parse_datetime(value)
+        return value
+
     @classmethod
     def on_rest_list_filter(cls, request, queryset):
         """
@@ -381,16 +514,22 @@ class MojoModel:
         Returns:
             The filtered queryset.
         """
+        reserved_keys = ["start", "size", "download_format", "dr_start", "dr_end", "limit", "offset"]
         filters = {}
-        for key, value in request.GET.items():
+        for key, value in request.QUERY_PARAMS.items():
             # Split key to check for foreign key relationships
+            if "." in key:
+                key = key.replace(".", "__")
             key_parts = key.split('__')
             field_name = key_parts[0]
+            if field_name in reserved_keys:
+                continue
             if hasattr(cls, field_name):
-                filters[key] = value
+                filters[key] = cls.normalize_rest_value(request, field_name, value)
             elif field_name in cls.__rest_field_names__ and cls._meta.get_field(field_name).is_relation:
+                # TODO Normalize relation field values
                 filters[key] = value
-        # logger.info("filters", filters)
+        logger.info("filters", filters)
         queryset = cls.on_rest_list_search(request, queryset)
         return queryset.filter(**filters)
 
@@ -406,7 +545,7 @@ class MojoModel:
         Returns:
             The filtered queryset based on the search criteria.
         """
-        search_query = request.GET.get('search', None)
+        search_query = request.DATA.get('search', None)
         if not search_query:
             return queryset
 
@@ -500,6 +639,19 @@ class MojoModel:
         # Perform any additional actions after object creation
         pass
 
+    def on_rest_response(self, request, graph="default"):
+        """
+        Handle the response after a REST request.
+
+        Args:
+            request: Django HTTP request object.
+            graph: String representing the graph to use for serialization.
+
+        Returns:
+            JsonResponse representing the object.
+        """
+        return self.on_rest_get(request, graph=graph)
+
     def on_rest_get(self, request, graph="default"):
         """
         Handle the retrieval of a single object.
@@ -510,7 +662,7 @@ class MojoModel:
         Returns:
             JsonResponse representing the object.
         """
-        graph = request.GET.get("graph", graph)
+        graph = request.DATA.get("graph", graph)
         # Use serializer manager for optimal performance
         manager = get_serializer_manager()
         serializer = manager.get_serializer(self, graph=graph)
@@ -525,6 +677,15 @@ class MojoModel:
     def has_field_changed(self, key):
         return key in self.__changed_fields__
 
+    def has_changed(self):
+        return bool(self.__changed_fields__)
+
+    def get_changes(self, data):
+        changes = {}
+        for key, value in self.__changed_fields__.items():
+            changes[key] = f"{value} -> {data.get(key, None)}"
+        return changes
+
     def on_rest_save(self, request, data_dict):
         """
         Create a model instance from a dictionary.
@@ -539,47 +700,78 @@ class MojoModel:
         self.__changed_fields__ = objict.objict()
         # Get fields that should not be saved
         no_save_fields = self.get_rest_meta_prop("NO_SAVE_FIELDS", ["id", "pk", "created", "uuid"])
-
+        post_save_actions = self.get_rest_meta_prop("POST_SAVE_ACTIONS", ['action'])
+        post_save_data = {}
+        action_resp = None  # an action may have a specific response
         # Iterate through data_dict keys instead of model fields
         for key, value in data_dict.items():
             # Skip fields that shouldn't be saved
             if key in no_save_fields:
                 continue
-
-            # First check for custom setter method
-            set_field_method = getattr(self, f'set_{key}', None)
-            if callable(set_field_method):
-                old_value = getattr(self, key, None)
-                set_field_method(value)
-                new_value = getattr(self, key, None)
-                self._set_field_change(key, old_value, new_value)
-                continue
-
-            # Check if this is a model field
-            field = self.get_model_field(key)
-            if field is None:
+            if key in post_save_actions:
+                post_save_data[key] = value
                 continue
-            if field.get_internal_type() == "ForeignKey":
-                self.on_rest_save_related_field(field, value, request)
-            elif field.get_internal_type() == "JSONField":
-                self.on_rest_update_jsonfield(key, value)
-            else:
-                self._set_field_change(key, getattr(self, key), value)
-                setattr(self, key, value)
+            self.on_rest_save_field(key, value, request)
 
         created = self.pk is None
         if created:
-            if request.user.is_authenticated and self.get_model_field("user"):
-                if getattr(self, "user", None) is None:
-                    self.user = request.user
+            owner_field = self.get_rest_meta_prop("CREATED_BY_OWNER_FIELD", "user")
+            if request.user.is_authenticated and self.get_model_field(owner_field):
+                setattr(self, owner_field, request.user)
             if request.group and self.get_model_field("group"):
                 if getattr(self, "group", None) is None:
                     self.group = request.group
+        else:
+            owner_field = self.get_rest_meta_prop("UPDATED_BY_OWNER_FIELD", "modified_by")
+            if request.user.is_authenticated and self.get_model_field(owner_field):
+                setattr(self, owner_field, request.user)
         self.on_rest_pre_save(self.__changed_fields__, created)
         if "files" in data_dict:
             self.on_rest_save_files(data_dict["files"])
         self.atomic_save()
         self.on_rest_saved(self.__changed_fields__, created)
+        for key, value in post_save_data.items():
+            # post save fields can only be called via on_action_
+            handler = getattr(self, f'on_action_{key}', None)
+            if callable(handler):
+                action_resp = handler(value)
+
+        if self.get_rest_meta_prop("LOG_CHANGES", False) and self.has_changed():
+            self.log(kind="model:changed", log=self.get_changes(data_dict))
+        return action_resp
+
+    def on_rest_save_field(self, key, value, request):
+        # First check for custom setter method
+        set_field_method = getattr(self, f'set_{key}', None)
+        if callable(set_field_method):
+            old_value = getattr(self, key, None)
+            set_field_method(value)
+            new_value = getattr(self, key, None)
+            self._set_field_change(key, old_value, new_value)
+            return
+
+        # Check if this is a model field
+        field = self.get_model_field(key)
+        if field is None:
+            return
+        if field.get_internal_type() == "ForeignKey":
+            self.on_rest_save_related_field(field, value, request)
+        elif field.get_internal_type() == "JSONField":
+            self.on_rest_update_jsonfield(key, value)
+        else:
+            if field.get_internal_type() == "BooleanField":
+                if isinstance(value, str):
+                    value = value.lower() in ("true", "1")
+                elif isinstance(value, int):
+                    value = bool(value)
+                else:
+                    value = bool(value)
+            elif value is not None:
+                if field.get_internal_type() in ["DateTimeField", "DateField"]:
+                    if not isinstance(value, (datetime.datetime, datetime.date)):
+                        value = dates.parse_datetime(value)
+            self._set_field_change(key, getattr(self, key), value)
+            setattr(self, key, value)
 
     def on_rest_save_files(self, files):
         for name, file in files.items():
@@ -599,8 +791,10 @@ class MojoModel:
             setattr(self, name, instance)
 
     def on_rest_save_and_respond(self, request):
-        self.on_rest_save(request, request.DATA)
-        return self.on_rest_get(request)
+        resp = self.on_rest_save(request, request.DATA)
+        if resp is None:
+            return self.on_rest_get(request)
+        return JsonResponse(resp)
 
     def on_rest_save_related_field(self, field, field_value, request):
         if isinstance(field_value, dict):
@@ -619,8 +813,10 @@ class MojoModel:
             field.related_model.on_rest_related_save(self, field.name, field_value, related_instance)
         elif isinstance(field_value, int) or (isinstance(field_value, str)):
             # self.debug(f"Related Model: {field.related_model.__name__}, Field Value: {field_value}")
+            field_value = int(field_value)
             if not bool(field_value):
                 # None, "", 0 will set it to None
+                logger.info(f"Setting field {field.name} to None")
                 setattr(self, field.name, None)
                 return
             field_value = int(field_value)
@@ -698,13 +894,27 @@ class MojoModel:
         Instance-level audit/event reporting. Automatically includes model+id.
         """
         context = dict(context)
-        context.setdefault("model_name", self.__class__.__name__)
-        if hasattr(self, 'id'):
+        context.setdefault("model_name", self.__class__.get_model_string())
+        if hasattr(self, 'id') and self.id is not None:
             context.setdefault("model_id", self.id)
         self.__class__.class_report_incident(
             details, event_type=event_type, level=level, request=request, **context
         )
 
+    @classmethod
+    def class_report_incident_for_user(cls, details, event_type="info", level=1, request=None, **context):
+        """
+        Class-level audit/event reporting for a specific user.
+        details: Human description.
+        event_type: Category/kind (e.g. "permission_denied", "security_alert").
+        level: Numeric severity.
+        request: Optional HTTP request or actor.
+        **context: Any additional context.
+        """
+        if ACTIVE_REQUEST and ACTIVE_REQUEST.user.is_authenticated:
+            return request.user.report_incident(details, event_type=event_type, level=level, request=request, **context)
+        return cls.class_report_incident(details, event_type=event_type, level=level, request=request, **context)
+
     @classmethod
     def class_report_incident(cls, details, event_type="info", level=1, request=None, **context):
         """
@@ -737,10 +947,14 @@ class MojoModel:
     def debug(cls, log, *args):
         return logger.info(log, *args)
 
+    @classmethod
+    def get_model_string(cls):
+        return f"{ cls._meta.app_label.lower()}.{cls.__name__}"
+
     @classmethod
     def class_logit(cls, request, log, kind="cls_log", model_id=0, level="info", **kwargs):
         from mojo.apps.logit.models import Log
-        return Log.logit(request, log, kind, cls.__name__, model_id, level, **kwargs)
+        return Log.logit(request, log, kind, cls.get_model_string(), model_id, level, **kwargs)
 
     @classmethod
     def get_model_field(cls, field_name):

mojo/models/secrets.py

@@ -66,3 +66,89 @@ class MojoSecrets(models.Model):
             super().save(*args, **kwargs)
             self.save_secrets()
             super().save()
+
+
+
+class KSMSecrets(models.Model):
+    """Base model class for adding secrets to a model using AWS KMS (envelope encryption)."""
+    class Meta:
+        abstract = True
+
+    mojo_secrets = models.TextField(blank=True, null=True, default=None)
+    _exposed_secrets = None
+    _secrets_changed = False
+    _kms_cache = {}
+
+    def set_secrets(self, value):
+        self.debug("Setting secrets", repr(value))
+        if isinstance(value, str):
+            value = objict.from_json(value)
+        self._exposed_secrets = merge_dicts(self.secrets, value)
+        self._secrets_changed = True
+
+    def set_secret(self, key, value):
+        self.secrets[key] = value
+        self._secrets_changed = True
+
+    def get_secret(self, key, default=None):
+        return self.secrets.get(key, default)
+
+    def clear_secrets(self):
+        self.mojo_secrets = None
+        self._exposed_secrets = objict()
+        self._secrets_changed = True
+
+    @property
+    def secrets(self):
+        if self._exposed_secrets is not None:
+            return self._exposed_secrets
+        if self.mojo_secrets is None or self.pk is None:
+            self._exposed_secrets = objict()
+            return self._exposed_secrets
+        if self._exposed_secrets is None:
+            try:
+                data = self._get_kms().decrypt_dict_field(self._kms_context(), self.mojo_secrets)
+                # convert to objict mapping
+                self._exposed_secrets = objict.from_dict(data)
+            except Exception:
+                # On failure, expose empty to avoid leaking details
+                self._exposed_secrets = objict()
+        return self._exposed_secrets
+
+    def save_secrets(self):
+        if self._secrets_changed:
+            if self._exposed_secrets:
+                # objict behaves like a dict; KMSHelper accepts dict
+                blob = self._get_kms().encrypt_field(self._kms_context(), self._exposed_secrets)
+                self.mojo_secrets = blob
+            else:
+                self.mojo_secrets = None
+            self._secrets_changed = False
+
+    def save(self, *args, **kwargs):
+        if self.pk is not None:
+            self.save_secrets()
+            super().save(*args, **kwargs)
+        else:
+            super().save(*args, **kwargs)
+            self.save_secrets()
+            super().save()
+
+    @classmethod
+    def _get_kms(cls):
+        kms_key_id = settings.get("KMS_KEY_ID", None)
+        region = settings.get("AWS_REGION", settings.get("AWS_DEFAULT_REGION", "us-east-1"))
+        if not kms_key_id:
+            raise RuntimeError("KMS_KEY_ID must be configured to use KSMSecrets")
+        cache_key = (kms_key_id, region)
+        helper = cls._kms_cache.get(cache_key)
+        if helper is None:
+            from mojo.helpers.aws.kms import KMSHelper
+            helper = KMSHelper(kms_key_id=kms_key_id, region_name=region)
+            cls._kms_cache[cache_key] = helper
+        return helper
+
+    def _kms_context(self):
+        # Bind to app_label.Model.<pk>.mojo_secrets for contextual integrity
+        app_label = getattr(self._meta, "app_label", self.__class__.__module__.split(".")[0])
+        return f"{app_label}.{self.__class__.__name__}.{self.pk}.mojo_secrets"

mojo/serializers/__init__.py

@@ -24,16 +24,10 @@ Usage:
 
 # Core serializer classes
 from .simple import GraphSerializer
-from .optimized import OptimizedGraphSerializer
 
-# Advanced serializer (optional - may not be available)
-try:
-    from .advanced import AdvancedGraphSerializer
-except ImportError:
-    AdvancedGraphSerializer = None
-
-# Manager and convenience functions
-from .manager import (
+# New optimized core system (default)
+from .core import (
+    OptimizedGraphSerializer,
     SerializerManager,
     get_serializer_manager,
     register_serializer,
@@ -43,9 +37,17 @@ from .manager import (
     to_response,
     get_performance_stats,
     clear_serializer_caches,
-    benchmark_serializers
+    benchmark_serializers,
+    HAS_UJSON,
+    UJSON_VERSION
 )
 
+# Advanced serializer (optional - may not be available)
+try:
+    from .advanced import AdvancedGraphSerializer
+except ImportError:
+    AdvancedGraphSerializer = None
+
 # Version and metadata
 __version__ = "2.0.0"
 __author__ = "Django-MOJO Team"
@@ -74,6 +76,10 @@ __all__ = [
     'get_performance_stats',
     'clear_serializer_caches',
     'benchmark_serializers',
+
+    # Performance info
+    'HAS_UJSON',
+    'UJSON_VERSION',
 ]
 
 # Initialize default manager on import