Bloomerp 1.0.0.dev19__tar.gz → 1.0.0.dev20__tar.gz

{bloomerp-1.0.0.dev19 → bloomerp-1.0.0.dev20}/Bloomerp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Bloomerp
-Version: 1.0.0.dev19
+Version: 1.0.0.dev20
 Summary: Bloomerp is an open-source Business Management Software framework that lets you create fully functional business management applications just by defining your Django database models.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{bloomerp-1.0.0.dev19 → bloomerp-1.0.0.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Bloomerp
-Version: 1.0.0.dev19
+Version: 1.0.0.dev20
 Summary: Bloomerp is an open-source Business Management Software framework that lets you create fully functional business management applications just by defining your Django database models.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{bloomerp-1.0.0.dev19 → bloomerp-1.0.0.dev20}/bloomerp/models/definition.py

@@ -159,6 +159,29 @@ class UserAccessRule(BaseModel):
     filters:list[ApiFilterRule] = Field(default_factory=list)
 
 
+class ApiNesting(BaseModel):
+    for_field: str
+    fields: list[str | Literal["__all__"]] = Field(default_factory=lambda: ["__all__"])
+    on_action: list[Literal["list", "read"]] = Field(
+        default_factory=lambda: ["list", "read"]
+    )
+    auto_pk: bool = True
+
+    def get_accessible_fields(self, action: str) -> set[str] | None:
+        normalized_action = str(action or "").strip().lower()
+        if normalized_action not in self.on_action:
+            return set()
+
+        if "__all__" in self.fields:
+            return None
+
+        return {
+            field_name
+            for field_name in self.fields
+            if field_name != "__all__"
+        }
+
+
 class ApiSettings(BaseModel):
     """
     Configures how Bloomerp API's are set up.
@@ -173,6 +196,7 @@ class ApiSettings(BaseModel):
     enable_auto_generation: bool = False
     public_access: list[PublicAccessRule] = Field(default_factory=list)
     user_access:list[UserAccessRule] = Field(default_factory=list)
+    nesting: list[ApiNesting] = Field(default_factory=list)
     public_access_for_authenticated_fallback: bool = True
 
     def get_public_access_rules(self, action: str) -> list[PublicAccessRule]:
@@ -197,6 +221,14 @@ class ApiSettings(BaseModel):
     def has_user_access(self) -> bool:
         return len(self.user_access) > 0
 
+    def get_nesting_rules(self, action: str) -> list[ApiNesting]:
+        normalized_action = str(action or "").strip().lower()
+        return [
+            rule
+            for rule in self.nesting
+            if normalized_action in rule.on_action
+        ]
+
 
 class BloomerpModelConfig(BaseModel):
     """
@@ -247,6 +279,11 @@ class BloomerpModelConfig(BaseModel):
             return False
         return self.api_settings.has_user_access()
 
+    def get_nesting_rules(self, action: str):
+        if self.api_settings is None:
+            return []
+        return self.api_settings.get_nesting_rules(action)
+
     def should_enable_api_auto_generation(self) -> bool:
         bloomerp_config : BloomerpConfig = getattr(settings, "BLOOMERP_CONFIG")
 

{bloomerp-1.0.0.dev19 → bloomerp-1.0.0.dev20}/bloomerp/sdk/base.py

@@ -35,6 +35,8 @@ class SdkModelDefinition:
     class_name: str
     variable_name: str
     endpoint_name: str
+    app_label: str
+    model_name: str
     pk_type: str
     python_pk_type: str
     fields: list[SdkFieldDefinition]
@@ -123,6 +125,8 @@ class BaseSdkGenerator(ABC):
             class_name=model.__name__,
             variable_name=self.to_camel_case(model_name_plural_underline(model)),
             endpoint_name=model_name_plural_underline(model),
+            app_label=model._meta.app_label,
+            model_name=model._meta.model_name,
             pk_type=self.get_ts_type_for_field(model._meta.pk),
             python_pk_type=self.get_python_type_for_field(model._meta.pk),
             fields=self.get_field_definitions(model),
@@ -288,11 +292,29 @@ class BaseSdkGenerator(ABC):
             "readAllowed": bool(config and config.get_public_access_rules("read")),
             "listFields": list_fields,
             "readFields": read_fields,
+            "nesting": self.get_nesting_metadata(config),
             "authenticatedFallbackEnabled": bool(
                 getattr(getattr(config, "api_settings", None), "public_access_for_authenticated_fallback", True)
             ),
         }
 
