drf-react-by-schema 0.26.0__tar.gz → 0.26.2__tar.gz

{drf_react_by_schema-0.26.0 → drf_react_by_schema-0.26.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: drf_react_by_schema
-Version: 0.26.0
+Version: 0.26.2
 Summary: A Django app to easily integrate with React from models.
 Home-page: https://gitlab.com/eita/drf-react-by-schema/drf-react-by-schema-django
 Author: Cooperativa EITA

drf_react_by_schema-0.26.2/drf_react_by_schema/management/commands/sync_react.py

@@ -0,0 +1,318 @@
+import os
+import json
+import shutil
+import importlib
+import traceback
+from django.conf import settings
+from django.core.management.base import BaseCommand
+from django.core.serializers.json import DjangoJSONEncoder
+from django.utils.encoding import force_str
+from django.apps import apps
+from rest_framework.test import APIRequestFactory
+from rest_framework.request import Request
+
+from drf_react_by_schema import settings as package_settings
+from drf_react_by_schema.metadata import Metadata
+from drf_react_by_schema.typescript_generator import TypeScriptGenerator
+from drf_react_by_schema import viewsets as drf_viewsets
+
+
+class Command(BaseCommand):
+    help = "Syncs Django models to React schemas and types"
+
+    def handle(self, *args, **kwargs):
+        drf_settings = getattr(settings, "DRF_REACT_BY_SCHEMA", {})
+        base_dir = os.path.join(
+            settings.BASE_DIR,
+            drf_settings.get(
+                "REACT_APP_DIR",
+                "frontend",
+            ),
+        )
+
+        output_dir = os.path.join(base_dir, "src/drfReactBySchema")
+        schema_path = os.path.join(output_dir, "schemas")
+
+        if os.path.exists(output_dir):
+            self.stdout.write(f"Cleaning output directory: {output_dir}")
+            shutil.rmtree(output_dir)
+
+        os.makedirs(schema_path, exist_ok=True)
+
+        apps_to_sync = drf_settings.get("APPS", [])
+
+        self.stdout.write(f"Syncing apps: {apps_to_sync}")
+
+        index_exports = ["import { SchemaLoader } from 'drf-react-by-schema';"]
+
+        factory = APIRequestFactory()
+        wsgi_request = factory.options("/")
+        request = Request(wsgi_request)
+
+        modules_to_sync = []
+        for app_label in apps_to_sync:
+            modules_to_sync.append(f"{app_label}.viewsets")
+        modules_to_sync.append("drf_react_by_schema.viewsets")
+
+        processed_models = set()
+        global_ts_gen = TypeScriptGenerator()
+        all_interfaces = []
+
+        for module_str in modules_to_sync:
+            try:
+                module = importlib.import_module(module_str)
+                module_name = module_str.split(".")[0]
+                self.stdout.write(f"Processing module: {module_name}...")
+                for viewset_name, viewset in module.__dict__.items():
+                    if isinstance(viewset, type) and viewset_name not in [
+                        "DRFReactBySchemaBaseModelViewSet",
+                        "GenericRelatedModelViewSet",
+                        "GenericAutocompleteViewSet",
+                        "GenericViewSet",
+                        "LoggingMixin",
+                        "generated_nested_class",
+                        "generated_class",
+                    ]:
+                        for parent in viewset.mro():
+                            if "ViewSet" in parent.__name__:
+                                # Subclass to override properties that might be read-only on the base
+                                class MockViewSet(viewset):
+                                    @property
+                                    def allowed_methods(self):
+                                        return [
+                                            "GET",
+                                            "POST",
+                                            "PUT",
+                                            "PATCH",
+                                            "DELETE",
+                                            "OPTIONS",
+                                        ]
+
+                                    def get_object(self):
+                                        # Avoid DB hit for metadata generation
+                                        if hasattr(self, "model") and self.model:
+                                            return self.model()
+                                        return None
+
+                                view_instance = MockViewSet()
+                                view_instance.request = request
+                                view_instance.format_kwarg = None
+                                view_instance.kwargs = {"pk": 1}
+                                view_instance.action = "create"  # Ensure get_serializer implementation has a context
+
+                                # Mock permissions
+                                view_instance.check_permissions = lambda req: None
+                                view_instance.check_object_permissions = (
+                                    lambda req, obj: None
+                                )
+
+                                # Check if it is a valid viewset to process
+                                if (
+                                    not getattr(view_instance, "model", None)
+                                    and not getattr(view_instance, "queryset", None)
+                                    and viewset_name != "EndpointsViewSet"
+                                ):
+                                    continue
+
+                                model_name = viewset_name.removesuffix("ViewSet")
+                                if model_name in processed_models:
+                                    continue
+                                processed_models.add(model_name)
+
+                                # A. Generate Schema
+                                meta_tool = Metadata()
+                                raw_metadata = meta_tool.determine_metadata(
+                                    request, view_instance
+                                )
+
+                                simplified_schema = {
+                                    "schema": raw_metadata.get("actions", {}).get(
+                                        "POST", {}
+                                    ),
+                                    "verbose_name": raw_metadata.get(
+                                        "verbose_name", ""
+                                    ),
+                                    "verbose_name_plural": raw_metadata.get(
+                                        "verbose_name_plural", ""
+                                    ),
+                                }
+
+                                # We want to export it as json
+                                schema_var_name = f"{model_name}Schema"
+                                json_filename = f"{schema_var_name}.json"
+                                with open(
+                                    os.path.join(schema_path, json_filename), "w"
+                                ) as f:
+                                    json.dump(
+                                        simplified_schema,
+                                        f,
+                                        cls=DjangoJSONEncoder,
+                                        indent=2,
+                                    )
+
+                                index_exports.append(
+                                    f"export const {schema_var_name} = (() => import('./schemas/{json_filename}')) as SchemaLoader;"
+                                )
+
+                                # B. Generate TypeScript
+                                interface_code = global_ts_gen.generate_interface(
+                                    model_name, view_instance
+                                )
+                                if interface_code:
+                                    all_interfaces.append(interface_code)
+                                break
+            except ImportError:
+                pass
+            except Exception as e:
+                print(f"--- Error loading module: {module_str} ---")
+                traceback.print_exc()
+
+        # Generate Imports for Types
+        imports = [
+            "import { ChoiceItem } from 'drf-react-by-schema';",
+            "import dayjs from 'dayjs';",
+        ]
+
+        # Shared definitions
+        shared_defs = []
+
+        # Combine Type content
+        # Enums first
+        enums_content = list(global_ts_gen.enums.values())
+
+        types_content = ImportsAndContent(
+            imports, shared_defs + enums_content + all_interfaces
+        )
+
+        # Write Files
+        self.write_file(output_dir, "types.ts", types_content)
+
+        # Generate OptionsGetters
+        # Imports from types
+        enum_names = list(global_ts_gen.enums.keys())
+        getter_imports = []
+        if enum_names:
+            getter_imports.append(
+                f"import {{ {', '.join(sorted(enum_names))} }} from './types';"
+            )
+
+        getter_funcs = []
+        for enum_name, labels_map in global_ts_gen.enum_labels.items():
+            func_name = f"get{enum_name}Label"
+            lines = [
+                f"export function {func_name}(value: {enum_name} | null | undefined): string {{"
+            ]
+            lines.append("  if (value === null || value === undefined) return '';")
+            lines.append("  switch (value) {")
+
+            for val, label in labels_map.items():
+                # Value must match the enum definition in types.ts
+                # We used the same logic for keys in typescript_generator, but here we just need raw value for case
+                if isinstance(val, (int, float)):
+                    case_val = f"{val}"
+                else:
+                    # Escape quotes if string
+                    safe_val = str(val).replace("'", "\\'")
+                    case_val = f"'{safe_val}'"
+
+                # Escape label
+                safe_label = str(label).replace("'", "\\'").replace("\n", " ")
+                lines.append(f"    case {case_val}: return '{safe_label}';")
+
+            lines.append("    default: return '';")
+            lines.append("  }")
+            lines.append("}")
+            getter_funcs.append("\n".join(lines))
+
+            # Export to index
+            # NO: these functions breach the SchemaType which are in the json files.
+            # index_exports.append(f"export * from './optionsGetters';")
+
+        getter_content_list = ImportsAndContent(getter_imports, getter_funcs)
+        self.write_file(output_dir, "optionsGetters.ts", getter_content_list)
+
+        # Write Index
+        # Dedup index exports
+        index_exports = list(dict.fromkeys(index_exports))
+        self.write_file(output_dir, "index.ts", index_exports)
+
+        self.stdout.write(
+            self.style.SUCCESS("Successfully synchronized schemas and types!")
+        )
+
+    def write_file(self, path, filename, content_list, custom_header=""):
+        full_path = os.path.join(path, filename)
+        if isinstance(content_list, ImportsAndContent):
+            content_str = content_list.to_string()
+        else:
+            content_str = "\n\n".join(content_list)
+
+        with open(full_path, "w") as f:
+            f.write("/* eslint-disable */\n")
+            f.write("// @generated by drf-react-by-schema\n\n")
+            if custom_header:
+                f.write(custom_header + "\n\n")
+            f.write(content_str)
+            f.write("\n")
+
+    def to_ts_literal(self, data, level=0):
+        # Kept for backward compatibility if other parts need it,
+        # but mostly unused for schema generation now
+        indent = "  " * level
+
+        if isinstance(data, dict):
+            if not data:
+                return "{}"
+            lines = []
+            for key, value in data.items():
+                key = force_str(key)
+                if not key.isidentifier():
+                    key = f"'{key}'"
+                val_str = self.to_ts_literal(value, level + 1)
+                lines.append(f"{indent}  {key}: {val_str},")
+            return f"{{\n" + "\n".join(lines) + f"\n{indent}}}"
+
+        elif isinstance(data, (list, tuple)):
+            if not data:
+                return "[]"
+            # Multiline if any item is a dict or list or tuple
+            is_complex = any(isinstance(x, (dict, list, tuple)) for x in data)
+            items = [self.to_ts_literal(x, level + 1) for x in data]
+            if is_complex:
+                content = "\n".join([f"{indent}  {x}," for x in items])
+                return f"[\n{content}\n{indent}]"
+            return f"[{', '.join(items)}]"
+
+        elif isinstance(data, bool):
+            return "true" if data else "false"
+
+        elif data is None:
+            return "null"
+
+        elif isinstance(data, (int, float)):
+            return str(data)
+
+        # Fallback for strings and anything else (including lazy objects)
+        val_str = force_str(data)
+
+        # If string contains single quote but NO double quote -> Use Double Quotes
+        # This makes strings like "('a', 'b')" cleaner: "('a', 'b')" instead of '(\'a\', \'b\')'
+        if "'" in val_str and '"' not in val_str:
+            safe_str = val_str.replace("\\", "\\\\").replace("\n", "\\n")
+            return f'"{safe_str}"'
+
+        # Default: Use Single Quotes
+        # Note: We must escape backslashes first, otherwise we might double-escape the ones added for quotes/newlines
+        safe_str = (
+            val_str.replace("\\", "\\\\").replace("\n", "\\n").replace("'", "\\'")
+        )
+        return f"'{safe_str}'"
+
+
+class ImportsAndContent:
+    def __init__(self, imports, content):
+        self.imports = imports
+        self.content = content
+
+    def to_string(self):
+        return "\n".join(self.imports) + "\n\n" + "\n\n".join(self.content)

{drf_react_by_schema-0.26.0 → drf_react_by_schema-0.26.2}/drf_react_by_schema/metadata.py

@@ -112,10 +112,15 @@ class Metadata(SimpleMetadata):
             elif getattr(field, "auto_now_add", False) or getattr(
                 field, "auto_now", None
             ):
+                # metadata["actions"]["POST"][field_name]["model_default"] = (
+                #     date.today()
+                #     if isinstance(field, models.DateField)
+                #     else datetime.now()
+                # )
                 metadata["actions"]["POST"][field_name]["model_default"] = (
-                    date.today()
+                    "{dateNow}"
                     if isinstance(field, models.DateField)
-                    else datetime.now()
+                    else "{dateTimeNow}"
                 )
             elif serializer_field and serializer_field.default:
                 if isinstance(serializer_field.default, (int, str)):
@@ -125,7 +130,7 @@ class Metadata(SimpleMetadata):
                 elif isinstance(serializer_field.default, CurrentUserDefault):
                     metadata["actions"]["POST"][field_name][
                         "model_default"
-                    ] = "currentUser"
+                    ] = "{currentUser}"
 
             # Custom regex Validators:
             validators = getattr(field, "validators", [])

{drf_react_by_schema-0.26.0 → drf_react_by_schema-0.26.2}/drf_react_by_schema/serializers.py

@@ -80,11 +80,13 @@ class GenericSerializerMetaclass(SerializerMetaclass):
                     # Help text and label
                     help_text = getattr(field, "help_text", "")
                     verbose_name = getattr(field, "verbose_name", "")
-                    if getattr(field.related_model._meta, "verbose_name", None):
+                    if not verbose_name and getattr(
+                        field.related_model._meta, "verbose_name", None
+                    ):
                         verbose_name = getattr(
                             field.related_model._meta, "verbose_name", None
                         )
-                    elif verbose_name == "":
+                    elif not verbose_name:
                         verbose_name = field.related_model.__name__
 
                     # Reverse relations don't use null/blank the same way

{drf_react_by_schema-0.26.0 → drf_react_by_schema-0.26.2}/drf_react_by_schema.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: drf-react-by-schema
-Version: 0.26.0
+Version: 0.26.2
 Summary: A Django app to easily integrate with React from models.
 Home-page: https://gitlab.com/eita/drf-react-by-schema/drf-react-by-schema-django
 Author: Cooperativa EITA

{drf_react_by_schema-0.26.0 → drf_react_by_schema-0.26.2}/drf_react_by_schema.egg-info/SOURCES.txt

@@ -35,6 +35,9 @@ drf_react_by_schema/fields/number.py
 drf_react_by_schema/fields/relational.py
 drf_react_by_schema/fields/serializers.py
 drf_react_by_schema/fields/text.py
+drf_react_by_schema/management/__init__.py
+drf_react_by_schema/management/commands/__init__.py
+drf_react_by_schema/management/commands/sync_react.py
 drf_react_by_schema/migrations/__init__.py
 drf_react_by_schema/patches/__init__.py
 drf_react_by_schema/patches/drf_serializers.py

{drf_react_by_schema-0.26.0 → drf_react_by_schema-0.26.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = drf_react_by_schema
-version = 0.26.0
+version = 0.26.2
 description = A Django app to easily integrate with React from models.
 long_description = file: README.rst
 url = https://gitlab.com/eita/drf-react-by-schema/drf-react-by-schema-django