dotorm 2.0.8__py3-none-any.whl

dotorm/__init__.py

@@ -0,0 +1,87 @@
+"""
+DotORM v2
+"""
+
+# Fields
+from .fields import (
+    Field,
+    Integer,
+    BigInteger,
+    SmallInteger,
+    Char,
+    Selection,
+    Text,
+    Boolean,
+    Decimal,
+    Datetime,
+    Date,
+    Time,
+    Float,
+    JSONField,
+    Binary,
+    Many2one,
+    One2many,
+    Many2many,
+    One2one,
+    AttachmentMany2one,
+    AttachmentOne2many,
+)
+
+# Model
+from .model import DotModel
+from .model import Model, JsonMode
+
+# Components
+from .components import (
+    Dialect,
+    POSTGRES,
+    MYSQL,
+    FilterParser,
+    FilterExpression,
+)
+
+# Exceptions
+from .exceptions import (
+    OrmConfigurationFieldException,
+    OrmUpdateEmptyParamsException,
+)
+
+__version__ = "2.0.8"
+
+__all__ = [
+    # Fields
+    "Field",
+    "Integer",
+    "BigInteger",
+    "SmallInteger",
+    "Char",
+    "Selection",
+    "Text",
+    "Boolean",
+    "Decimal",
+    "Datetime",
+    "Date",
+    "Time",
+    "Float",
+    "JSONField",
+    "Binary",
+    "Many2one",
+    "One2many",
+    "Many2many",
+    "One2one",
+    "AttachmentMany2one",
+    "AttachmentOne2many",
+    # Model
+    "DotModel",
+    "Model",
+    "JsonMode",
+    # Components
+    "Dialect",
+    "POSTGRES",
+    "MYSQL",
+    "FilterParser",
+    "FilterExpression",
+    # Exceptions
+    "OrmConfigurationFieldException",
+    "OrmUpdateEmptyParamsException",
+]

dotorm/access.py

@@ -0,0 +1,151 @@
+"""
+Контекст доступа для DotORM.
+
+Использование:
+
+    # При старте приложения (security/app.py):
+    set_access_checker(SecurityAccessChecker(env))
+
+    # При каждом запросе (verify_access):
+    set_access_session(session)  # Session из security модуля
+
+    # В DotModel автоматически:
+    # - check_table_access() перед CRUD операциями
+    # - check_row_access() для конкретных записей (get/update/delete)
+    # - get_domain_filter() для фильтрации выборки (search)
+"""
+
+from contextvars import ContextVar
+from enum import StrEnum
+from typing import TypeVar, Generic
+
+
+class Operation(StrEnum):
+    """Операции доступа."""
+
+    READ = "read"
+    CREATE = "create"
+    UPDATE = "update"
+    DELETE = "delete"
+
+
+# Generic тип для Session
+TSession = TypeVar("TSession")
+
+
+class AccessChecker(Generic[TSession]):
+    """
+    Базовый класс проверки доступа.
+
+    По умолчанию разрешает всё.
+    Модуль security наследует и переопределяет методы.
+    """
+
+    async def check_access(
+        self,
+        session: TSession,
+        model: str,
+        operation: Operation,
+        record_ids: list[int] | None = None,
+    ) -> tuple[bool, list]:
+        """
+        Единая проверка доступа: ACL + Rules.
+
+        Args:
+            session: Сессия пользователя
+            model: Имя модели (таблицы)
+            operation: Операция (read/create/update/delete)
+            record_ids: ID записей (для проверки Rules)
+
+        Returns:
+            (has_access, domain_filter):
+            - has_access: True если доступ разрешён
+            - domain_filter: фильтр для search (пустой если не нужен)
+        """
+        return True, []
+
+    async def check_table_access(
+        self,
+        session: TSession,
+        model: str,
+        operation: Operation,
+    ) -> bool:
+        """
+        Проверяет доступ к таблице (ACL уровень).
+        """
+        return True
+
+    async def check_row_access(
+        self,
+        session: TSession,
+        model: str,
+        operation: Operation,
+        record_ids: list[int],
+    ) -> bool:
+        """
+        Проверяет доступ к записям (Rules уровень).
+
+        Для одной или нескольких записей проверяет что они
+        попадают под domain из Rules.
+        """
+        return True
+
+    async def get_domain_filter(
+        self,
+        session: TSession,
+        model: str,
+        operation: Operation,
+    ) -> list:
+        """
+        Возвращает domain-фильтр для ограничения выборки.
+
+        Используется для search — добавляется к filter ДО запроса.
+        """
+        return []
+
+
+class AccessDenied(Exception):
+    """Доступ запрещён."""
+
+    def __init__(self, message: str = "Access denied"):
+        self.message = message
+        super().__init__(self.message)
+
+
+# ============================================================
+# State
+# ============================================================
+
+_state: dict = {"checker": AccessChecker()}
+
+_access_session: ContextVar = ContextVar("access_session", default=None)
+
+
+# ============================================================
+# Public API
+# ============================================================
+
+
+def set_access_checker(checker: AccessChecker) -> None:
+    """Устанавливает AccessChecker (один раз при старте)."""
+    _state["checker"] = checker
+
+
+def get_access_checker() -> AccessChecker:
+    """Возвращает текущий AccessChecker."""
+    return _state["checker"]
+
+
+def set_access_session(session) -> None:
+    """Устанавливает сессию для текущего запроса."""
+    _access_session.set(session)
+
+
+def get_access_session():
+    """Возвращает сессию текущего запроса."""
+    return _access_session.get()
+
+
+def clear_access_session() -> None:
+    """Очищает сессию (после завершения post_init)."""
+    _access_session.set(None)

