Bloomerp 1.0.0.dev10__tar.gz → 1.0.0.dev12__tar.gz

{bloomerp-1.0.0.dev10 → bloomerp-1.0.0.dev12}/Bloomerp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Bloomerp
-Version: 1.0.0.dev10
+Version: 1.0.0.dev12
 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.dev10 → bloomerp-1.0.0.dev12}/Bloomerp.egg-info/SOURCES.txt

@@ -80,6 +80,7 @@ bloomerp/forms/model_form.py
 bloomerp/forms/sidebar.py
 bloomerp/forms/widgets.py
 bloomerp/forms/workspaces.py
+bloomerp/management/commands/create_sdk.py
 bloomerp/management/commands/get_urls.py
 bloomerp/management/commands/save_application_fields.py
 bloomerp/management/commands/validate_bloomerp.py
@@ -168,6 +169,10 @@ bloomerp/modules/definition.py
 bloomerp/modules/misc.py
 bloomerp/modules/users.py
 bloomerp/modules/website.py
+bloomerp/sdk/base.py
+bloomerp/sdk/javascript.py
+bloomerp/sdk/python.py
+bloomerp/sdk/typescript.py
 bloomerp/serializers/access_control.py
 bloomerp/services/__init__.py
 bloomerp/services/bulk_services.py

{bloomerp-1.0.0.dev10 → bloomerp-1.0.0.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Bloomerp
-Version: 1.0.0.dev10
+Version: 1.0.0.dev12
 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.dev10 → bloomerp-1.0.0.dev12}/bloomerp/forms/auth.py

@@ -54,8 +54,14 @@ class UserSelectionForm(forms.Form):
 # User Creation Form
 # ---------------------------------
 from django.contrib.auth.forms import UserCreationForm
+
+
+def get_user_creation_fields(user_model:type[AbstractBloomerpUser]) -> tuple[str, ...]:
+    ordered_fields = [user_model.USERNAME_FIELD, *getattr(user_model, "REQUIRED_FIELDS", [])]
+    return tuple(dict.fromkeys(ordered_fields))
+
+
 class BloomerpUserCreationForm(UserCreationForm):
     class Meta(UserCreationForm.Meta):
         model = User
-        fields = UserCreationForm.Meta.fields + ('email',)
-
+        fields = get_user_creation_fields(User)

bloomerp-1.0.0.dev12/bloomerp/management/commands/create_sdk.py

@@ -0,0 +1,116 @@
+from pathlib import Path
+
+from django.core.management.base import BaseCommand, CommandError
+
+from bloomerp.sdk.javascript import JavaScriptSdkGenerator
+from bloomerp.sdk.python import PythonSdkGenerator
+from bloomerp.sdk.typescript import TypescriptSdkGenerator
+
+
+class Command(BaseCommand):
+    help = "Generate a typed SDK for Bloomerp APIs."
+
+    def add_arguments(self, parser):
+        parser.add_argument("path", type=str, help="Target directory for the generated SDK.")
+        parser.add_argument(
+            "--language",
+            type=str,
+            default="typescript",
+            help="SDK language to generate. Supported: typescript, javascript, python.",
+        )
+        parser.add_argument(
+            "--package-name",
+            type=str,
+            default=None,
+            help="Optional package name for the generated SDK.",
+        )
+        parser.add_argument(
+            "--filename",
+            type=str,
+            default=None,
+            help="Optional filename for the generated SDK entry file. Defaults depend on the selected language.",
+        )
+        parser.add_argument(
+            "--add-readme",
+            action="store_true",
+            help="Also generate a README.md file in the target folder.",
+        )
+        parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Overwrite generated files when they already exist.",
+        )
+
+    def handle(self, *args, **options):
+        output_path = Path(options["path"]).expanduser()
+        language = str(options["language"]).strip().lower()
+        package_name = options.get("package_name")
+        raw_filename = options.get("filename")
+        filename = str(raw_filename).strip() if raw_filename is not None else None
+        add_readme = bool(options.get("add_readme"))
+        force = bool(options.get("force"))
+
+        if filename is not None and not filename:
+            raise CommandError("Filename cannot be empty.")
+
+        generator = self.get_generator(
+            language=language,
+            path=str(output_path),
+            package_name=package_name,
+            force=force,
+            filename=filename,
+            add_readme=add_readme,
+        )
+        try:
+            generated_files = generator.generate()
+        except FileExistsError as exc:
+            raise CommandError(str(exc)) from exc
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"Generated {language} SDK in {output_path} ({len(generated_files)} files)."
+            )
+        )
+        for generated_file in generated_files:
+            self.stdout.write(str(generated_file))
+
+    def get_generator(
+        self,
+        *,
+        language: str,
+        path: str,
+        package_name: str | None,
+        force: bool,
+        filename: str,
+        add_readme: bool,
+    ):
+        match language:
+            
+            case "typescript":
+                return TypescriptSdkGenerator(
+                    path=path,
+                    package_name=package_name,
+                    force=force,
+                    filename=filename,
+                    add_readme=add_readme,
+                )
+            case "javascript":
+                return JavaScriptSdkGenerator(
+                    path=path,
+                    package_name=package_name,
+                    force=force,
+                    filename=filename,
+                    add_readme=add_readme,
+                )
+            case "python":
+                return PythonSdkGenerator(
+                    path=path,
+                    package_name=package_name,
+                    force=force,
+                    filename=filename,
+                    add_readme=add_readme,
+                )
+            case _:
+                raise CommandError(
+                    f"Unsupported SDK language '{language}'. Supported languages: typescript, javascript, python."
+                )

