s-ormkit 0.0.1__tar.gz → 0.1.0__tar.gz

{s_ormkit-0.0.1 → s_ormkit-0.1.0}/CHANGELOG.md

@@ -5,6 +5,23 @@
 Формат основан на [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 и этот проект соответствует [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.0] - 2026-07-07
+
+### Added
+
+- **`ormkit.pagination`** — offset-пагинация: чистые `Page[T]` / `page_to_offset`
+  + SQL-исполнитель `paginate_stmt(session, stmt, limit, offset, count_stmt=,
+  scalars=)` (limit/offset + авто-count, либо custom count для JOIN/DISTINCT).
+- **`ormkit.search`** — `trigram_filter(stmt, cols, q, dialect=, threshold=)`:
+  fuzzy-поиск (PostgreSQL `word_similarity`/pg_trgm с exact-boost, ILIKE-fallback
+  для остальных диалектов); возвращает `(stmt_with_where, rank_expr)`.
+- **`ormkit.rls`** — tenant Row-Level Security (defense-in-depth): `TenantContext`,
+  ContextVar-хелперы (`set`/`reset`/`current_tenant_context`), `rls_bypass`
+  контекст-менеджер, `apply_tenant_guc` (transaction-local GUC `app.rls_enforce`/
+  `app.rls_bypass`/`app.current_company`; no-op на не-PostgreSQL и при `ctx=None`).
+
+Все три модуля вынесены из skills-hub (generic SQLAlchemy, 0 завязок на приложение).
+
 ## [0.0.1] - 2026-07-04
 
 ### Added

{s_ormkit-0.0.1 → s_ormkit-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s-ormkit
-Version: 0.0.1
+Version: 0.1.0
 Summary: Generic БД/ORM-инфраструктура на SQLAlchemy 2.0: диалект-нейтральный движок из DB-URL, Repository + UnitOfWork + DIP-протоколы. 0 завязок на конкретное приложение.
 Author: Dmitry
 License: MIT
@@ -8,6 +8,7 @@ License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: sqlalchemy>=2.0
 Provides-Extra: dev
+Requires-Dist: aiosqlite>=0.20; extra == 'dev'
 Requires-Dist: psycopg[binary]>=3.1; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
 Requires-Dist: pytest-cov>=6.0; extra == 'dev'

{s_ormkit-0.0.1 → s_ormkit-0.1.0}/ormkit/__init__.py

@@ -13,6 +13,12 @@ sqlite/диалект: движок конфигурируется через DB
 - Транзакционная граница: `UnitOfWork`
 - DIP-контракты: `RepositoryProtocol`, `UnitOfWorkProtocol`
 
+**Инфра-хелперы (v0.1.0):**
+- Пагинация: `Page`, `page_to_offset`, `paginate_stmt` (limit/offset + count)
+- Fuzzy-поиск: `trigram_filter` (pg_trgm word_similarity / ILIKE fallback)
+- Tenant RLS: `TenantContext`, `apply_tenant_guc`, `rls_bypass`,
+  `set_tenant_context` / `reset_tenant_context` / `current_tenant_context`
+
 Зависимости: SQLAlchemy>=2.0 (и ничего больше).
 """
 from __future__ import annotations
@@ -26,11 +32,21 @@ from ormkit.engine import (
     make_session_factory,
 )
 from ormkit.exceptions import NotFoundError, OrmKitError
+from ormkit.pagination import Page, page_to_offset, paginate_stmt
 from ormkit.protocols import RepositoryProtocol, UnitOfWorkProtocol
 from ormkit.repository import BaseRepository
+from ormkit.rls import (
+    TenantContext,
+    apply_tenant_guc,
+    current_tenant_context,
+    reset_tenant_context,
+    rls_bypass,
+    set_tenant_context,
+)
+from ormkit.search import trigram_filter
 from ormkit.unit_of_work import UnitOfWork
 
-__version__ = "0.0.1"
+__version__ = "0.1.0"
 
 __all__ = [
     # base
@@ -53,4 +69,17 @@ __all__ = [
     # exceptions
     "OrmKitError",
     "NotFoundError",
+    # pagination
+    "Page",
+    "page_to_offset",
+    "paginate_stmt",
+    # search
+    "trigram_filter",
+    # rls (tenant Row-Level Security)
+    "TenantContext",
+    "apply_tenant_guc",
+    "rls_bypass",
+    "set_tenant_context",
+    "reset_tenant_context",
+    "current_tenant_context",
 ]

s_ormkit-0.1.0/ormkit/pagination.py

@@ -0,0 +1,131 @@
+"""Offset-пагинация: чистый контракт (``Page`` / ``page_to_offset``) + SQL-исполнитель.
+
+Единый инструмент offset-пагинации вместо копипасты ``.limit().offset()`` + отдельный
+``select(func.count())`` в каждом репозитории.
+
+Разделение:
+- :class:`Page` и :func:`page_to_offset` — ЧИСТАЯ логика (без SQLAlchemy); ими может
+  пользоваться и application-слой, не зная про ORM.
+- :func:`paginate_stmt` — SQL-исполнитель (нужна ``AsyncSession``).
+
+Паттерн:
+    offset = page_to_offset(page=2, size=20)  # → 20
+
+    # Простой случай: count ≈ simple COUNT() по тем же WHERE-условиям.
+    items, total = await paginate_stmt(session, stmt, limit=20, offset=offset)
+
+    # Сложный случай: счётчик отличается (JOIN-мультипликация, DISTINCT).
+    custom = select(func.count(distinct(User.id))).where(...)
+    items, total = await paginate_stmt(
+        session, stmt, limit=20, offset=offset, count_stmt=custom
+    )
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from sqlalchemy import func, select
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+    from sqlalchemy.sql.selectable import Select
+
+T = TypeVar("T")
+
+# Тип строки для пагинации без scalars (кортежи вместо ORM).
+ResultRow = tuple
+
+
+@dataclass(frozen=True, slots=True)
+class Page(Generic[T]):
+    """Страница результатов пагинации.
+
+    Attributes:
+        items: кортеж элементов на этой странице.
+        total: общее количество элементов (для всех фильтров).
+    """
+
+    items: tuple[T, ...]
+    total: int
+
+
+def page_to_offset(page: int, size: int) -> int:
+    """Преобразуй номер страницы (1-индексированная) в SQL offset.
+
+    Args:
+        page: номер страницы, от 1. page=1 → offset=0, page=2 → offset=size.
+        size: размер страницы (количество элементов на странице).
+
+    Returns:
+        offset для SQL ``.offset()``.
+
+    Raises:
+        ValueError: если ``page < 1`` или ``size < 1``.
+
+    Example:
+        >>> page_to_offset(1, 20)
+        0
+        >>> page_to_offset(3, 20)
+        40
+    """
+    if page < 1:
+        raise ValueError(f"page must be >= 1, got {page}")
+    if size < 1:
+        raise ValueError(f"size must be >= 1, got {size}")
+    return (page - 1) * size
+
+
+async def paginate_stmt(
+    session: AsyncSession,
+    stmt: Select,  # type: ignore[type-arg]
+    *,
+    limit: int,
+    offset: int,
+    count_stmt: Select | None = None,  # type: ignore[type-arg]
+    scalars: bool = True,
+) -> tuple[list, int]:
+    """Выполни пагинированный SELECT с автоматическим count.
+
+    Args:
+        session: AsyncSession для выполнения запросов.
+        stmt: SQLAlchemy select-выражение для данных.
+        limit: количество строк на странице.
+        offset: смещение (сколько пропустить строк с начала).
+        count_stmt: опциональный custom COUNT-запрос. Если None, строится
+            автоматически как ``select(func.count())`` по ``stmt`` с убранными
+            ORDER BY, LIMIT, OFFSET (изолируем условия FROM/WHERE). Передавай,
+            когда счётчик отличается (JOIN-мультипликация, DISTINCT).
+        scalars: если True (default), результат — список ORM-объектов или
+            скаляров. Если False — список кортежей (для raw SELECT с
+            множественными колонками).
+
+    Returns:
+        Кортеж ``(items, total)``: список результатов и общее количество строк
+        (учитывающее все фильтры).
+
+    Example:
+        >>> items, total = await paginate_stmt(
+        ...     session, select(User).where(User.active), limit=20, offset=0
+        ... )
+    """
+    # Выполни data-запрос с limit/offset.
+    if scalars:
+        rows = list((await session.execute(stmt.limit(limit).offset(offset))).scalars().all())  # type: ignore[attr-defined]
+    else:
+        rows = list((await session.execute(stmt.limit(limit).offset(offset))).all())  # type: ignore[attr-defined]
+
+    # Если count_stmt не передан, строим его автоматически.
+    if count_stmt is None:
+        # Изолируем условия: убираем ORDER BY, LIMIT, OFFSET; грузим COUNT().
+        count_stmt = (
+            select(func.count())  # type: ignore[arg-type]
+            .select_from(
+                stmt.order_by(None).limit(None).offset(None).subquery()  # type: ignore[attr-defined]
+            )
+        )
+
+    # Выполни count-запрос.
+    total = int((await session.execute(count_stmt)).scalar_one())  # type: ignore[arg-type]
+
+    return rows, total

s_ormkit-0.1.0/ormkit/rls.py

@@ -0,0 +1,146 @@
+"""Request-scoped tenant-контекст для PostgreSQL Row-Level Security (RLS).
+
+**Defense-in-depth** поверх app-слоя tenant-изоляции: RLS — safety-net на случай
+«один забытый ``WHERE company_id = …`` = межтенантная утечка». Даже если запрос
+в коде забыл скоуп, БД физически не вернёт чужие строки.
+
+## Как это работает
+
+1. Приложение кладёт :class:`TenantContext` в process-wide ContextVar на входе
+   запроса (например, из FastAPI-зависимости) — обычно только когда RLS включён
+   флагом окружения.
+2. Транзакционная граница (UnitOfWork) в начале транзакции читает ContextVar и
+   через :func:`apply_tenant_guc` выставляет **transaction-local GUC**
+   (``SET LOCAL``-семантика через ``set_config(…, true)``):
+   - ``app.rls_enforce='on'`` — включает enforcement для текущей транзакции;
+   - либо ``app.rls_bypass='on'`` (привилегированный актор — видит все компании),
+   - либо ``app.current_company=<id>`` (tenant — видит свою компанию + global).
+3. RLS-политика в БД (создаётся отдельной миграцией потребителя) сверяет
+   ``company_id`` строки с этими GUC.
+
+## Почему безопасно включать постепенно
+
+Проектируй политику **permissive, пока ``app.rls_enforce`` не выставлен в 'on'**
+(``IS DISTINCT FROM 'on'`` → TRUE при отсутствии GUC). Тогда:
+
+- GUC никогда не ставится (RLS выключен) → политика всегда permissive → ноль
+  изменений поведения (применение миграции безопасно).
+- Системные контексты (seed, ETL, миграции, фон без токена) идут БЕЗ ContextVar
+  → :func:`apply_tenant_guc` получает ``None`` → GUC не ставится → permissive.
+
+Только аутентифицированный tenant-запрос получает enforcement. GUC-имена
+(``app.rls_enforce`` / ``app.rls_bypass`` / ``app.current_company``) — контракт
+между этим модулем и SQL-политикой потребителя.
+"""
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar, Token
+from dataclasses import dataclass
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+
+@dataclass(frozen=True, slots=True)
+class TenantContext:
+    """Tenant-скоуп текущего запроса для RLS.
+
+    Attributes:
+        company_id: id компании актора (``None`` — актор без company-scope).
+        bypass: ``True`` для привилегированного / системного контекста — видит
+            все компании (RLS-bypass). Имеет приоритет над ``company_id``.
+    """
+
+    company_id: int | None
+    bypass: bool = False
+
+
+_TENANT_CONTEXT: ContextVar[TenantContext | None] = ContextVar(
+    "ormkit_tenant_context", default=None
+)
+
+
+def set_tenant_context(ctx: TenantContext | None) -> Token[TenantContext | None]:
+    """Устанавливает tenant-контекст; вернёт token для :func:`reset_tenant_context`."""
+    return _TENANT_CONTEXT.set(ctx)
+
+
+def reset_tenant_context(token: Token[TenantContext | None]) -> None:
+    """Откатывает ContextVar к предыдущему значению (cleanup после запроса)."""
+    _TENANT_CONTEXT.reset(token)
+
+
+@contextmanager
+def rls_bypass() -> Iterator[None]:
+    """Контекст-менеджер: на время блока выставляет tenant-контекст с bypass=True
+    (RLS не enforce'ит). Канон для ПРИВИЛЕГИРОВАННЫХ операций, которые легитимно
+    пишут/читают кросс-компанийно (вступление по приглашению, чтение всех
+    membership'ов актора и т.п.).
+
+    Пример:
+        with rls_bypass():
+            await use_case.execute(...)
+    """
+    token = set_tenant_context(TenantContext(company_id=None, bypass=True))
+    try:
+        yield
+    finally:
+        reset_tenant_context(token)
+
+
+def current_tenant_context() -> TenantContext | None:
+    """Текущий tenant-контекст (``None`` вне запроса / при анонимном акторе)."""
+    return _TENANT_CONTEXT.get()
+
+
+async def apply_tenant_guc(
+    session: AsyncSession, ctx: TenantContext | None
+) -> None:
+    """Выставляет transaction-local GUC для RLS внутри открытой транзакции.
+
+    Должна вызываться ПОСЛЕ ``session.begin()`` (GUC через ``set_config(…, true)``
+    живёт до конца транзакции). На не-PostgreSQL диалектах (sqlite-тесты) и при
+    ``ctx is None`` (системный/анонимный контекст) — **no-op** (политика остаётся
+    permissive).
+    """
+    bind = session.bind
+    dialect = getattr(bind, "dialect", None)
+    if dialect is None or dialect.name != "postgresql":
+        return
+    # ВАЖНО (leak-guard): transaction-local GUC от ПРЕДЫДУЩЕЙ транзакции может
+    # «протечь» на checkout'е pooled-соединения. Поэтому КАЖДУЮ транзакцию
+    # начинаем с ЧИСТОГО baseline — иначе system/анонимный запрос (login, ETL;
+    # ctx=None) унаследовал бы чужой rls_enforce='on' / rls_bypass='on' /
+    # current_company и отфильтровал бы (или упал на ''::bigint).
+    await session.execute(
+        text("SELECT set_config('app.rls_bypass', '', true)")
+    )
+    await session.execute(
+        text("SELECT set_config('app.current_company', '', true)")
+    )
+    if ctx is None:
+        # Система/аноним → permissive (enforcement выключен).
+        await session.execute(
+            text("SELECT set_config('app.rls_enforce', '', true)")
+        )
+        return
+    # Tenant-запрос → enforcement on.
+    await session.execute(
+        text("SELECT set_config('app.rls_enforce', 'on', true)")
+    )
+    if ctx.bypass:
+        await session.execute(
+            text("SELECT set_config('app.rls_bypass', 'on', true)")
+        )
+    elif ctx.company_id is not None and str(ctx.company_id).strip() != "":
+        # Пустая строка ("" — company-less токен) НЕ ставится: current_company
+        # остаётся '' (== NULL через NULLIF в политике) → видны только
+        # global-строки. Непустой id → tenant-скоуп.
+        await session.execute(
+            text("SELECT set_config('app.current_company', :cid, true)"),
+            {"cid": str(ctx.company_id)},
+        )
+    # else: company-less, не bypass → current_company='' → NULLIF→NULL → только
+    # global-строки. Корректно.

s_ormkit-0.1.0/ormkit/search.py

@@ -0,0 +1,104 @@
+"""Единый fuzzy-поиск по любой сущности (search-gateway).
+
+Функция :func:`trigram_filter` принимает SQLAlchemy-стейтмент, список колонок
+и строку запроса, добавляет WHERE-условие и возвращает выражение ранжирования.
+
+**Диалект PostgreSQL** — использует ``word_similarity`` из расширения ``pg_trgm``.
+  ⚠️  Внимание: ``pg_trgm`` и GIN-индексы создаются отдельной миграцией
+  потребителя (не в этом модуле). Без расширения PG-ветка бросит
+  ``ProgrammingError`` только при реальном выполнении запроса — импорт модуля
+  безопасен в любом случае.
+
+**Остальные диалекты** (SQLite и пр.) — простой ILIKE (``lower(col) LIKE '%q%'``),
+ранжирование не применяется (``rank_expr = None``).
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import case, func, or_
+from sqlalchemy.sql import Select
+
+
+def trigram_filter(
+    stmt: Select,
+    cols: list[Any],
+    q: str,
+    *,
+    dialect: str,
+    threshold: float = 0.3,
+) -> tuple[Select, Any | None]:
+    """Добавляет fuzzy-фильтр по строке ``q`` к стейтменту ``stmt``.
+
+    Args:
+        stmt:      Исходный SELECT-стейтмент (не модифицируется на месте,
+                   возвращается новый с добавленным WHERE).
+        cols:      Список SQLAlchemy-колонок/выражений, по которым ищем.
+        q:         Строка поиска. Пустая / только пробелы — стейтмент
+                   возвращается без изменений, ``rank_expr = None``.
+        dialect:   Имя диалекта SQLAlchemy (``engine.dialect.name``):
+                   ``'postgresql'`` → word_similarity + точный буст,
+                   всё остальное → ILIKE без ранжирования.
+        threshold: Минимальное значение word_similarity для PG-ветки
+                   (0.0–1.0, дефолт 0.3). Игнорируется для не-PG диалектов.
+
+    Returns:
+        ``(stmt_with_where, rank_expr)``
+
+        - ``rank_expr`` — SQLAlchemy-выражение для ``ORDER BY rank_expr DESC``.
+          ``None`` для не-PG ветки или пустого ``q``.
+    """
+    # Пустой / whitespace q — не фильтруем, ранжирование не нужно.
+    q_stripped = q.strip() if q else ""
+    if not q_stripped:
+        return stmt, None
+
+    if dialect == "postgresql":
+        return _pg_trigram(stmt, cols, q_stripped, threshold)
+    else:
+        return _sqlite_ilike(stmt, cols, q_stripped)
+
+
+def _pg_trigram(
+    stmt: Select,
+    cols: list[Any],
+    q: str,
+    threshold: float,
+) -> tuple[Select, Any]:
+    """PostgreSQL-ветка: word_similarity с точным бустом до 2.0.
+
+    ВАЖНО: и запрос, и колонка приводятся к ``lower()`` — это (1) делает поиск
+    регистронезависимым (как прежний ``lower(col) LIKE``), и (2) совпадает с
+    выражением GIN-индекса ``lower(col) gin_trgm_ops`` → планировщик может
+    использовать индекс.
+    """
+    q_lower = q.lower()
+
+    # WHERE: хотя бы одна колонка имеет достаточную схожесть (по lower).
+    where_clause = or_(
+        *(func.word_similarity(q_lower, func.lower(col)) > threshold for col in cols)
+    )
+
+    # rank_expr: exact-match буcтится до 2.0, иначе — word_similarity (по lower).
+    # GREATEST берёт наибольшее значение по всем колонкам.
+    rank_parts = [
+        case(
+            (func.lower(col) == q_lower, 2.0),
+            else_=func.word_similarity(q_lower, func.lower(col)),
+        )
+        for col in cols
+    ]
+    rank_expr = func.greatest(*rank_parts)
+
+    return stmt.where(where_clause), rank_expr
+
+
+def _sqlite_ilike(
+    stmt: Select,
+    cols: list[Any],
+    q: str,
+) -> tuple[Select, None]:
+    """SQLite/fallback-ветка: ILIKE через lower(...) LIKE '%q%'."""
+    pattern = f"%{q.lower()}%"
+    where_clause = or_(*(func.lower(col).like(pattern) for col in cols))
+    return stmt.where(where_clause), None

{s_ormkit-0.0.1 → s_ormkit-0.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "s-ormkit"
-version = "0.0.1"
+version = "0.1.0"
 description = "Generic БД/ORM-инфраструктура на SQLAlchemy 2.0: диалект-нейтральный движок из DB-URL, Repository + UnitOfWork + DIP-протоколы. 0 завязок на конкретное приложение."
 readme = "README.md"
 license = { text = "MIT" }
@@ -13,7 +13,7 @@ dependencies = [
 [project.optional-dependencies]
 # psycopg (v3) — ТОЛЬКО для теста ленивого создания postgres-движка без живого сервера.
 # В runtime кит зависит исключительно от SQLAlchemy.
-dev = ["pytest>=8", "pytest-asyncio>=0.24", "pytest-cov>=6.0", "psycopg[binary]>=3.1"]
+dev = ["pytest>=8", "pytest-asyncio>=0.24", "pytest-cov>=6.0", "psycopg[binary]>=3.1", "aiosqlite>=0.20"]
 
 [build-system]
 requires = ["hatchling"]

s_ormkit-0.1.0/tests/unit/test_infra_helpers.py

@@ -0,0 +1,143 @@
+"""Тесты инфра-хелперов ormkit v0.1.0: pagination, search, rls."""
+from __future__ import annotations
+
+import pytest
+from sqlalchemy import Integer, String, select
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+from ormkit.pagination import Page, page_to_offset, paginate_stmt
+from ormkit.rls import (
+    TenantContext,
+    apply_tenant_guc,
+    current_tenant_context,
+    reset_tenant_context,
+    rls_bypass,
+    set_tenant_context,
+)
+from ormkit.search import trigram_filter
+
+
+# --- Демо-модель для async-тестов (принадлежит тестам, не киту) ---
+class _Base(DeclarativeBase):
+    pass
+
+
+class _Widget(_Base):
+    __tablename__ = "_widgets"
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(String(100))
+
+
+@pytest.fixture
+async def async_session():
+    engine = create_async_engine("sqlite+aiosqlite://")
+    async with engine.begin() as conn:
+        await conn.run_sync(_Base.metadata.create_all)
+    factory = async_sessionmaker(engine, expire_on_commit=False)
+    async with factory() as s:
+        for i in range(25):
+            s.add(_Widget(name=f"w{i:02d}"))
+        await s.commit()
+        yield s
+    await engine.dispose()
+
+
+# --- pagination: чистое ---
+def test_page_to_offset() -> None:
+    assert page_to_offset(1, 20) == 0
+    assert page_to_offset(2, 20) == 20
+    assert page_to_offset(3, 20) == 40
+
+
+@pytest.mark.parametrize("bad", [(0, 20), (1, 0), (-1, 5)])
+def test_page_to_offset_validates(bad: tuple[int, int]) -> None:
+    with pytest.raises(ValueError):
+        page_to_offset(*bad)
+
+
+def test_page_dataclass_frozen() -> None:
+    p: Page[int] = Page(items=(1, 2, 3), total=99)
+    assert p.items == (1, 2, 3)
+    assert p.total == 99
+    with pytest.raises(Exception):
+        p.total = 5  # type: ignore[misc]
+
+
+# --- pagination: SQL-исполнитель ---
+async def test_paginate_stmt_returns_page_and_total(async_session) -> None:
+    stmt = select(_Widget).order_by(_Widget.id)
+    items, total = await paginate_stmt(async_session, stmt, limit=10, offset=0)
+    assert total == 25
+    assert len(items) == 10
+    assert items[0].name == "w00"
+
+
+async def test_paginate_stmt_offset(async_session) -> None:
+    stmt = select(_Widget).order_by(_Widget.id)
+    items, total = await paginate_stmt(async_session, stmt, limit=10, offset=20)
+    assert total == 25
+    assert len(items) == 5  # хвост
+    assert items[0].name == "w20"
+
+
+async def test_paginate_stmt_scalars_false(async_session) -> None:
+    stmt = select(_Widget.id, _Widget.name).order_by(_Widget.id)
+    rows, total = await paginate_stmt(
+        async_session, stmt, limit=3, offset=0, scalars=False
+    )
+    assert total == 25
+    assert rows[0] == (1, "w00")
+
+
+# --- search ---
+def test_trigram_filter_empty_query_noop() -> None:
+    stmt = select(_Widget)
+    out, rank = trigram_filter(stmt, [_Widget.name], "  ", dialect="postgresql")
+    assert out is stmt
+    assert rank is None
+
+
+def test_trigram_filter_sqlite_ilike_no_rank() -> None:
+    stmt = select(_Widget)
+    out, rank = trigram_filter(stmt, [_Widget.name], "foo", dialect="sqlite")
+    assert rank is None
+    assert "lower" in str(out).lower()
+
+
+def test_trigram_filter_pg_has_rank() -> None:
+    stmt = select(_Widget)
+    out, rank = trigram_filter(stmt, [_Widget.name], "foo", dialect="postgresql")
+    assert rank is not None
+    compiled = str(out).lower()
+    assert "word_similarity" in compiled
+
+
+async def test_trigram_filter_sqlite_executes(async_session) -> None:
+    stmt = select(_Widget)
+    out, _ = trigram_filter(stmt, [_Widget.name], "w1", dialect="sqlite")
+    found = (await async_session.execute(out)).scalars().all()
+    # w10..w19 содержат "w1"
+    assert {w.name for w in found} == {f"w1{d}" for d in range(10)}
+
+
+# --- rls ---
+def test_tenant_context_var_set_reset() -> None:
+    assert current_tenant_context() is None
+    tok = set_tenant_context(TenantContext(company_id=42))
+    assert current_tenant_context() == TenantContext(company_id=42, bypass=False)
+    reset_tenant_context(tok)
+    assert current_tenant_context() is None
+
+
+def test_rls_bypass_contextmanager() -> None:
+    with rls_bypass():
+        ctx = current_tenant_context()
+        assert ctx is not None and ctx.bypass is True
+    assert current_tenant_context() is None
+
+
+async def test_apply_tenant_guc_noop_on_sqlite(async_session) -> None:
+    # На не-PostgreSQL — no-op, без ошибок (для обоих ctx).
+    await apply_tenant_guc(async_session, None)
+    await apply_tenant_guc(async_session, TenantContext(company_id=7))

{s_ormkit-0.0.1 → s_ormkit-0.1.0}/tests/unit/test_schema.py

@@ -43,4 +43,4 @@ def test_public_api_exports():
 
 @pytest.mark.unit
 def test_version():
-    assert ormkit.__version__ == "0.0.1"
+    assert ormkit.__version__ == "0.1.0"