dotorm/builder/builder.py

@@ -0,0 +1,72 @@
+"""
+SQL Query Builder.
+
+Combines base state with mixin functionality.
+"""
+
+from typing import TYPE_CHECKING
+
+from ..components.filter_parser import FilterParser
+
+from .mixins import (
+    CRUDMixin,
+    Many2ManyMixin,
+    RelationsMixin,
+)
+
+if TYPE_CHECKING:
+    from ..fields import Field
+    from ..components.dialect import Dialect
+
+
+class Builder(
+    CRUDMixin,
+    Many2ManyMixin,
+    RelationsMixin,
+):
+    """
+    Unified SQL query builder.
+
+    Inherits from:
+        - CRUDMixin: create, read, update, delete operations
+        - Many2ManyMixin: M2M relation queries
+        - RelationsMixin: Batch relation loading
+
+    Example:
+        builder = Builder(
+            table="users",
+            fields=model_fields,
+            dialect=POSTGRES,
+        )
+
+        # Simple queries
+        sql, vals = builder.build_get(id=1)
+        sql, vals = builder.build_delete(id=1)
+
+        # Search with filter
+        sql, vals = builder.build_search(
+            fields=["id", "name"],
+            filter=[("status", "=", "active")],
+            limit=10,
+        )
+
+    MRO ensures BuilderBase.__init__ is called and provides
+    all attributes that mixins expect.
+    """
+
+    __slots__ = ("table", "fields", "dialect", "filter_parser")
+
+    def __init__(
+        self,
+        table: str,
+        fields: dict[str, "Field"],
+        dialect: "Dialect",
+    ) -> None:
+        self.table = table
+        self.fields = fields
+        self.dialect = dialect
+        self.filter_parser = FilterParser(dialect)
+
+    def get_store_fields(self) -> list[str]:
+        """Returns only fields that are stored in DB (store=True)."""
+        return [name for name, field in self.fields.items() if field.store]

dotorm/builder/helpers.py

@@ -0,0 +1,63 @@
+"""Helper functions for SQL building."""
+
+from __future__ import annotations
+from typing import Any
+
+
+def build_sql_update_from_schema(
+    sql: str,
+    payload_dict: dict[str, Any],
+    id: int | list[int],
+) -> tuple[str, tuple]:
+    """Составляет запрос обновления (update).
+
+    Arguments:
+        sql -- текст шаблона запроса
+        payload_dict -- сериализованные данные модели
+        id -- идентификатор или список идентификаторов
+
+    Returns:
+        sql -- текст запроса с подстановками (биндингами)
+        values_list -- значения для биндинга
+    """
+    if not payload_dict:
+        raise ValueError("payload_dict cannot be empty")
+
+    fields_list, values_list = zip(*payload_dict.items())
+    values_list = tuple(values_list)
+
+    if isinstance(id, list):
+        values_list += tuple(id)
+        where_placeholder = ", ".join(["%s"] * len(id))
+    else:
+        values_list += (id,)
+        where_placeholder = "%s"
+
+    query_placeholders = ", ".join(f"{field}=%s" for field in fields_list)
+    sql = sql % (query_placeholders, where_placeholder)
+    return sql, values_list
+
+
+def build_sql_create_from_schema(
+    sql: str,
+    payload_dict: dict[str, Any],
+) -> tuple[str, tuple]:
+    """Составляет запрос создания (insert).
+
+    Arguments:
+        sql -- текст шаблона запроса
+        payload_dict -- сериализованные данные модели
+
+    Returns:
+        sql -- текст запроса с подстановками (биндингами)
+        values_list -- значения для биндинга
+    """
+    if not payload_dict:
+        raise ValueError("payload_dict cannot be empty")
+
+    fields_list, values_list = zip(*payload_dict.items())
+
+    query_columns = ", ".join(fields_list)
+    query_placeholders = ", ".join(["%s"] * len(values_list))
+    sql = sql % (query_columns, query_placeholders)
+    return sql, values_list