bloomerp-1.0.0.dev12/bloomerp/models/definition.py

@@ -0,0 +1,161 @@
+from typing import Literal, Optional
+from bloomerp.config.definition import BloomerpConfig
+from bloomerp.models.base_bloomerp_model import FieldLayout
+from bloomerp.field_types import Lookup
+from pydantic import BaseModel, Field
+from django.conf import settings
+
+class ApiFilterRule(BaseModel):
+    field: str
+    operator: str = Lookup.EQUALS.value.id
+    value: str | int | float | bool | None = None
+
+    def get_lookup_operator(self) -> str:
+        operator_value = str(self.operator or "").strip()
+        for lookup in Lookup:
+            if operator_value == lookup.value.id:
+                return lookup.value.django_representation or operator_value
+        return operator_value
+
+
+class PublicAccessRule(BaseModel):
+    actions: list[Literal["list", "read"]] = Field(
+        default_factory=lambda: ["list", "read"]
+    )
+    fields: list[str] | Literal["__all__"] = "__all__"
+    filters: list[ApiFilterRule] = Field(default_factory=list)
+
+class UserAccessRule(BaseModel):
+    """A user access rule defines in which cases users can access an object via the api. The through field serves as the entry point for the user access definition. Note that user access rules only apply to the auto generated API's.
+
+    For example, we might want to give API access to a `Project` model so that users can create particular and manage particular projects of their own, whilst the integrity of other people's projects stay the same. That would look something like this:
+    ```python
+    rule = UserAccessRule(
+        through_field="owner",
+        field_actions={
+            "name" : ["view", "change", "add"],
+            "type: ["view", "change", "add"],
+            "datetime_created" : ["view"],
+            "datetime_updated" : ["view"],
+        },
+        row_actions=["view", "add", "change", "delete"]
+    )
+    ```
+    In above case, the user is able to create, add, change, delete, and view objects (as defined in the row actions) with the condition that project.owner == user
+
+    In the case that we want to give user access to objects with a deeper link to a user, that would look something like this (assume the model `ProjectTask`). 
+    ```python
+    rule = UserAccessRule(
+        through_field="project.owner",
+        field_actions={
+            "name" : ["view", "change", "add"],
+            "content: ["view", "change", "add"],
+            "datetime_created" : ["view"],
+            "datetime_updated" : ["view"],
+        },
+        row_actions=["view", "add", "change", "delete"]
+    )
+    ```
+    In the below case, the user is only able to create, view, add, and change objects (as defined in the row actions) with the condition of project_task.project.owner == user
+
+    """
+    through_field: str
+    field_actions:dict[str|Literal['__all__'], list[Literal["view", "change", "add", "delete"]] | Literal['__all__']]
+    row_actions:list[Literal["view", "change", "add", "delete"]]
+    filters:list[ApiFilterRule] = Field(default_factory=list)
+
+
+class ApiSettings(BaseModel):
+    """
+    Configures how Bloomerp API's are set up.
+
+    Settings are:
+        - enable_auto_generation: defines whether API endpoints are autogenerated for this model. Defaults to False
+        - public_access: defines read/list exceptions for public API access
+        - user_access: defines exceptions for public API access
+    """
+
+    enable_auto_generation: bool = False
+    public_access: list[PublicAccessRule] = Field(default_factory=list)
+    user_access:list[UserAccessRule] = Field(default_factory=list)
+
+    def get_public_access_rules(self, action: str) -> list[PublicAccessRule]:
+        normalized_action = str(action or "").strip().lower()
+        return [
+            rule
+            for rule in self.public_access
+            if normalized_action in rule.actions
+        ]
+
+    def get_user_access_rules(self, action: str) -> list[UserAccessRule]:
+        normalized_action = str(action or "").strip().lower()
+        return [
+            rule
+            for rule in self.user_access
+            if normalized_action in rule.row_actions
+        ]
+
+    def has_public_access(self) -> bool:
+        return len(self.public_access) > 0
+
+    def has_user_access(self) -> bool:
+        return len(self.user_access) > 0
+
+
+class BloomerpModelConfig(BaseModel):
+    """
+    Used to define certain bloomerp related meta data on a model. 
+
+    Settings are:
+        - modules: a list of modules to which this model belongs.
+        - layout: a layout object defining how the default CRUD layout for users is.
+
+    Usage
+    ```python
+    from bloomerp.models.definition import BloomerpModelConfig
+
+    class Lorum(BloomerpModel):
+        bloomerp_config = BloomerpModelConfig(
+            ...
+        )
+    ``` 
+    """
+
+    modules: Optional[list[str]] = None
+
+    layout: Optional[FieldLayout] = None
+
+    allow_string_search: bool = True
+
+    is_internal: bool = False
+
+    api_settings: Optional[ApiSettings] = None
+
+    def get_public_access_rules(self, action: str) -> list[PublicAccessRule]:
+        if self.api_settings is None:
+            return []
+        return self.api_settings.get_public_access_rules(action)
+
+    def has_public_access(self) -> bool:
+        if self.api_settings is None:
+            return False
+        return self.api_settings.has_public_access()
+
+    def get_user_access_rules(self, action: str) -> list[UserAccessRule]:
+        if self.api_settings is None:
+            return []
+        return self.api_settings.get_user_access_rules(action)
+
+    def has_user_access(self) -> bool:
+        if self.api_settings is None:
+            return False
+        return self.api_settings.has_user_access()
+
+    def should_enable_api_auto_generation(self) -> bool:
+        bloomerp_config : BloomerpConfig = getattr(settings, "BLOOMERP_CONFIG")
+
+        if self.api_settings is None:
+            # In this case, use the global setting to determine whether to auto generate API endpoints
+            return bloomerp_config.auto_generate_api_endpoints
+        
+        return self.api_settings.enable_auto_generation

