Update plugin-list

Author: fsbraun

djangocms_rest/serializers/plugins.py

@@ -1,7 +1,6 @@
 from typing import Any, Optional
 
 from django.apps import apps
-from django.core.exceptions import FieldDoesNotExist
 from django.db.models import Field, Model
 from django.http import HttpRequest
 from django.urls import NoReverseMatch, reverse
@@ -157,133 +156,164 @@ class PluginDefinitionSerializer(serializers.Serializer):
     type = serializers.CharField(help_text="Schema type")
     properties = serializers.DictField(help_text="Property definitions")
 
+    @staticmethod
+    def get_field_type(field: Field) -> str:
+        """
+        Convert Django field types to JSON Schema types.
+
+        Args:
+            field (Field): Django model field instance
+
+        Returns:
+            str: JSON Schema type corresponding to the Django field type
+        """
+        field_mapping = {
+            "CharField": "string",
+            "TextField": "string",
+            "URLField": "string",
+            "EmailField": "string",
+            "IntegerField": "integer",
+            "FloatField": "number",
+            "DecimalField": "number",
+            "BooleanField": "boolean",
+            "DateField": "string",
+            "DateTimeField": "string",
+            "TimeField": "string",
+            "FileField": "string",
+            "ImageField": "string",
+            "JSONField": "object",
+            "ForeignKey": "integer",
+        }
+        return field_mapping.get(field.__class__.__name__, "string")
+
+    @staticmethod
+    def get_field_format(field: Field) -> Optional[str]:
+        """
+        Get the format for specific field types.
+
+        Args:
+            field (Field): Django model field instance
+
+        Returns:
+            Optional[str]: JSON Schema format string if applicable, None otherwise
+        """
+        format_mapping = {
+            "URLField": "uri",
+            "EmailField": "email",
+            "DateField": "date",
+            "DateTimeField": "date-time",
+            "TimeField": "time",
+            "FileField": "uri",
+            "ImageField": "uri",
+        }
+        return format_mapping.get(field.__class__.__name__)
 
-def get_field_type(field: Field) -> str:
-    """
-    Convert Django field types to JSON Schema types.
+    @staticmethod
+    def generate_plugin_definitions() -> dict[str, Any]:
+        """
+        Generate simple plugin definitions for rendering.
+        """
+        definitions = {}
 
-    Args:
-        field (Field): Django model field instance
+        for plugin in plugin_pool.get_all_plugins():
+            # Use plugin's serializer_class or create a simple fallback
+            serializer_cls = getattr(plugin, "serializer_class", None)
 
-    Returns:
-        str: JSON Schema type corresponding to the Django field type
-    """
-    field_mapping = {
-        "CharField": "string",
-        "TextField": "string",
-        "URLField": "string",
-        "EmailField": "string",
-        "IntegerField": "integer",
-        "FloatField": "number",
-        "DecimalField": "number",
-        "BooleanField": "boolean",
-        "DateField": "string",
-        "DateTimeField": "string",
-        "TimeField": "string",
-        "FileField": "string",
-        "ImageField": "string",
-        "JSONField": "object",
-        "ForeignKey": "integer",
-    }
-    return field_mapping.get(field.__class__.__name__, "string")
-
-
-def get_field_format(field: Field) -> Optional[str]:
-    """
-    Get the format for specific field types.
+            if not serializer_cls:
 
-    Args:
-        field (Field): Django model field instance
+                class DynamicModelSerializer(serializers.ModelSerializer):
+                    class Meta:
+                        model = plugin.model
+                        fields = "__all__"
 
-    Returns:
-        Optional[str]: JSON Schema format string if applicable, None otherwise
-    """
-    format_mapping = {
-        "URLField": "uri",
-        "EmailField": "email",
-        "DateField": "date",
-        "DateTimeField": "date-time",
-        "TimeField": "time",
-        "FileField": "uri",
-        "ImageField": "uri",
-    }
-    return format_mapping.get(field.__class__.__name__)
-
-
-def generate_plugin_definitions() -> dict[str, Any]:
-    """
-    Generate plugin definitions from registered plugins.
-
-    Returns:
-        Dict[str, Any]: A dictionary mapping plugin types to their definitions.
-        Each definition contains:
-            - title: Human readable name
-            - type: Schema type (always "object")
-            - properties: Field definitions following JSON Schema format
-            - required: List of required field names
-    """
-    definitions = {}
-
-    excluded_fields = {
-        "cmsplugin_ptr",
-        "id",
-        "parent",
-        "creation_date",
-        "changed_date",
-        "position",
-        "language",
-        "plugin_type",
-        "placeholder",
-    }
-
-    for plugin in plugin_pool.get_all_plugins():
-        model = plugin.model
-        plugin_class = plugin_pool.get_plugin(plugin.__name__)
-
-        properties = {}
-        required = []
-
-        # Get fields from the model
-        for field in model._meta.get_fields():
-            # Skip excluded and relation fields
-            if field.name in excluded_fields or field.is_relation:
-                continue
+                serializer_cls = DynamicModelSerializer
 
             try:
-                model_field = model._meta.get_field(field.name)
-                field_def = {
-                    "type": get_field_type(model_field),
-                    "description": str(getattr(model_field, "help_text", "") or ""),
-                }
-
-                # Add format if applicable
-                field_format = get_field_format(model_field)
-                if field_format:
-                    field_def["format"] = field_format
-
-                properties[field.name] = field_def
+                serializer_instance = serializer_cls()
+                properties = {}
+
+                for field_name, field in serializer_instance.fields.items():
+                    # Skip internal CMS fields
+                    if field_name in base_exclude:
+                        continue
+
+                    properties[
+                        field_name
+                    ] = PluginDefinitionSerializer.map_field_to_schema(
+                        field, field_name
+                    )
 
-                # Add to required fields if not nullable
-                if not getattr(model_field, "blank", True):
-                    required.append(field.name)
+                definitions[plugin.__name__] = {
+                    "name": getattr(plugin, "name", plugin.__name__),
+                    "title": getattr(plugin, "name", plugin.__name__),
+                    "type": "object",
+                    "properties": properties,
+                }
 
-            except FieldDoesNotExist:
+            except Exception as e:
+                # Skip plugins that fail to process
+                input(e)
                 continue
 
-        # Add plugin_type to properties and required
-        properties["plugin_type"] = {
-            "type": "string",
-            "const": plugin.__name__,
-            "description": "Plugin identifier",
-        }
-        required.append("plugin_type")
-
-        definitions[plugin.__name__] = {
-            "title": getattr(plugin_class, "name", plugin.__name__),
-            "type": "object",
-            "properties": properties,
-            "required": required,
-            "additionalProperties": False,
+        return definitions
+
+    @staticmethod
+    def map_field_to_schema(field: serializers.Field, field_name: str = "") -> dict:
+        """
+        Map DRF field to simple JSON Schema definition for rendering.
+
+        Args:
+            field: DRF serializer field instance
+            field_name: Name of the field (unused but kept for compatibility)
+
+        Returns:
+            dict: Basic JSON Schema definition for the field for TypeScript compatibility
+        """
+
+        # Field type mapping for TypeScript compatibility
+        field_mapping = {
+            "CharField": {"type": "string"},
+            "TextField": {"type": "string"},
+            "URLField": {"type": "string", "format": "uri"},
+            "EmailField": {"type": "string", "format": "email"},
+            "IntegerField": {"type": "integer"},
+            "FloatField": {"type": "number"},
+            "DecimalField": {"type": "number"},
+            "BooleanField": {"type": "boolean"},
+            "DateField": {"type": "string", "format": "date"},
+            "DateTimeField": {"type": "string", "format": "date-time"},
+            "TimeField": {"type": "string", "format": "time"},
+            "FileField": {"type": "string", "format": "uri"},
+            "ImageField": {"type": "string", "format": "uri"},
+            "JSONField": {"type": "object"},
+            "ForeignKey": {"type": "integer"},
+            "PrimaryKeyRelatedField": {"type": "integer"},
+            "ListField": {"type": "array"},
+            "DictField": {"type": "object"},
+            "UUIDField": {"type": "string", "format": "uuid"},
         }
 
-    return definitions
+        # Handle special cases first
+        if isinstance(field, serializers.ChoiceField):
+            schema = {"type": "string", "enum": list(field.choices.keys())}
+        elif hasattr(field, "fields"):  # Nested serializer
+            schema = {"type": "object"}
+            # Extract nested properties
+            properties = {}
+            for nested_field_name, nested_field in field.fields.items():
+                properties[
+                    nested_field_name
+                ] = PluginDefinitionSerializer.map_field_to_schema(
+                    nested_field, nested_field_name
+                )
+            if properties:
+                schema["properties"] = properties
+        else:
+            # Use mapping or default to string
+            schema = field_mapping.get(field.__class__.__name__, {"type": "string"})
+
+        # Description from help_text
+        if getattr(field, "help_text", None):
+            schema["description"] = str(field.help_text)
+
+        return schema

djangocms_rest/views.py

@@ -19,12 +19,10 @@
     PreviewPageContentSerializer,
 )
 from djangocms_rest.serializers.placeholders import PlaceholderSerializer