dotorm/builder/mixins/__init__.py

@@ -0,0 +1,11 @@
+"""Builder mixins - stateless method providers."""
+
+from .crud import CRUDMixin
+from .m2m import Many2ManyMixin
+from .relations import RelationsMixin
+
+__all__ = [
+    "CRUDMixin",
+    "Many2ManyMixin",
+    "RelationsMixin",
+]

dotorm/builder/mixins/crud.py

@@ -0,0 +1,246 @@
+"""CRUD operations mixin."""
+
+from typing import TYPE_CHECKING, Any, Literal
+
+from ...components.filter_parser import FilterExpression
+
+if TYPE_CHECKING:
+    from ..protocol import BuilderProtocol
+
+from ..helpers import (
+    build_sql_create_from_schema,
+    build_sql_update_from_schema,
+)
+
+
+# Allowed order values (uppercase for comparison)
+_ALLOWED_ORDER = frozenset({"ASC", "DESC"})
+
+
+class CRUDMixin:
+    """
+    Mixin providing basic CRUD query builders.
+
+    Builder работает с dict, а не с моделью.
+    Сериализация модели в dict происходит в ORM слое.
+
+    Expects: table, fields, dialect, get_store_fields(), filter_parser
+    """
+
+    __slots__ = ()
+
+    def build_delete(self: "BuilderProtocol") -> str:
+        return f"DELETE FROM {self.table} WHERE id=%s"
+
+    def build_delete_bulk(self: "BuilderProtocol", count: int) -> str:
+        args = ",".join(["%s"] * count)
+        return f"DELETE FROM {self.table} WHERE id IN ({args})"
+
+    def build_create(
+        self: "BuilderProtocol",
+        payload_dict: dict[str, Any],
+    ) -> tuple[str, tuple]:
+        """Build INSERT query from dict."""
+        stmt = f"INSERT INTO {self.table} (%s) VALUES (%s)"
+        stmt, values_list = build_sql_create_from_schema(stmt, payload_dict)
+        return stmt, values_list
+
+    def build_create_bulk(
+        self: "BuilderProtocol",
+        payloads_dicts: list[dict[str, Any]],
+    ) -> tuple[str, list]:
+        """Build bulk INSERT query with multiple VALUES."""
+        if not payloads_dicts:
+            raise ValueError("payloads_dicts cannot be empty")
+
+        # Берём ключи из первого payload
+        fields_list = list(payloads_dicts[0].keys())
+        query_columns = ", ".join(fields_list)
+
+        # Собираем все значения в плоский список
+        all_values = []
+        value_groups = []
+        param_index = 1
+
+        for payload_dict in payloads_dicts:
+            placeholders = []
+            for field in fields_list:
+                placeholders.append(f"${param_index}")
+                all_values.append(payload_dict[field])
+                param_index += 1
+            value_groups.append(f"({', '.join(placeholders)})")
+
+        values_clause = ", ".join(value_groups)
+        stmt = f"INSERT INTO {self.table} ({query_columns}) VALUES {values_clause}"
+
+        return stmt, all_values
+
+    def build_update(
+        self: "BuilderProtocol",
+        payload_dict: dict[str, Any],
+        id: int,
+    ) -> tuple[str, tuple]:
+        """Build UPDATE query from dict."""
+        stmt = f"UPDATE {self.table} SET %s WHERE id = %s"
+        stmt, values_list = build_sql_update_from_schema(
+            stmt, payload_dict, id
+        )
+        return stmt, values_list
+
+    def build_update_bulk(
+        self: "BuilderProtocol",
+        payload_dict: dict[str, Any],
+        ids: list[int],
+    ) -> tuple[str, tuple]:
+        """Build bulk UPDATE query from dict."""
+        stmt = f"UPDATE {self.table} SET %s WHERE id IN (%s)"
+        stmt, values_list = build_sql_update_from_schema(
+            stmt, payload_dict, ids
+        )
+        return stmt, values_list
+
+    def build_get(
+        self: "BuilderProtocol",
+        id: int,
+        fields: list[str] | None = None,
+    ) -> tuple[str, list]:
+        """
+        Build SELECT by ID query.
+
+        Args:
+            id: Record ID
+            fields: Fields to select (empty = all stored)
+        """
+        escape = self.dialect.escape
+        store_fields = self.get_store_fields()
+
+        selected_fields = fields if fields else store_fields
+        fields_stmt = ", ".join(
+            f"{escape}{name}{escape}" for name in selected_fields
+        )
+
+        stmt = f"SELECT {fields_stmt} FROM {self.table} WHERE id = %s LIMIT 1"
+        return stmt, [id]
+
+    def build_table_len(self: "BuilderProtocol") -> tuple[str, None]:
+        stmt = f"SELECT COUNT(*) FROM {self.table}"
+        return stmt, None
+
+    def build_search(
+        self: "BuilderProtocol",
+        fields: list[str] | None = None,
+        start: int | None = None,
+        end: int | None = None,
+        limit: int = 80,
+        order: Literal["DESC", "ASC", "desc", "asc"] = "DESC",
+        sort: str = "id",
+        filter: FilterExpression | None = None,
+        raw: bool = False,
+    ) -> tuple[str, tuple]:
+        """
+        Build search query.
+
+        Args:
+            fields: Fields to select (default: ["id"])
+            start: Offset start
+            end: Offset end
+            limit: Max records
+            order: Sort order (ASC/DESC)
+            sort: Sort field
+            filter: Filter expression
+            raw: Return raw dict instead of model
+        """
+        escape = self.dialect.escape
+        store_fields = self.get_store_fields()
+
+        if fields is None:
+            fields = ["id"]
+
+        # поставить защиту, хотя по идее защита есть в ОРМ
+        order_upper = order.upper()
+        if order_upper not in _ALLOWED_ORDER:
+            raise ValueError(f"Invalid order: {order}")
+        if sort not in store_fields:
+            sort = store_fields[0]
+            # raise ValueError(f"Invalid sort field: {sort}")
+
+        fields_store_stmt = ", ".join(
+            f"{escape}{name}{escape}"
+            for name in fields
+            if name in store_fields
+        )
+
+        where = ""
+        where_values: tuple = ()
+
+        if filter:
+            where_clause, where_values = self.filter_parser.parse(filter)
+            where = f"WHERE {where_clause}"
+
+        stmt = (
+            f"SELECT {fields_store_stmt} FROM {self.table} "
+            f"{where} ORDER BY {sort} {order_upper} "
+        )
+
+        val: tuple = ()
+
+        if end is not None and start is not None:
+            stmt += "LIMIT %s OFFSET %s"
+            val = (end - start, start)
+        elif limit:
+            stmt += "LIMIT %s"
+            val = (limit,)
+
+        # Prepend where values
+        if where_values:
+            val = where_values + val
+
+        return stmt, val
+
+    def build_search_count(
+        self: "BuilderProtocol",
+        filter: FilterExpression | None = None,
+    ) -> tuple[str, tuple]:
+        """
+        Build COUNT query with filter.
+
+        Args:
+            filter: Filter expression
+
+        Returns:
+            Tuple of (query, values)
+        """
+        where = ""
+        where_values: tuple = ()
+
+        if filter:
+            where_clause, where_values = self.filter_parser.parse(filter)
+            where = f"WHERE {where_clause}"
+
+        stmt = f"SELECT COUNT(*) as count FROM {self.table} {where}"
+
+        return stmt, where_values
+
+    def build_exists(
+        self: "BuilderProtocol",
+        filter: FilterExpression | None = None,
+    ) -> tuple[str, tuple]:
+        """
+        Build EXISTS query with filter.
+
+        Args:
+            filter: Filter expression
+
+        Returns:
+            Tuple of (query, values)
+        """
+        where = ""
+        where_values: tuple = ()
+
+        if filter:
+            where_clause, where_values = self.filter_parser.parse(filter)
+            where = f"WHERE {where_clause}"
+
+        stmt = f"SELECT 1 FROM {self.table} {where} LIMIT 1"
+
+        return stmt, where_values