fastapi-fsp 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

fastapi_fsp/fsp.py

@@ -2,8 +2,10 @@ import math
 from typing import Annotated, Any, List, Optional
 
 from fastapi import Depends, HTTPException, Query, Request, status
+from pydantic import ValidationError
 from sqlalchemy import Select, func
-from sqlmodel import Session, select
+from sqlmodel import Session, not_, select
+from sqlmodel.ext.asyncio.session import AsyncSession
 
 from fastapi_fsp.models import (
     Filter,
@@ -18,22 +20,90 @@ from fastapi_fsp.models import (
 )
 
 
-def _parse_filters(
-    fields: Optional[List[str]] = Query(None, alias="field"),
-    operators: Optional[List[FilterOperator]] = Query(None, alias="operator"),
-    values: Optional[List[str]] = Query(None, alias="value"),
-) -> List[Filter] | None:
-    if not fields:
-        return None
-    filters: List[Filter] = []
+def _parse_one_filter_at(i: int, field: str, operator: str, value: str) -> Filter:
+    try:
+        filter_ = Filter(field=field, operator=FilterOperator(operator), value=value)
+    except ValidationError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Invalid filter at index {i}: {str(e)}",
+        ) from e
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Invalid operator '{operator}' at index {i}.",
+        ) from e
+    return filter_
+
+
+def _parse_array_of_filters(
+    fields: List[str], operators: List[str], values: List[str]
+) -> List[Filter]:
+    # Validate that we have matching lengths
     if not (len(fields) == len(operators) == len(values)):
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
-            detail="Mismatched filter parameters.",
+            detail="Mismatched filter parameters in array format.",
         )
-    for field, operator, value in zip(fields, operators, values):
-        filters.append(Filter(field=field, operator=operator, value=value))
-    return filters
+    return [
+        _parse_one_filter_at(i, field, operator, value)
+        for i, (field, operator, value) in enumerate(zip(fields, operators, values))
+    ]
+
+
+def _parse_filters(
+    request: Request,
+) -> Optional[List[Filter]]:
+    """
+    Parse filters from query parameters supporting two formats:
+    1. Indexed format:
+       ?filters[0][field]=age&filters[0][operator]=gte&filters[0][value]=18&filters[1][field]=name&filters[1][operator]=ilike&filters[1][value]=joy
+    2. Simple format:
+       ?field=age&operator=gte&value=18&field=name&operator=ilike&value=joy
+    """
+    query_params = request.query_params
+    filters = []
+
+    # Try indexed format first: filters[0][field], filters[0][operator], etc.
+    i = 0
+    while True:
+        field_key = f"filters[{i}][field]"
+        operator_key = f"filters[{i}][operator]"
+        value_key = f"filters[{i}][value]"
+
+        field = query_params.get(field_key)
+        operator = query_params.get(operator_key)
+        value = query_params.get(value_key)
+
+        # If we don't have a field at this index, break the loop
+        if field is None:
+            break
+
+        # Validate that we have all required parts
+        if operator is None or value is None:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Incomplete filter at index {i}. Missing operator or value.",
+            )
+
+        filters.append(_parse_one_filter_at(i, field, operator, value))
+        i += 1
+
+    # If we found indexed filters, return them
+    if filters:
+        return filters
+
+    # Fall back to simple format: field, operator, value
+    filters = _parse_array_of_filters(
+        query_params.getlist("field"),
+        query_params.getlist("operator"),
+        query_params.getlist("value"),
+    )
+    if filters:
+        return filters
+
+    # No filters found
+    return None
 
 
 def _parse_sort(
@@ -72,11 +142,24 @@ class FSPManager:
             )
         ).all()
 
+    async def paginate_async(self, query: Select, session: AsyncSession) -> Any:
+        result = await session.exec(
+            query.offset((self.pagination.page - 1) * self.pagination.per_page).limit(
+                self.pagination.per_page
+            )
+        )
+        return result.all()
+
     def _count_total(self, query: Select, session: Session) -> int:
         # Count the total rows of the given query (with filters/sort applied) ignoring pagination
         count_query = select(func.count()).select_from(query.subquery())
         return session.exec(count_query).one()
 
+    async def _count_total_async(self, query: Select, session: AsyncSession) -> int:
+        count_query = select(func.count()).select_from(query.subquery())
+        result = await session.exec(count_query)
+        return result.one()
+
     def _apply_filters(self, query: Select) -> Select:
         # Helper: build a map of column name -> column object from the select statement
         try:
@@ -152,7 +235,7 @@ class FSPManager:
             elif op == "like":
                 query = query.where(column.like(str(raw_value)))
             elif op == "not_like":
-                query = query.where(~column.like(str(raw_value)))
+                query = query.where(not_(column.like(str(raw_value))))
             elif op == "ilike":
                 pattern = str(raw_value)
                 if ilike_supported(column):
@@ -162,15 +245,15 @@ class FSPManager:
             elif op == "not_ilike":
                 pattern = str(raw_value)
                 if ilike_supported(column):
-                    query = query.where(~column.ilike(pattern))
+                    query = query.where(not_(column.ilike(pattern)))
                 else:
-                    query = query.where(~func.lower(column).like(pattern.lower()))
+                    query = query.where(not_(func.lower(column).like(pattern.lower())))
             elif op == "in":
                 vals = [coerce_value(column, v) for v in split_values(raw_value)]
                 query = query.where(column.in_(vals))
             elif op == "not_in":
                 vals = [coerce_value(column, v) for v in split_values(raw_value)]
-                query = query.where(~column.in_(vals))
+                query = query.where(not_(column.in_(vals)))
             elif op == "between":
                 vals = split_values(raw_value)
                 if len(vals) != 2:
@@ -185,13 +268,22 @@ class FSPManager:
                 query = query.where(column.is_not(None))
             elif op == "starts_with":
                 pattern = f"{str(raw_value)}%"
-                query = query.where(column.like(pattern))
+                if ilike_supported(column):
+                    query = query.where(column.ilike(pattern))
+                else:
+                    query = query.where(func.lower(column).like(pattern.lower()))
             elif op == "ends_with":
                 pattern = f"%{str(raw_value)}"
-                query = query.where(column.like(pattern))
+                if ilike_supported(column):
+                    query = query.where(column.ilike(pattern))
+                else:
+                    query = query.where(func.lower(column).like(pattern.lower()))
             elif op == "contains":
                 pattern = f"%{str(raw_value)}%"
-                query = query.where(column.like(pattern))
+                if ilike_supported(column):
+                    query = query.where(column.ilike(pattern))
+                else:
+                    query = query.where(func.lower(column).like(pattern.lower()))
             else:
                 # Unknown operator: skip
                 continue
@@ -221,7 +313,6 @@ class FSPManager:
 
     def generate_response(self, query: Select, session: Session) -> PaginatedResponse[Any]:
         query = self._apply_filters(query)
-
         query = self._apply_sort(query)
 
         total_items = self._count_total(query, session)
@@ -267,3 +358,53 @@ class FSPManager:
                 prev=prev_url,
             ),
         )
+
+    async def generate_response_async(
+        self, query: Select, session: AsyncSession
+    ) -> PaginatedResponse[Any]:
+        query = self._apply_filters(query)
+        query = self._apply_sort(query)
+
+        total_items = await self._count_total_async(query, session)
+        per_page = self.pagination.per_page
+        current_page = self.pagination.page
+        total_pages = max(1, math.ceil(total_items / per_page)) if total_items is not None else 1
+
+        data_page = await self.paginate_async(query, session)
+
+        # Build links based on current URL, replacing/adding page and per_page parameters
+        url = self.request.url
+        first_url = str(url.include_query_params(page=1, per_page=per_page))
+        last_url = str(url.include_query_params(page=total_pages, per_page=per_page))
+        next_url = (
+            str(url.include_query_params(page=current_page + 1, per_page=per_page))
+            if current_page < total_pages
+            else None
+        )
+        prev_url = (
+            str(url.include_query_params(page=current_page - 1, per_page=per_page))
+            if current_page > 1
+            else None
+        )
+        self_url = str(url.include_query_params(page=current_page, per_page=per_page))
+
+        return PaginatedResponse(
+            data=data_page,
+            meta=Meta(
+                pagination=Pagination(
+                    total_items=total_items,
+                    per_page=per_page,
+                    current_page=current_page,
+                    total_pages=total_pages,
+                ),
+                filters=self.filters,
+                sort=self.sorting,
+            ),
+            links=Links(
+                self=self_url,
+                first=first_url,
+                last=last_url,
+                next=next_url,
+                prev=prev_url,
+            ),
+        )