-from djangocms_rest.serializers.plugins import (
-    PluginDefinitionSerializer,
-    generate_plugin_definitions,
-)
+from djangocms_rest.serializers.plugins import PluginDefinitionSerializer
 from djangocms_rest.utils import get_object, get_site_filtered_queryset
 from djangocms_rest.views_base import BaseAPIView, BaseListAPIView
+from django.utils.functional import lazy
 
 
 try:
@@ -49,7 +47,15 @@ def extend_placeholder_schema(func):
         return func
 
 
-PLUGIN_DEFINITIONS = generate_plugin_definitions()
+# Generate the plugin definitions once at module load time
+# This avoids the need to import the plugin definitions in every view
+# and keeps the code cleaner.
+# Attn: Dynamic changes to the plugin pool will not be reflected in the
+# plugin definitions.
+# If you need to update the plugin definitions, you need reassign the variable.
+PLUGIN_DEFINITIONS = lazy(
+    PluginDefinitionSerializer.generate_plugin_definitions, dict
+)()
 
 
 class LanguageListView(BaseAPIView):

tests/endpoints/test_plugin_list.py

@@ -7,9 +7,22 @@
 
 class PluginListTestCase(BaseCMSRestTestCase):
     def test_get(self):
+        from cms.plugin_pool import plugin_pool
 
         type_checks = PLUGIN_FIELD_TYPES
-
+        expected_plugin_types = [
+            plugin.__name__ for plugin in plugin_pool.get_all_plugins()
+        ]
+        expected_dummy_plugin_signature = {
+            "plugin_type": "DummyNumberPlugin",
+            "title": "Dummy Number Plugin",
+            "type": "object",
+            "properties": {
+                "integer": {"type": "integer"},
+                "json": {"type": "object"},
+                "float": {"type": "number"},
+            },
+        }
         # GET
         response = self.client.get(reverse("plugin-list"))
         self.assertEqual(response.status_code, 200)
@@ -19,6 +32,14 @@ def test_get(self):
         self.assertIsInstance(data, list)
         self.assertTrue(len(data) > 0, "Plugin list should not be empty")
 
+        # Check completeness
+        for plugin_type in expected_plugin_types:
+            self.assertIn(
+                plugin_type,
+                [plugin.get("plugin_type") for plugin in data],
+                f"Plugin type {plugin_type} not found in response",
+            )
+
         # Check Plugin Types
         for plugin in data:
             for field, expected_type in type_checks.items():
@@ -29,3 +50,14 @@ def test_get(self):
                     expected_type,
                     f"plugin {plugin.get('plugin_type', 'unknown')}",
                 )
+
+        # Check signature of DummyNumberPlugin
+        dummy_plugin = next(
+            (
+                plugin
+                for plugin in data
+                if plugin.get("plugin_type") == "DummyNumberPlugin"
+            ),
+            None,
+        )
+        self.assertDictEqual(dummy_plugin, expected_dummy_plugin_signature)

tests/test_app/serializers.py

@@ -2,6 +2,11 @@
 
 
 class CustomSerializer(serializers.Serializer):
+    id = serializers.IntegerField()
+    integer = serializers.IntegerField(default=42)
+    float = serializers.FloatField(default=3.14)
+    json = serializers.JSONField()
+
     def to_representation(self, instance):
         return {
             "id": instance.id,