fix: rpc method (#156)

* refactor: move rpc method to PostgrestRpcBuilder

* feat: support void rpc function

* fix: rpc unit tests

* chore: remove rpc from PostgrestQueryBuilder

* fix: return PostgrestRpcBuilder

* chore: add options param description

* fix: Stored Procedure rpc not support HEAD request

* fix: store procedure unit tests

* chore: remove unused param

* chore: create stored procedure returns void unit test

* fix: fetch response and error parsing

* chore: clean up

* refactor: format code

* chore: add comment

* chore: revert try/catch error

Author: phamhieu

src/PostgrestClient.ts

@@ -1,4 +1,5 @@
 import PostgrestQueryBuilder from './lib/PostgrestQueryBuilder'
+import PostgrestRpcBuilder from './lib/PostgrestRpcBuilder'
 import PostgrestTransformBuilder from './lib/PostgrestTransformBuilder'
 
 export default class PostgrestClient {
@@ -47,11 +48,21 @@ export default class PostgrestClient {
    *
    * @param fn  The function name to call.
    * @param params  The parameters to pass to the function call.
+   * @param count  Count algorithm to use to count rows in a table.
    */
-  rpc<T = any>(fn: string, params?: object): PostgrestTransformBuilder<T> {
+  rpc<T = any>(
+    fn: string,
+    params?: object,
+    {
+      count = null,
+    }: {
+      count?: null | 'exact' | 'planned' | 'estimated'
+    } = {}
+  ): PostgrestTransformBuilder<T> {
     const url = `${this.url}/rpc/${fn}`
-    return new PostgrestQueryBuilder<T>(url, { headers: this.headers, schema: this.schema }).rpc(
-      params
-    )
+    return new PostgrestRpcBuilder<T>(url, {
+      headers: this.headers,
+      schema: this.schema,
+    }).rpc(params, { count })
   }
 }

src/lib/PostgrestQueryBuilder.ts

@@ -1,6 +1,5 @@
 import { PostgrestBuilder } from './types'
 import PostgrestFilterBuilder from './PostgrestFilterBuilder'
-import PostgrestTransformBuilder from './PostgrestTransformBuilder'
 
 export default class PostgrestQueryBuilder<T> extends PostgrestBuilder<T> {
   constructor(
@@ -142,26 +141,4 @@ export default class PostgrestQueryBuilder<T> extends PostgrestBuilder<T> {
     this.headers['Prefer'] = prefersHeaders.join(',')
     return new PostgrestFilterBuilder(this)
   }
-
-  /** @internal */
-  rpc(
-    params?: object,
-    {
-      head = false,
-      count = null,
-    }: {
-      head?: boolean
-      count?: null | 'exact' | 'planned' | 'estimated'
-    } = {}
-  ): PostgrestTransformBuilder<T> {
-    this.method = 'POST'
-    this.body = params
-    if (count) {
-      this.headers['Prefer'] = `count=${count}`
-    }
-    if (head) {
-      this.method = 'HEAD'
-    }
-    return new PostgrestTransformBuilder(this)
-  }
 }

src/lib/PostgrestRpcBuilder.ts

@@ -0,0 +1,36 @@
+import { PostgrestBuilder } from './types'
+import PostgrestTransformBuilder from './PostgrestTransformBuilder'
+
+export default class PostgrestRpcBuilder<T> extends PostgrestBuilder<T> {
+  constructor(
+    url: string,
+    { headers = {}, schema }: { headers?: { [key: string]: string }; schema?: string } = {}
+  ) {
+    super({} as PostgrestBuilder<T>)
+    this.url = new URL(url)
+    this.headers = { ...headers }
+    this.schema = schema
+  }
+
+  /**
+   * Perform a stored procedure call.
+   */
+  rpc(
+    params?: object,
+    {
+      count = null,
+    }: {
+      count?: null | 'exact' | 'planned' | 'estimated'
+    } = {}
+  ): PostgrestTransformBuilder<T> {
+    this.method = 'POST'
+    this.body = params
+
+    if (count) {
+      if (this.headers['Prefer'] !== undefined) this.headers['Prefer'] += `,count=${count}`
+      else this.headers['Prefer'] = `count=${count}`
+    }
+
+    return new PostgrestTransformBuilder(this)
+  }
+}

src/lib/types.ts

@@ -83,32 +83,26 @@ export abstract class PostgrestBuilder<T> implements PromiseLike<PostgrestRespon
       body: JSON.stringify(this.body),
     })
       .then(async (res) => {
-        let error, data, count
+        let error = null
+        let data = null
+        let count = null
+
         if (res.ok) {
-          error = null
-          if (this.method !== 'HEAD') {
-            const isReturnMinimal = this.headers['Prefer']?.split(',').includes('return=minimal')
-            data = isReturnMinimal ? null : await res.json()
-          } else {
-            data = null
+          const isReturnMinimal = this.headers['Prefer']?.split(',').includes('return=minimal')
+          if (this.method !== 'HEAD' && !isReturnMinimal) {
+            const text = await res.text()
+            if (text && text !== '') data = JSON.parse(text)
           }
 
           const countHeader = this.headers['Prefer']?.match(/count=(exact|planned|estimated)/)
-          if (countHeader) {
-            const contentRange = res.headers.get('content-range')?.split('/')
-            if (contentRange && contentRange.length > 1) {
-              count = parseInt(contentRange[1])
-            } else {
-              count = null
-            }
-          } else {
-            count = null
+          const contentRange = res.headers.get('content-range')?.split('/')
+          if (countHeader && contentRange && contentRange.length > 1) {
+            count = parseInt(contentRange[1])
           }
         } else {
           error = await res.json()
-          data = null
-          count = null
         }
+
         const postgrestResponse: PostgrestResponse<T> = {
           error,
           data,

test/__snapshots__/index.test.ts.snap

@@ -2883,35 +2883,25 @@ Object {
 }
 `;
 
-exports[`stored procedure with count: 'exact' 1`] = `
+exports[`stored procedure returns void 1`] = `
 Object {
   "body": null,
   "count": null,
   "data": null,
-  "error": Object {
-    "code": "42883",
-    "details": null,
-    "hint": "No function matches the given name and argument types. You might need to add explicit type casts.",
-    "message": "function public.get_status(count => text, name_param => text) does not exist",
-  },
-  "status": 404,
-  "statusText": "Not Found",
+  "error": null,
+  "status": 200,
+  "statusText": "OK",
 }
 `;
 
-exports[`stored procedure with count: 'exact', head: true 1`] = `
+exports[`stored procedure with count: 'exact' 1`] = `
 Object {
-  "body": null,
-  "count": null,
-  "data": null,
-  "error": Object {
-    "code": "42883",
-    "details": null,
-    "hint": "No function matches the given name and argument types. You might need to add explicit type casts.",
-    "message": "function public.get_status(count => text, head => text, name_param => text) does not exist",
-  },
-  "status": 404,
-  "statusText": "Not Found",
+  "body": "ONLINE",
+  "count": 1,
+  "data": "ONLINE",
+  "error": null,
+  "status": 200,
+  "statusText": "OK",
 }
 `;
 

test/basic.ts

@@ -13,6 +13,11 @@ test('stored procedure', async () => {
   expect(res).toMatchSnapshot()
 })
 
+test('stored procedure returns void', async () => {
+  const res = await postgrest.rpc('void_func')
+  expect(res).toMatchSnapshot()
+})
+
 test('custom headers', async () => {
   const postgrest = new PostgrestClient(REST_URL, { headers: { apikey: 'foo' } })
   expect((postgrest.from('users').select() as any).headers['apikey']).toEqual('foo')
@@ -171,16 +176,7 @@ test('select with count:exact', async () => {
 })
 
 test("stored procedure with count: 'exact'", async () => {
-  const res = await postgrest.rpc('get_status', { name_param: 'supabot', count: 'exact' })
-  expect(res).toMatchSnapshot()
-})
-
-test("stored procedure with count: 'exact', head: true", async () => {
-  const res = await postgrest.rpc('get_status', {
-    name_param: 'supabot',
-    count: 'exact',
-    head: true,
-  })
+  const res = await postgrest.rpc('get_status', { name_param: 'supabot'}, {count: 'exact' })
   expect(res).toMatchSnapshot()
 })
 

test/db/00-schema.sql

@@ -47,6 +47,10 @@ RETURNS TABLE(username text, status user_status) AS $$
   SELECT username, status from users WHERE username=name_param;
 $$ LANGUAGE SQL IMMUTABLE;
 
+CREATE FUNCTION public.void_func() 
+RETURNS void AS $$
+$$ LANGUAGE SQL;
+
 -- SECOND SCHEMA USERS
 CREATE TYPE personal.user_status AS ENUM ('ONLINE', 'OFFLINE');
 CREATE TABLE personal.users(