Remove Cursor encoding/decoding logic

Author: febus982

sqlalchemy_bind_manager/_repository/__init__.py

@@ -1,4 +1,4 @@
 from .async_ import SQLAlchemyAsyncRepository
 from .base_repository import SortDirection
-from .common import Cursor, CursorPaginatedResult, PaginatedResult
+from .common import CursorPaginatedResult, CursorReference, PaginatedResult
 from .sync import SQLAlchemyRepository

sqlalchemy_bind_manager/_repository/async_.py

@@ -21,7 +21,13 @@
     BaseRepository,
     SortDirection,
 )
-from .common import MODEL, PRIMARY_KEY, Cursor, CursorPaginatedResult, PaginatedResult
+from .common import (
+    MODEL,
+    PRIMARY_KEY,
+    CursorPaginatedResult,
+    CursorReference,
+    PaginatedResult,
+)
 
 
 class SQLAlchemyAsyncRepository(Generic[MODEL], BaseRepository[MODEL], ABC):
@@ -180,7 +186,7 @@ async def paginated_find(
     async def cursor_paginated_find(
         self,
         items_per_page: int,
-        reference_cursor: Union[Cursor, str, None] = None,
+        cursor_reference: Union[CursorReference, None] = None,
         is_end_cursor: bool = False,
         search_params: Union[None, Mapping[str, Any]] = None,
     ) -> CursorPaginatedResult[MODEL]:
@@ -201,13 +207,10 @@ async def cursor_paginated_find(
         :return: A collection of models
         :rtype: List
         """
-        if isinstance(reference_cursor, str):
-            reference_cursor = self.decode_cursor(reference_cursor)
-
         find_stmt = self._find_query(search_params)
         paginated_stmt = self._cursor_paginated_query(
             find_stmt,
-            reference_cursor=reference_cursor,
+            cursor_reference=cursor_reference,
             is_end_cursor=is_end_cursor,
             per_page=items_per_page,
         )
@@ -224,6 +227,6 @@ async def cursor_paginated_find(
                 result_items=result_items,
                 total_items_count=total_items_count,
                 items_per_page=items_per_page,
-                reference_cursor=reference_cursor,
+                cursor_reference=cursor_reference,
                 is_end_cursor=is_end_cursor,
             )

sqlalchemy_bind_manager/_repository/base_repository.py

@@ -1,5 +1,4 @@
 from abc import ABC
-from base64 import b64decode, b64encode
 from enum import Enum
 from functools import partial
 from math import ceil
@@ -24,9 +23,9 @@
 
 from .common import (
     MODEL,
-    Cursor,
     CursorPageInfo,
     CursorPaginatedResult,
+    CursorReference,
     PageInfo,
     PaginatedResult,
 )
@@ -181,7 +180,7 @@ def _paginate_query_by_page(
     def _cursor_paginated_query(
         self,
         stmt: Select,
-        reference_cursor: Union[Cursor, None],
+        cursor_reference: Union[CursorReference, None],
         is_end_cursor: bool = False,
         per_page: int = _max_query_limit,
     ) -> Select:
@@ -200,52 +199,52 @@ def _cursor_paginated_query(
 
         forward_limit = self._sanitised_query_limit(per_page) + 1
 
-        if not reference_cursor:
+        if not cursor_reference:
             return stmt.limit(forward_limit).order_by(  # type: ignore
                 asc(self._model_pk())
             )
 
         # TODO: Use window functions
         if not is_end_cursor:
             previous_query = stmt.where(
-                getattr(self._model, reference_cursor.column) <= reference_cursor.value
+                getattr(self._model, cursor_reference.column) <= cursor_reference.value
             )
             previous_query = (
                 self._filter_order_by(
-                    previous_query, [(reference_cursor.column, SortDirection.DESC)]
+                    previous_query, [(cursor_reference.column, SortDirection.DESC)]
                 )
                 .limit(1)
                 .subquery("previous")  # type: ignore
             )
 
             page_query = stmt.where(
-                getattr(self._model, reference_cursor.column) > reference_cursor.value
+                getattr(self._model, cursor_reference.column) > cursor_reference.value
             )
             page_query = (
                 self._filter_order_by(
-                    page_query, [(reference_cursor.column, SortDirection.ASC)]
+                    page_query, [(cursor_reference.column, SortDirection.ASC)]
                 )
                 .limit(forward_limit)
                 .subquery("page")  # type: ignore
             )
         else:
             previous_query = stmt.where(
-                getattr(self._model, reference_cursor.column) >= reference_cursor.value
+                getattr(self._model, cursor_reference.column) >= cursor_reference.value
             )
             previous_query = (
                 self._filter_order_by(
-                    previous_query, [(reference_cursor.column, SortDirection.ASC)]
+                    previous_query, [(cursor_reference.column, SortDirection.ASC)]
                 )
                 .limit(1)
                 .subquery("previous")  # type: ignore
             )
 
             page_query = stmt.where(
-                getattr(self._model, reference_cursor.column) < reference_cursor.value
+                getattr(self._model, cursor_reference.column) < cursor_reference.value
             )
             page_query = (
                 self._filter_order_by(
-                    page_query, [(reference_cursor.column, SortDirection.DESC)]
+                    page_query, [(cursor_reference.column, SortDirection.DESC)]
                 )
                 .limit(forward_limit)
                 .subquery("page")  # type: ignore
@@ -256,7 +255,7 @@ def _cursor_paginated_query(
                 self._model,
                 select(previous_query)
                 .union(select(page_query))
-                .order_by(reference_cursor.column)
+                .order_by(cursor_reference.column)
                 .subquery(),  # type: ignore
             )
         )
@@ -302,7 +301,7 @@ def _build_cursor_paginated_result(
         result_items: List[MODEL],
         total_items_count: int,
         items_per_page: int,
-        reference_cursor: Union[Cursor, None],
+        cursor_reference: Union[CursorReference, None],
         is_end_cursor: bool,
     ) -> CursorPaginatedResult:
         """
@@ -312,7 +311,7 @@ def _build_cursor_paginated_result(
         :param result_items:
         :param total_items_count:
         :param items_per_page:
-        :param reference_cursor:
+        :param cursor_reference:
         :param is_end_cursor:
         :return:
         """
@@ -329,7 +328,7 @@ def _build_cursor_paginated_result(
         if not result_items:
             return result_structure
 
-        if not reference_cursor:
+        if not cursor_reference:
             has_previous_page = False
             has_next_page = len(result_items) > sanitised_query_limit
             if has_next_page:
@@ -341,7 +340,7 @@ def _build_cursor_paginated_result(
 
         elif is_end_cursor:
             index = -1
-            reference_column = reference_cursor.column
+            reference_column = cursor_reference.column
             last_found_cursor_value = getattr(result_items[index], reference_column)
             """
             Currently we support only numeric or string model values for cursors,
@@ -352,17 +351,17 @@ def _build_cursor_paginated_result(
             9 < 10 but '9' > '10' 
             """
             if isinstance(last_found_cursor_value, str):
-                has_next_page = last_found_cursor_value >= reference_cursor.value
+                has_next_page = last_found_cursor_value >= cursor_reference.value
             else:
-                has_next_page = last_found_cursor_value >= float(reference_cursor.value)
+                has_next_page = last_found_cursor_value >= float(cursor_reference.value)
             if has_next_page:
                 result_items.pop(index)
             has_previous_page = len(result_items) > sanitised_query_limit
             if has_previous_page:
                 result_items = result_items[-sanitised_query_limit:]
         else:
             index = 0
-            reference_column = reference_cursor.column
+            reference_column = cursor_reference.column
             first_found_cursor_value = getattr(result_items[index], reference_column)
             """
             Currently we support only numeric or string model values for cursors,
@@ -373,10 +372,10 @@ def _build_cursor_paginated_result(
             9 < 10 but '9' > '10' 
             """
             if isinstance(first_found_cursor_value, str):
-                has_previous_page = first_found_cursor_value <= reference_cursor.value
+                has_previous_page = first_found_cursor_value <= cursor_reference.value
             else:
                 has_previous_page = first_found_cursor_value <= float(
-                    reference_cursor.value
+                    cursor_reference.value
                 )
             if has_previous_page:
                 result_items.pop(index)
@@ -389,28 +388,17 @@ def _build_cursor_paginated_result(
         result_structure.page_info.has_previous_page = has_previous_page
 
         if result_items:
-            result_structure.page_info.start_cursor = self.encode_cursor(
-                Cursor(
-                    column=reference_column,
-                    value=getattr(result_items[0], reference_column),
-                )
+            result_structure.page_info.start_cursor = CursorReference(
+                column=reference_column,
+                value=getattr(result_items[0], reference_column),
             )
-            result_structure.page_info.end_cursor = self.encode_cursor(
-                Cursor(
-                    column=reference_column,
-                    value=getattr(result_items[-1], reference_column),
-                )
+            result_structure.page_info.end_cursor = CursorReference(
+                column=reference_column,
+                value=getattr(result_items[-1], reference_column),
             )
 
         return result_structure
 
-    def encode_cursor(self, cursor: Cursor) -> str:
-        serialised_cursor = cursor.json()
-        return b64encode(serialised_cursor.encode()).decode()
-
-    def decode_cursor(self, cursor: str) -> Cursor:
-        return Cursor.parse_raw(b64decode(cursor))
-
     def _model_pk(self) -> str:
         primary_keys = inspect(self._model).primary_key  # type: ignore
         if len(primary_keys) > 1:

sqlalchemy_bind_manager/_repository/common.py

@@ -21,20 +21,20 @@ class PaginatedResult(GenericModel, Generic[MODEL]):
     page_info: PageInfo
 
 
+class CursorReference(BaseModel):
+    column: str
+    value: str
+
+
 class CursorPageInfo(BaseModel):
     items_per_page: int
     total_items: int
     has_next_page: bool = False
     has_previous_page: bool = False
-    start_cursor: Union[str, None] = None
-    end_cursor: Union[str, None] = None
+    start_cursor: Union[CursorReference, None] = None
+    end_cursor: Union[CursorReference, None] = None
 
 
 class CursorPaginatedResult(GenericModel, Generic[MODEL]):
     items: List[MODEL]
     page_info: CursorPageInfo
-
-
-class Cursor(BaseModel):
-    column: str
-    value: str

sqlalchemy_bind_manager/_repository/sync.py

@@ -21,7 +21,13 @@
     BaseRepository,
     SortDirection,
 )
-from .common import MODEL, PRIMARY_KEY, Cursor, CursorPaginatedResult, PaginatedResult
+from .common import (
+    MODEL,
+    PRIMARY_KEY,
+    CursorPaginatedResult,
+    CursorReference,
+    PaginatedResult,
+)
 
 
 class SQLAlchemyRepository(Generic[MODEL], BaseRepository[MODEL], ABC):
@@ -168,7 +174,7 @@ def paginated_find(
     def cursor_paginated_find(
         self,
         items_per_page: int,
-        reference_cursor: Union[Cursor, str, None] = None,
+        cursor_reference: Union[CursorReference, None] = None,
         is_end_cursor: bool = False,
         search_params: Union[None, Mapping[str, Any]] = None,
     ) -> CursorPaginatedResult[MODEL]:
@@ -189,14 +195,11 @@ def cursor_paginated_find(
         :return: A collection of models
         :rtype: List
         """
-        if isinstance(reference_cursor, str):
-            reference_cursor = self.decode_cursor(reference_cursor)
-
         find_stmt = self._find_query(search_params)
 
         paginated_stmt = self._cursor_paginated_query(
             find_stmt,
-            reference_cursor=reference_cursor,
+            cursor_reference=cursor_reference,
             is_end_cursor=is_end_cursor,
             per_page=items_per_page,
         )
@@ -211,6 +214,6 @@ def cursor_paginated_find(
                 result_items=result_items,
                 total_items_count=total_items_count,
                 items_per_page=items_per_page,
-                reference_cursor=reference_cursor,
+                cursor_reference=cursor_reference,
                 is_end_cursor=is_end_cursor,
             )

sqlalchemy_bind_manager/protocols.py

@@ -14,8 +14,8 @@
     PRIMARY_KEY,
 )
 from sqlalchemy_bind_manager.repository import (
-    Cursor,
     CursorPaginatedResult,
+    CursorReference,
     PaginatedResult,
     SortDirection,
 )
@@ -54,7 +54,7 @@ async def paginated_find(
     async def cursor_paginated_find(
         self,
         items_per_page: int,
-        reference_cursor: Union[Cursor, str, None] = None,
+        cursor_reference: Union[CursorReference, None] = None,
         is_end_cursor: bool = False,
         search_params: Union[None, Mapping[str, Any]] = None,
     ) -> CursorPaginatedResult[MODEL]:
@@ -94,7 +94,7 @@ def paginated_find(
     def cursor_paginated_find(
         self,
         items_per_page: int,
-        reference_cursor: Union[Cursor, str, None] = None,
+        cursor_reference: Union[CursorReference, None] = None,
         is_end_cursor: bool = False,
         search_params: Union[None, Mapping[str, Any]] = None,
     ) -> CursorPaginatedResult[MODEL]:

sqlalchemy_bind_manager/repository.py

@@ -1,6 +1,6 @@
 from ._repository import (
-    Cursor,
     CursorPaginatedResult,
+    CursorReference,
     PaginatedResult,
     SortDirection,
     SQLAlchemyAsyncRepository,