Complete basic features

Author: lqmanh

TODO.md

@@ -1 +1,5 @@
 ## ROADMAP
+
+- [ ] Multi-criteria ordering
+- [ ] Exact match filtering
+- [ ] OR filter

postgrest_py/__init__.py

@@ -0,0 +1 @@
+from postgrest_py.client import Client

postgrest_py/client.py

@@ -13,24 +13,29 @@ def __init__(self, base_url: str, *, schema="public") -> None:
         }
         self.session = AsyncClient(base_url=base_url, params={}, headers=headers)
 
-    async def __aenter__(self) -> Client:
+    async def __aenter__(self):
         return self
 
-    async def __aexit__(self) -> None:
+    async def __aexit__(self, exc_type, exc, tb) -> None:
         await self.aclose()
 
     async def aclose(self) -> None:
         await self.session.aclose()
 
-    def auth(self, token: str) -> Client:
+    def auth(self, token: str):
         self.session.headers["Authorization"] = f"Bearer {token}"
         return self
 
-    def schema(self, schema: str) -> Client:
+    def schema(self, schema: str):
         self.session.merge_headers(
             {"Accept-Profile": schema, "Content-Profile": schema}
         )
         return self
 
-    def fromTable(self, table: str) -> RequestBuilder:
+    def from_table(self, table: str) -> RequestBuilder:
         return RequestBuilder(self.session, f"/{table}")
+
+    def from_(self, table: str) -> RequestBuilder:
+        """Alias to Self.from_table()."""
+
+        return self.fromTable(table)

postgrest_py/request_builder.py

@@ -1,4 +1,6 @@
-from httpx import AsyncClient
+from httpx import AsyncClient, Response
+
+from postgrest_py.constants import FILTER_OPERATORS
 
 
 class RequestBuilder:
@@ -8,54 +10,148 @@ def __init__(self, session: AsyncClient, path: str) -> None:
         self.json = {}
         self.http_method = "GET"
 
-    def select(self, columns: str) -> GetRequestBuilder:
+    def select(self, columns: str):
         self.session.params["select"] = columns
         self.http_method = "GET"
         return GetRequestBuilder.from_request_builder(self)
 
-    def insert(self, json: dict, *, upsert=False) -> RequestBuilder:
+    def insert(self, json: dict, *, upsert=False):
         self.session.headers[
             "Prefer"
         ] = f"return=representation{',resolution=merge-duplicates' if upsert else ''}"
         self.json = json
         self.http_method = "POST"
         return self
 
-    def update(self, json: dict) -> RequestBuilder:
+    def update(self, json: dict):
         self.session.headers["Prefer"] = "return=representation"
         self.json = json
         self.http_method = "PATCH"
         return self
 
-    def delete(self) -> RequestBuilder:
+    def delete(self):
         self.http_method = "DELETE"
         return self
 
+    async def execute(self) -> Response:
+        r = await self.session.request(self.http_method, self.path, json=self.json)
+        return r
+
+    def filter_in(self, column: str, operator: str, criteria: str):
+        self.session.params[column] = f"{operator}.{criteria}"
+        return self
+
+    def filter(self, column: str, operator: str, criteria: str):
+        """Alias to Self.filter_in()."""
+
+        return self.filter_in(column, operator, criteria)
+
+    def filter_out(self, column: str, operator: str, criteria: str):
+        self.session.params[column] = f"not.{operator}.{criteria}"
+        return self
+
+    def not_(self, column: str, operator: str, criteria: str):
+        """Alias to Self.filter_out()."""
+
+        return self.filter_out(column, operator, criteria)
+
+    def eq(self, column: str, criteria: str):
+        return self.filter_in(column, "eq", criteria)
+
+    def neq(self, column: str, criteria: str):
+        return self.filter_in(column, "neq", criteria)
+
+    def gt(self, column: str, criteria: str):
+        return self.filter_in(column, "gt", criteria)
+
+    def lt(self, column: str, criteria: str):
+        return self.filter_in(column, "lt", criteria)
+
+    def gte(self, column: str, criteria: str):
+        return self.filter_in(column, "gte", criteria)
+
+    def lte(self, column: str, criteria: str):
+        return self.filter_in(column, "lte", criteria)
+
+    def like(self, column: str, criteria: str):
+        return self.filter_in(column, "like", criteria)
+
+    def ilike(self, column: str, criteria: str):
+        return self.filter_in(column, "ilike", criteria)
+
+    def is_(self, column: str, criteria: str):
+        return self.filter_in(column, "is", criteria)
+
+    def in_(self, column: str, criteria: str):
+        return self.filter_in(column, "in", criteria)
+
+    def fts(self, column: str, criteria: str):
+        return self.filter_in(column, "fts", criteria)
+
+    def plfts(self, column: str, criteria: str):
+        return self.filter_in(column, "plfts", criteria)
+
+    def phfts(self, column: str, criteria: str):
+        return self.filter_in(column, "phfts", criteria)
+
+    def wfts(self, column: str, criteria: str):
+        return self.filter_in(column, "wfts", criteria)
+
+    def cs(self, column: str, criteria: str):
+        return self.filter_in(column, "cs", criteria)
+
+    def cd(self, column: str, criteria: str):
+        return self.filter_in(column, "cd", criteria)
+
+    def ova(self, column: str, criteria: str):
+        return self.filter_in(column, "ova", criteria)
+
+    def ovr(self, column: str, criteria: str):
+        return self.filter_in(column, "ovr", criteria)
+
+    def sl(self, column: str, criteria: str):
+        return self.filter_in(column, "sl", criteria)
+
+    def sr(self, column: str, criteria: str):
+        return self.filter_in(column, "sr", criteria)
+
+    def nxr(self, column: str, criteria: str):
+        return self.filter_in(column, "nxr", criteria)
+
+    def nxl(self, column: str, criteria: str):
+        return self.filter_in(column, "nxl", criteria)
+
+    def adj(self, column: str, criteria: str):
+        return self.filter_in(column, "adj", criteria)
+
+    # def or_(self, column: str, criteria: str):
+    #     return self.filter_in(column, "or", criteria)
+
 
 class GetRequestBuilder(RequestBuilder):
     @classmethod
-    def from_request_builder(cls, builder: RequestBuilder) -> GetRequestBuilder:
+    def from_request_builder(cls, builder: RequestBuilder):
         result = cls(builder.session, builder.path)
         result.json = builder.json
         result.http_method = builder.http_method
         return result
 
-    def order(self, column: str, *, desc=False, nullsfirst=False) -> GetRequestBuilder:
+    def order(self, column: str, *, desc=False, nullsfirst=False):
         self.session.params[
             "order"
         ] = f"{column}{'.desc' if desc else ''}{'.nullsfirst' if nullsfirst else ''}"
         return self
 
-    def limit(self, size: int, *, start=0) -> GetRequestBuilder:
+    def limit(self, size: int, *, start=0):
         self.session.headers["Range-Unit"] = "items"
         self.session.headers["Range"] = f"{start}-{start + size - 1}"
         return self
 
-    def range(self, start: int, end: int) -> GetRequestBuilder:
+    def range(self, start: int, end: int):
         self.session.headers["Range-Unit"] = "items"
         self.session.headers["Range"] = f"{start}-{end - 1}"
         return self
 
-    def single(self) -> GetRequestBuilder:
+    def single(self):
         self.session.headers["Accept"] = "application/vnd.pgrst.object+json"
         return self