Merge pull request #9 from supabase/feature/rpc

Add support for rpc and switching schema

Author: soedirgo

rustfmt.toml

@@ -0,0 +1 @@
+"edition" = "2018"

src/builder.rs

@@ -12,27 +12,29 @@ macro_rules! filter {
     }
 }
 
+#[derive(Default)]
 pub struct Builder {
     method: Method,
     url: String,
+    schema: Option<String>,
     queries: Vec<(String, String)>,
+    // TODO: Maybe change to HeaderMap in the future
     headers: Vec<(String, String)>,
     body: Option<String>,
+    is_rpc: bool,
 }
 
 // TODO: Complex filters (not, and, or)
-// TODO: Switching schema
 // TODO: Exact, planned, estimated count (HEAD verb)
 // TODO: Response format
 // TODO: Embedded resources
 impl Builder {
-    pub fn new(url: &str) -> Self {
+    pub fn new(url: &str, schema: Option<String>) -> Self {
         Builder {
             method: Method::GET,
             url: url.to_string(),
-            queries: Vec::new(),
-            headers: Vec::new(),
-            body: None,
+            schema,
+            ..Default::default()
         }
     }
 
@@ -96,6 +98,7 @@ impl Builder {
         self.method = Method::POST;
         self.headers.push((
             "Prefer".to_string(),
+            // Maybe check if this works as intended...
             "return=representation; resolution=merge-duplicates".to_string(),
         ));
         self.body = Some(body.to_string());
@@ -127,21 +130,38 @@ impl Builder {
         self
     }
 
-    pub fn in_set(mut self, column: &str, param: &str) -> Self {
-        self.queries
-            .push((column.to_string(), format!("in.{}", param)));
-        self
-    }
-
     // It's unfortunate that `in` is a keyword, otherwise it'd belong in the
     // collection of filters below
     filter!(
         eq, gt, gte, lt, lte, neq, like, ilike, is, fts, plfts, phfts, wfts, cs, cd, ov, sl, sr,
         nxr, nxl, adj, not
     );
 
+    pub fn in_(mut self, column: &str, param: &str) -> Self {
+        self.queries
+            .push((column.to_string(), format!("in.{}", param)));
+        self
+    }
+
+    pub fn rpc(mut self, params: &str) -> Self {
+        self.method = Method::POST;
+        self.body = Some(params.to_string());
+        self.is_rpc = true;
+        self
+    }
+
     pub async fn execute(self) -> Result<Response, Error> {
-        let mut req = Client::new().request(self.method, &self.url);
+        let mut req = Client::new().request(self.method.clone(), &self.url);
+        if let Some(schema) = self.schema {
+            // NOTE: Upstream bug: RPC only works with Accept-Profile
+            // Will change when upstream is fixed
+            let key = if !self.is_rpc || self.method == Method::GET || self.method == Method::HEAD {
+                "Accept-Profile"
+            } else {
+                "Content-Profile"
+            };
+            req = req.header(key, schema);
+        }
         for (k, v) in &self.headers {
             req = req.header(k, v);
         }

src/lib.rs

@@ -1,21 +1,32 @@
-use builder::Builder;
-
 mod builder;
 
+use builder::Builder;
+
 pub struct Postgrest {
-    rest_url: String,
+    url: String,
+    schema: Option<String>,
 }
 
 impl Postgrest {
-    pub fn new(rest_url: &str) -> Postgrest {
+    pub fn new(url: &str) -> Self {
         Postgrest {
-            rest_url: rest_url.to_string(),
+            url: url.to_string(),
+            schema: None,
         }
     }
 
+    pub fn schema(mut self, schema: &str) -> Self {
+        self.schema = Some(schema.to_string());
+        self
+    }
+
     pub fn from(&self, table: &str) -> Builder {
-        let mut url = self.rest_url.clone();
-        url = format!("{}/{}", url, table);
-        Builder::new(&url)
+        let url = format!("{}/{}", self.url, table);
+        Builder::new(&url, self.schema.clone())
+    }
+
+    pub fn rpc(&self, function: &str, params: &str) -> Builder {
+        let url = format!("{}/rpc/{}", self.url, function);
+        Builder::new(&url, self.schema.clone()).rpc(params)
     }
 }