+    def get_nesting_metadata(self, config: BloomerpModelConfig | None) -> list[dict]:
+        if config is None:
+            return []
+
+        rules = getattr(getattr(config, "api_settings", None), "nesting", [])
+        metadata: list[dict] = []
+        for rule in rules:
+            metadata.append(
+                {
+                    "forField": getattr(rule, "for_field", ""),
+                    "fields": list(getattr(rule, "fields", [])),
+                    "onAction": list(getattr(rule, "on_action", [])),
+                    "autoPk": bool(getattr(rule, "auto_pk", True)),
+                }
+            )
+        return metadata
+
     def get_public_accessible_fields(
         self, config: BloomerpModelConfig | None, action: str
     ) -> list[str] | None:

{bloomerp-1.0.0.dev19 → bloomerp-1.0.0.dev20}/bloomerp/sdk/python.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import json
 
+from django.apps import apps
+
 from bloomerp.sdk.base import BaseSdkGenerator, SdkModelDefinition
 
 
@@ -380,10 +382,7 @@ bloomerp_auth_strategy_types: tuple[str, ...] = tuple({auth_strategy_types})
 """
 
     def render_model_section(self, model_definition: SdkModelDefinition) -> str:
-        model_fields = [
-            f"    {field.name}: {field.python_type}"
-            for field in model_definition.fields
-        ] or ["    pass"]
+        model_fields = self.render_model_fields(model_definition) or ["    pass"]
         create_fields = [
             f"    {field.name}: {field.python_type}"
             for field in model_definition.fields
@@ -414,6 +413,60 @@ bloomerp_auth_strategy_types: tuple[str, ...] = tuple({auth_strategy_types})
         ]
         return "\n".join(lines)
 
+    def render_model_fields(self, model_definition: SdkModelDefinition) -> list[str]:
+        field_types = {
+            field.name: {
+                "type": field.python_type,
+                "optional": False,
+            }
+            for field in model_definition.fields
+        }
+
+        for relation_name, relation_type in self.get_top_level_nested_types(model_definition).items():
+            if relation_name in field_types:
+                current_type = field_types[relation_name]["type"]
+                field_types[relation_name]["type"] = f"{current_type} | {relation_type}"
+            else:
+                field_types[relation_name] = {
+                    "type": relation_type,
+                    "optional": True,
+                }
+
+        lines: list[str] = []
+        for field_name in sorted(field_types.keys()):
+            lines.append(f"    {field_name}: {field_types[field_name]['type']}")
+        return lines
+
+    def get_top_level_nested_types(self, model_definition: SdkModelDefinition) -> dict[str, str]:
+        model = apps.get_model(model_definition.app_label, model_definition.model_name)
+        nested_types: dict[str, str] = {}
+
+        for nesting_rule in model_definition.public_access.get("nesting", []):
+            path = str(nesting_rule.get("forField", "") or "").strip()
+            if not path or "." in path:
+                continue
+
+            relation = self.resolve_relation(model, path)
+            if relation is None or relation.related_model is None:
+                continue
+
+            related_type = relation.related_model.__name__
+            if getattr(relation, "many_to_one", False) or getattr(relation, "one_to_one", False):
+                nested_types[path] = related_type
+            else:
+                nested_types[path] = f"list[{related_type}]"
+
+        return nested_types
+
+    def resolve_relation(self, model, relation_name: str):
+        for field in model._meta.get_fields():
+            accessor_name = getattr(field, "get_accessor_name", lambda: None)()
+            if field.name == relation_name or accessor_name == relation_name:
+                if not getattr(field, "is_relation", False):
+                    return None
+                return field
+        return None
+
     def render_sdk_class(self, model_definitions: list[SdkModelDefinition]) -> str:
         metadata_lines: list[str] = [
             "        self.metadata = {",

{bloomerp-1.0.0.dev19 → bloomerp-1.0.0.dev20}/bloomerp/sdk/typescript.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import json
 
+from django.apps import apps
+
 from bloomerp.sdk.base import BaseSdkGenerator, SdkModelDefinition
 
 
@@ -142,9 +144,17 @@ export interface BloomerpModelPublicAccessMetadata {{
   readAllowed: boolean;
   listFields: string[] | null;
   readFields: string[] | null;
+  nesting: BloomerpModelNestingMetadata[];
   authenticatedFallbackEnabled: boolean;
 }}
 
+export interface BloomerpModelNestingMetadata {{
+  forField: string;
+  fields: string[];
+  onAction: Array<"list" | "read">;
+  autoPk: boolean;
+}}
+
 export interface BloomerpModelCapabilities {{
   list: boolean;
   retrieve: boolean;
@@ -528,13 +538,11 @@ export const bloomerpAuthStrategyTypes = {auth_strategy_types} as const;
         create_fields = [field for field in model_definition.fields if field.editable and field.name != "id"]
         public_access = json.dumps(model_definition.public_access)
         capabilities = json.dumps(model_definition.capabilities)
+        model_field_lines = self.render_model_fields(model_definition)
 
         model_lines = [
             f"export interface {model_definition.class_name} {{",
-            *[
-                f"  {field.name}: {field.ts_type};"
-                for field in model_definition.fields
-            ],
+            *model_field_lines,
             "}",
             "",
             f"export type {model_definition.class_name}Id = {model_definition.pk_type};",
@@ -576,6 +584,63 @@ export const bloomerpAuthStrategyTypes = {auth_strategy_types} as const;
         ]
         return "\n".join(model_lines)
 
+    def render_model_fields(self, model_definition: SdkModelDefinition) -> list[str]:
+        field_types = {
+            field.name: {
+                "type": field.ts_type,
+                "optional": False,
+            }
+            for field in model_definition.fields
+        }
+
+        for relation_name, relation_type in self.get_top_level_nested_types(model_definition).items():
+            if relation_name in field_types:
+                current_type = field_types[relation_name]["type"]
+                field_types[relation_name]["type"] = f"{current_type} | {relation_type}"
+            else:
+                field_types[relation_name] = {
+                    "type": relation_type,
+                    "optional": True,
+                }
+
+        lines: list[str] = []
+        for field_name in sorted(field_types.keys()):
+            optional_marker = "?" if field_types[field_name]["optional"] else ""
+            lines.append(
+                f"  {field_name}{optional_marker}: {field_types[field_name]['type']};"
+            )
+        return lines
+
+    def get_top_level_nested_types(self, model_definition: SdkModelDefinition) -> dict[str, str]:
+        model = apps.get_model(model_definition.app_label, model_definition.model_name)
+        nested_types: dict[str, str] = {}
+
+        for nesting_rule in model_definition.public_access.get("nesting", []):
+            path = str(nesting_rule.get("forField", "") or "").strip()
+            if not path or "." in path:
+                continue
+
+            relation = self.resolve_relation(model, path)
+            if relation is None or relation.related_model is None:
+                continue
+
+            related_type = relation.related_model.__name__
+            if getattr(relation, "many_to_one", False) or getattr(relation, "one_to_one", False):
+                nested_types[path] = related_type
+            else:
+                nested_types[path] = f"Array<{related_type}>"
+
+        return nested_types
+
+    def resolve_relation(self, model, relation_name: str):
+        for field in model._meta.get_fields():
+            accessor_name = getattr(field, "get_accessor_name", lambda: None)()
+            if field.name == relation_name or accessor_name == relation_name:
+                if not getattr(field, "is_relation", False):
+                    return None
+                return field
+        return None
+
     def render_sdk_class(self, model_definitions: list[SdkModelDefinition]) -> str:
         model_metadata_lines: list[str] = []
         for model_definition in model_definitions: