add OffsetPaginationExtension

Author: vincentsarago

setup.py

@@ -10,9 +10,9 @@
     "orjson",
     "pydantic",
     "stac_pydantic==3.1.*",
-    "stac-fastapi.api~=3.0.2",
-    "stac-fastapi.extensions~=3.0.2",
-    "stac-fastapi.types~=3.0.2",
+    "stac-fastapi.api~=3.0.3",
+    "stac-fastapi.extensions~=3.0.3",
+    "stac-fastapi.types~=3.0.3",
     "asyncpg",
     "buildpg",
     "brotli_asgi",

stac_fastapi/pgstac/app.py

@@ -19,6 +19,7 @@
 from stac_fastapi.extensions.core import (
     FieldsExtension,
     FilterExtension,
+    OffsetPaginationExtension,
     SortExtension,
     TokenPaginationExtension,
     TransactionExtension,
@@ -55,6 +56,9 @@
     "sort": SortExtension(),
     "fields": FieldsExtension(),
     "filter": FilterExtension(client=FiltersClient()),
+    # NOTE: there is no conformance class for the Pagination extension
+    # so `CollectionSearchExtension.from_extensions` will raise a warning
+    "pagination": OffsetPaginationExtension(),
 }
 
 enabled_extensions = (

stac_fastapi/pgstac/core.py

@@ -47,8 +47,8 @@ async def all_collections(  # noqa: C901
         bbox: Optional[BBox] = None,
         datetime: Optional[DateTimeType] = None,
         limit: Optional[int] = None,
+        offset: Optional[int] = None,
         query: Optional[str] = None,
-        token: Optional[str] = None,
         fields: Optional[List[str]] = None,
         sortby: Optional[str] = None,
         filter: Optional[str] = None,
@@ -69,7 +69,7 @@ async def all_collections(  # noqa: C901
         base_args = {
             "bbox": bbox,
             "limit": limit,
-            "token": token,
+            "offset": offset,
             "query": orjson.loads(unquote_plus(query)) if query else query,
         }
 
@@ -91,16 +91,16 @@ async def all_collections(  # noqa: C901
             )
             collections_result: Collections = await conn.fetchval(q, *p)
 
-        next: Optional[Dict[str, Any]] = None
-        prev: Optional[Dict[str, Any]] = None
+        next_link: Optional[Dict[str, Any]] = None
+        prev_link: Optional[Dict[str, Any]] = None
         if links := collections_result.get("links"):
-            next = None
-            prev = None
+            next_link = None
+            prev_link = None
             for link in links:
                 if link["rel"] == "next":
-                    next = link
+                    next_link = link
                 elif link["rel"] == "prev":
-                    prev = link
+                    prev_link = link
 
         linked_collections: List[Collection] = []
         collections = collections_result["collections"]
@@ -125,10 +125,13 @@ async def all_collections(  # noqa: C901
 
                 linked_collections.append(coll)
 
+        if not collections:
+            next_link = None
+
         links = await CollectionSearchPagingLinks(
             request=request,
-            next=next,
-            prev=prev,
+            next=next_link,
+            prev=prev_link,
         ).get_links()
 
         return Collections(

stac_fastapi/pgstac/models/links.py

@@ -191,16 +191,14 @@ def link_next(self) -> Optional[Dict[str, Any]]:
 
                 # if next link is equal to this link, skip it
                 if href == self.url:
-                    print(self.request.body())
                     return None
 
-                link = {
+                return {
                     "rel": Relations.next.value,
                     "type": MimeTypes.geojson.value,
                     "method": method,
                     "href": href,
                 }
-                return link
 
         return None
 
@@ -217,6 +215,7 @@ def link_prev(self):
                 # if prev link is equal to this link, skip it
                 if href == self.url:
                     return None
+
                 return {
                     "rel": Relations.previous.value,
                     "type": MimeTypes.geojson.value,

tests/conftest.py

@@ -26,6 +26,7 @@
     CollectionSearchExtension,
     FieldsExtension,
     FilterExtension,
+    OffsetPaginationExtension,
     SortExtension,
     TokenPaginationExtension,
     TransactionExtension,
@@ -140,10 +141,12 @@ def api_client(request, database):
         SortExtension(),
         FieldsExtension(),
         FilterExtension(client=FiltersClient()),
+        OffsetPaginationExtension(),
     ]
-    collection_search_extension = CollectionSearchExtension.from_extensions(
-        collection_extensions
-    )
+    with pytest.warns(UserWarning):
+        collection_search_extension = CollectionSearchExtension.from_extensions(
+            collection_extensions
+        )
 
     items_get_request_model = create_request_model(
         model_name="ItemCollectionUri",

tests/resources/test_collection.py

@@ -309,19 +309,127 @@ async def test_get_collections_search(
 async def test_get_collections_search_limit_offset(
     app_client, load_test_collection, load_test2_collection
 ):
+    resp = await app_client.get("/collections")
+    cols = resp.json()["collections"]
+    assert len(cols) == 2
+    links = resp.json()["links"]
+    assert len(links) == 2
+    assert {"root", "self"} == {link["rel"] for link in links}
+
+    ###################
+    # limit should be positive
+    resp = await app_client.get("/collections", params={"limit": 0})
+    assert resp.status_code == 400
+
+    ###################
+    # limit=1, should have a `next` link
     resp = await app_client.get(
         "/collections",
         params={"limit": 1},
     )
-    response = resp.json()
-    assert len(response["collections"]) == 1
-    assert response["collections"][0]["id"] == load_test_collection["id"]
-
-    # check next link
-    next_link = [link["href"] for link in response["links"] if link["rel"] == "next"][0]
-    next_url = next_link.replace(str(app_client.base_url), "")
-    next_resp = await app_client.get(next_url)
-    next_response = next_resp.json()
-
-    assert len(next_response["collections"]) == 1
-    assert next_response["collections"][0]["id"] == load_test2_collection.id
+    cols = resp.json()["collections"]
+    links = resp.json()["links"]
+    assert len(cols) == 1
+    assert cols[0]["id"] == load_test_collection["id"]
+    assert len(links) == 3
+    assert {"root", "self", "next"} == {link["rel"] for link in links}
+    next_link = list(filter(lambda link: link["rel"] == "next", links))[0]
+    assert next_link["href"].endswith("?limit=1&offset=1")
+
+    ###################
+    # limit=2, there should not be a next link
+    resp = await app_client.get(
+        "/collections",
+        params={"limit": 2},
+    )
+    cols = resp.json()["collections"]
+    links = resp.json()["links"]
+    assert len(cols) == 2
+    assert cols[0]["id"] == load_test_collection["id"]
+    assert cols[1]["id"] == load_test2_collection.id
+    # TODO: check with pgstac
+    # assert len(links) == 2
+    # assert {"root", "self"} == {link["rel"] for link in links}
+
+    ###################
+    # limit=3, there should not be a next/previous link
+    resp = await app_client.get(
+        "/collections",
+        params={"limit": 3},
+    )
+    cols = resp.json()["collections"]
+    links = resp.json()["links"]
+    assert len(cols) == 2
+    assert cols[0]["id"] == load_test_collection["id"]
+    assert cols[1]["id"] == load_test2_collection.id
+    assert len(links) == 2
+    assert {"root", "self"} == {link["rel"] for link in links}
+
+    ###################
+    # offset=3, because there are 2 collections, we should not have `next` or `prev` links
+    resp = await app_client.get(
+        "/collections",
+        params={"offset": 3},
+    )
+    cols = resp.json()["collections"]
+    links = resp.json()["links"]
+    assert len(cols) == 0
+    assert len(links) == 2
+    assert {"root", "self"} == {link["rel"] for link in links}
+
+    ###################
+    # offset=3,limit=1
+    resp = await app_client.get(
+        "/collections",
+        params={"limit": 1, "offset": 3},
+    )
+    cols = resp.json()["collections"]
+    links = resp.json()["links"]
+    assert len(cols) == 0
+    assert len(links) == 3
+    assert {"root", "self", "previous"} == {link["rel"] for link in links}
+    prev_link = list(filter(lambda link: link["rel"] == "previous", links))[0]
+    assert prev_link["href"].endswith("?limit=1&offset=2")
+
+    # ###################
+    # # offset=3,limit=2
+    # resp = await app_client.get(
+    #     "/collections",
+    #     params={"limit": 2,"offset": 3},
+    # )
+    # cols = resp.json()["collections"]
+    # links = resp.json()["links"]
+    # assert len(cols) == 0
+    # assert len(links) == 3
+    # assert {"root", "self", "previous"} == {link["rel"] for link in links}
+    # prev_link = list(filter(lambda link: link["rel"] == "previous", links))[0]
+    # assert prev_link["href"].endswith("?limit=1&offset=2")
+
+    ###################
+    # offset=1, should have a `previous` link
+    resp = await app_client.get(
+        "/collections",
+        params={"offset": 1},
+    )
+    cols = resp.json()["collections"]
+    links = resp.json()["links"]
+    assert len(cols) == 1
+    assert cols[0]["id"] == load_test2_collection.id
+    # TODO: Check with pgstac
+    # assert len(links) == 3
+    # assert {"root", "self", "previous"} == {link["rel"] for link in links}
+    # prev_link = list(filter(lambda link: link["rel"] == "previous", links))[0]
+    # assert prev_link["href"].endswith("?offset=0")
+
+    ###################
+    # offset=0, should not have next/previous link
+    resp = await app_client.get(
+        "/collections",
+        params={"offset": 0},
+    )
+    cols = resp.json()["collections"]
+    links = resp.json()["links"]
+    assert len(cols) == 2
+    # TODO: Check with pgstac
+    # assert len(links) == 2
+    # assert {"root", "self"} == {link["rel"] for link in links}