{fastapi_fsp-0.1.0.dist-info → fastapi_fsp-0.1.2.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fastapi-fsp
-Version: 0.1.0
+Version: 0.1.2
 Summary: Filter, Sort, and Paginate (FSP) utilities for FastAPI + SQLModel
-Project-URL: Homepage, https://github.com/your-org/fastapi-fsp
-Project-URL: Repository, https://github.com/your-org/fastapi-fsp
-Project-URL: Issues, https://github.com/your-org/fastapi-fsp/issues
+Project-URL: Homepage, https://github.com/fromej-dev/fastapi-fsp
+Project-URL: Repository, https://github.com/fromej-dev/fastapi-fsp
+Project-URL: Issues, https://github.com/fromej-dev/fastapi-fsp/issues
 Author-email: Evert Jan Stamhuis <ej@fromejdevelopment.nl>
 License: MIT
 License-File: LICENSE
@@ -109,7 +109,9 @@ Sorting:
 - sort_by: the field name, e.g., `name`
 - order: `asc` or `desc`
 
-Filtering (repeatable sets; arrays are supported by sending multiple parameters):
+Filtering (two supported formats):
+
+1) Simple (triplets repeated in the query string):
 - field: the field/column name, e.g., `name`
 - operator: one of
   - eq, ne
@@ -122,17 +124,25 @@ Filtering (repeatable sets; arrays are supported by sending multiple parameters)
   - contains, starts_with, ends_with (translated to LIKE patterns)
 - value: raw string value (or list-like comma-separated depending on operator)
 
-Examples:
+Examples (simple format):
 - `?field=name&operator=eq&value=Deadpond`
 - `?field=age&operator=between&value=18,30`
 - `?field=name&operator=in&value=Deadpond,Rusty-Man`
 - `?field=name&operator=contains&value=man`
+- Chain multiple filters by repeating the triplet: `?field=age&operator=gte&value=18&field=name&operator=ilike&value=rust`
+
+2) Indexed format (useful for clients that handle arrays of objects):
+- Use keys like `filters[0][field]`, `filters[0][operator]`, `filters[0][value]`, then increment the index for additional filters (`filters[1][...]`, etc.).
 
-You can chain multiple filters by repeating the triplet:
+Example (indexed format):
 ```
-?field=age&operator=gte&value=18&field=name&operator=ilike&value=rust
+?filters[0][field]=age&filters[0][operator]=gte&filters[0][value]=18&filters[1][field]=name&filters[1][operator]=ilike&filters[1][value]=joy
 ```
 
+Notes:
+- Both formats are equivalent; the indexed format takes precedence if present.
+- If any filter is incomplete (missing operator or value in the indexed form, or mismatched counts of simple triplets), the API responds with HTTP 400.
+
 ## Response model
 
 ```

fastapi_fsp-0.1.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+fastapi_fsp/__init__.py,sha256=0I_XN_ptNu1NyNRpjdyVm6nwvrilAB8FyT2EfgVF_QA,215
+fastapi_fsp/fsp.py,sha256=vCmaKbUw-UeLLklUcVNbbEicsxlEnSGO9Sd9jLq3I3Y,15174
+fastapi_fsp/models.py,sha256=_P72r_kgVh_ZvoKQqU359vnbJTxeWnvnT6yV5_M558Q,1740
+fastapi_fsp-0.1.2.dist-info/METADATA,sha256=0LL3xqAnDsME26BNsqUUwJ22sgWkPNF6I16OB-K3CJE,6087
+fastapi_fsp-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastapi_fsp-0.1.2.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+fastapi_fsp-0.1.2.dist-info/RECORD,,

fastapi_fsp-0.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-fastapi_fsp/__init__.py,sha256=0I_XN_ptNu1NyNRpjdyVm6nwvrilAB8FyT2EfgVF_QA,215
-fastapi_fsp/fsp.py,sha256=lC9CV0T4Zjf4MRaVdtq2HZlpRusxuR-na_AQnZa1w6A,10033
-fastapi_fsp/models.py,sha256=_P72r_kgVh_ZvoKQqU359vnbJTxeWnvnT6yV5_M558Q,1740
-fastapi_fsp-0.1.0.dist-info/METADATA,sha256=qxwzS_WR_pCfJTPSktw-5LDSm6UyU1WulD4UTTIR-T8,5430
-fastapi_fsp-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastapi_fsp-0.1.0.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-fastapi_fsp-0.1.0.dist-info/RECORD,,