bloomerp-1.0.0.dev12/bloomerp/sdk/base.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from django.apps import apps
+from django.db import models
+
+from bloomerp.models.application_field import ApplicationField
+from bloomerp.models.definition import BloomerpModelConfig
+from bloomerp.utils.models import model_name_plural_underline
+
+
+@dataclass(frozen=True)
+class SdkFieldDefinition:
+    name: str
+    field_type: str
+    db_field_type: str | None
+    nullable: bool
+    many: bool
+    related_model_name: str | None
+    title: str
+    editable: bool
+    required_on_create: bool
+    ts_type: str
+    js_doc_type: str
+    python_type: str
+
+
+@dataclass(frozen=True)
+class SdkModelDefinition:
+    class_name: str
+    variable_name: str
+    endpoint_name: str
+    pk_type: str
+    python_pk_type: str
+    fields: list[SdkFieldDefinition]
+
+
+class BaseSdkGenerator(ABC):
+    language: str = "base"
+    default_filename: str = "index.txt"
+
+    def __init__(
+        self,
+        path: str,
+        package_name: str | None = None,
+        force: bool = False,
+        filename: str | None = None,
+        add_readme: bool = False,
+    ):
+        self.output_path = Path(path)
+        self.package_name = package_name or self.output_path.name or "bloomerp-sdk"
+        self.force = force
+        self.filename = filename or self.default_filename
+        self.add_readme = add_readme
+
+    def generate(self) -> list[Path]:
+        model_definitions = self.get_model_definitions()
+        files = [self.write_text(self.filename, self.render_source(model_definitions))]
+        if self.add_readme:
+            files.append(self.write_text("README.md", self.render_readme(model_definitions)))
+        return files
+
+    @abstractmethod
+    def render_source(self, model_definitions: list[SdkModelDefinition]) -> str:
+        pass
+
+    @abstractmethod
+    def render_readme(self, model_definitions: list[SdkModelDefinition]) -> str:
+        pass
+
+    def ensure_output_path(self) -> None:
+        self.output_path.mkdir(parents=True, exist_ok=True)
+
+    def write_text(self, relative_path: str, content: str) -> Path:
+        self.ensure_output_path()
+        target = self.output_path / relative_path
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if target.exists() and not self.force:
+            raise FileExistsError(
+                f"{target} already exists. Re-run with force enabled to overwrite generated files."
+            )
+        target.write_text(content, encoding="utf-8")
+        return target
+
+    def get_model_definitions(self) -> list[SdkModelDefinition]:
+        return [self.build_model_definition(model) for model in self.get_api_models()]
+
+    def get_api_models(self) -> list[type[models.Model]]:
+        api_models: list[type[models.Model]] = []
+        for model in apps.get_models():
+            if model._meta.abstract or model._meta.proxy:
+                continue
+
+            config = getattr(model, "bloomerp_config", None)
+            if isinstance(config, BloomerpModelConfig) and not config.should_enable_api_auto_generation():
+                continue
+
+            api_models.append(model)
+
+        api_models.sort(key=lambda model: model.__name__)
+        return api_models
+
+    def build_model_definition(self, model: type[models.Model]) -> SdkModelDefinition:
+        return SdkModelDefinition(
+            class_name=model.__name__,
+            variable_name=self.to_camel_case(model_name_plural_underline(model)),
+            endpoint_name=model_name_plural_underline(model),
+            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),
+        )
+
+    def get_field_definitions(self, model: type[models.Model]) -> list[SdkFieldDefinition]:
+        application_fields = {field.field: field for field in ApplicationField.get_for_model(model)}
+        serializable_fields = list(model._meta.fields) + list(model._meta.many_to_many)
+        field_definitions: list[SdkFieldDefinition] = []
+
+        for model_field in serializable_fields:
+            application_field = application_fields.get(model_field.name)
+            field_definitions.append(
+                SdkFieldDefinition(
+                    name=model_field.name,
+                    field_type=application_field.field_type if application_field else model_field.get_internal_type(),
+                    db_field_type=application_field.db_field_type if application_field else None,
+                    nullable=getattr(model_field, "null", False),
+                    many=bool(getattr(model_field, "many_to_many", False)),
+                    related_model_name=self.get_related_model_name(model_field),
+                    title=application_field.title if application_field else model_field.name.replace("_", " ").title(),
+                    editable=getattr(model_field, "editable", True),
+                    required_on_create=self.is_required_on_create(model_field),
+                    ts_type=self.get_ts_type_for_field(model_field),
+                    js_doc_type=self.get_js_doc_type_for_field(model_field),
+                    python_type=self.get_python_type_for_field(model_field),
+                )
+            )
+
+        field_definitions.sort(key=lambda field: field.name)
+        return field_definitions
+
+    def is_required_on_create(self, field: models.Field) -> bool:
+        if getattr(field, "primary_key", False):
+            return False
+        if not getattr(field, "editable", True):
+            return False
+        if getattr(field, "auto_created", False):
+            return False
+        if getattr(field, "auto_now", False) or getattr(field, "auto_now_add", False):
+            return False
+        if field.has_default():
+            return False
+        if getattr(field, "blank", False):
+            return False
+        if getattr(field, "null", False):
+            return False
+        return True
+
+    def get_related_model_name(self, field: models.Field) -> str | None:
+        related_model = getattr(field, "related_model", None)
+        if related_model is None:
+            return None
+        return related_model.__name__
+
+    def get_ts_type_for_field(self, field: models.Field) -> str:
+        if isinstance(field, (models.ForeignKey, models.OneToOneField)):
+            related_pk_type = self.get_ts_type_for_field(field.related_model._meta.pk)
+            return f"{related_pk_type} | null" if getattr(field, "null", False) else related_pk_type
+        if isinstance(field, models.ManyToManyField):
+            return f"Array<{self.get_ts_type_for_field(field.related_model._meta.pk)}>"
+        if isinstance(field, (models.AutoField, models.BigAutoField, models.SmallAutoField)):
+            return "number"
+        if isinstance(field, models.UUIDField):
+            return "string"
+        if isinstance(field, (models.IntegerField, models.BigIntegerField, models.SmallIntegerField, models.PositiveIntegerField, models.PositiveSmallIntegerField, models.DecimalField, models.FloatField)):
+            return "number"
+        if isinstance(field, models.BooleanField):
+            return "boolean"
+        if isinstance(field, (models.DateField, models.DateTimeField, models.TimeField, models.DurationField)):
+            return "string"
+        if isinstance(field, (models.CharField, models.TextField, models.EmailField, models.SlugField, models.URLField, models.FileField, models.ImageField)):
+            return "string | null" if getattr(field, "null", False) else "string"
+        if isinstance(field, models.JSONField):
+            return "unknown"
+        return "unknown"
+
+    def get_js_doc_type_for_field(self, field: models.Field) -> str:
+        ts_type = self.get_ts_type_for_field(field)
+        return (
+            ts_type.replace("Array<", "Array.<")
+            .replace(" | ", "|")
+            .replace("unknown", "*")
+        )
+
+    def get_python_type_for_field(self, field: models.Field) -> str:
+        if isinstance(field, (models.ForeignKey, models.OneToOneField)):
+            related_pk_type = self.get_python_type_for_field(field.related_model._meta.pk)
+            return f"{related_pk_type} | None" if getattr(field, "null", False) else related_pk_type
+        if isinstance(field, models.ManyToManyField):
+            return f"list[{self.get_python_type_for_field(field.related_model._meta.pk)}]"
+        if isinstance(field, (models.AutoField, models.BigAutoField, models.SmallAutoField, models.IntegerField, models.BigIntegerField, models.SmallIntegerField, models.PositiveIntegerField, models.PositiveSmallIntegerField)):
+            return "int"
+        if isinstance(field, (models.DecimalField, models.FloatField)):
+            return "float"
+        if isinstance(field, models.BooleanField):
+            return "bool"
+        if isinstance(field, models.UUIDField):
+            return "str"
+        if isinstance(field, (models.DateField, models.DateTimeField, models.TimeField, models.DurationField)):
+            return "str"
+        if isinstance(field, (models.CharField, models.TextField, models.EmailField, models.SlugField, models.URLField, models.FileField, models.ImageField)):
+            return "str | None" if getattr(field, "null", False) else "str"
+        if isinstance(field, models.JSONField):
+            return "Any"
+        return "Any"
+
+    def get_example_model(self, model_definitions: list[SdkModelDefinition]) -> SdkModelDefinition | None:
+        if not model_definitions:
+            return None
+        preferred = next((model for model in model_definitions if model.class_name == "Customer"), None)
+        return preferred or model_definitions[0]
+
+    def get_example_field_name(self, model_definition: SdkModelDefinition | None) -> str:
+        if not model_definition or not model_definition.fields:
+            return "title"
+        preferred_field = next(
+            (
+                field
+                for field in model_definition.fields
+                if field.name not in {"id", "created_by", "updated_by", "datetime_created", "datetime_updated"}
+            ),
+            None,
+        )
+        return preferred_field.name if preferred_field else model_definition.fields[0].name
+
+    def get_example_id_value(self, model_definition: SdkModelDefinition | None, *, quoted: bool) -> str:
+        if model_definition and model_definition.pk_type == "string":
+            return '"1"' if quoted else "1"
+        return "1"
+
+    def serialize_field_metadata(self, field: SdkFieldDefinition) -> dict:
+        payload = asdict(field)
+        payload.pop("js_doc_type")
+        payload.pop("python_type")
+        return {
+            "name": payload["name"],
+            "title": payload["title"],
+            "fieldType": payload["field_type"],
+            "dbFieldType": payload["db_field_type"],
+            "nullable": payload["nullable"],
+            "many": payload["many"],
+            "relatedModel": payload["related_model_name"],
+            "editable": payload["editable"],
+            "requiredOnCreate": payload["required_on_create"],
+            "tsType": payload["ts_type"],
+        }
+
+    def to_camel_case(self, value: str) -> str:
+        parts = [part for part in value.replace("-", "_").split("_") if part]
+        if not parts:
+            return value
+        return parts[0] + "".join(part[:1].upper() + part[1:] for part in parts[1:])
+
+    def to_pascal_case(self, value: str) -> str:
+        parts = [part for part in value.replace("-", "_").split("_") if part]
+        if not parts:
+            return value
+        return "".join(part[:1].upper() + part[1:] for part in parts)