@supabase/postgrest-js 1.0.0-rc.3 → 1.0.0-rc.4

package/dist/main/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.0.0-rc.3";
+export declare const version = "1.0.0-rc.4";
 //# sourceMappingURL=version.d.ts.map

package/dist/main/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-exports.version = '1.0.0-rc.3';
+exports.version = '1.0.0-rc.4';
 //# sourceMappingURL=version.js.map

package/dist/module/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.0.0-rc.3";
+export declare const version = "1.0.0-rc.4";
 //# sourceMappingURL=version.d.ts.map

package/dist/module/version.js

@@ -1,2 +1,2 @@
-export const version = '1.0.0-rc.3';
+export const version = '1.0.0-rc.4';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/postgrest-js",
-  "version": "1.0.0-rc.3",
+  "version": "1.0.0-rc.4",
   "description": "Isomorphic PostgREST client",
   "keywords": [
     "postgrest",
@@ -11,7 +11,8 @@
   "license": "MIT",
   "author": "Supabase",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "main": "dist/main/index.js",
   "module": "dist/module/index.js",

package/src/PostgrestBuilder.ts

@@ -0,0 +1,154 @@
+import crossFetch from 'cross-fetch'
+
+import type { Fetch, PostgrestResponse } from './types'
+
+export default abstract class PostgrestBuilder<Result>
+  implements PromiseLike<PostgrestResponse<Result>>
+{
+  protected method: 'GET' | 'HEAD' | 'POST' | 'PATCH' | 'DELETE'
+  protected url: URL
+  protected headers: Record<string, string>
+  protected schema?: string
+  protected body?: unknown
+  protected shouldThrowOnError = false
+  protected signal?: AbortSignal
+  protected fetch: Fetch
+  protected allowEmpty: boolean
+
+  constructor(builder: PostgrestBuilder<Result>) {
+    this.method = builder.method
+    this.url = builder.url
+    this.headers = builder.headers
+    this.schema = builder.schema
+    this.body = builder.body
+    this.shouldThrowOnError = builder.shouldThrowOnError
+    this.signal = builder.signal
+    this.allowEmpty = builder.allowEmpty
+
+    if (builder.fetch) {
+      this.fetch = builder.fetch
+    } else if (typeof fetch === 'undefined') {
+      this.fetch = crossFetch
+    } else {
+      this.fetch = fetch
+    }
+  }
+
+  /**
+   * If there's an error with the query, throwOnError will reject the promise by
+   * throwing the error instead of returning it as part of a successful response.
+   *
+   * {@link https://github.com/supabase/supabase-js/issues/92}
+   */
+  throwOnError(): this {
+    this.shouldThrowOnError = true
+    return this
+  }
+
+  then<TResult1 = PostgrestResponse<Result>, TResult2 = never>(
+    onfulfilled?:
+      | ((value: PostgrestResponse<Result>) => TResult1 | PromiseLike<TResult1>)
+      | undefined
+      | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
+  ): PromiseLike<TResult1 | TResult2> {
+    // https://postgrest.org/en/stable/api.html#switching-schemas
+    if (typeof this.schema === 'undefined') {
+      // skip
+    } else if (['GET', 'HEAD'].includes(this.method)) {
+      this.headers['Accept-Profile'] = this.schema
+    } else {
+      this.headers['Content-Profile'] = this.schema
+    }
+    if (this.method !== 'GET' && this.method !== 'HEAD') {
+      this.headers['Content-Type'] = 'application/json'
+    }
+
+    // NOTE: Invoke w/o `this` to avoid illegal invocation error.
+    // https://github.com/supabase/postgrest-js/pull/247
+    const _fetch = this.fetch
+    let res = _fetch(this.url.toString(), {
+      method: this.method,
+      headers: this.headers,
+      body: JSON.stringify(this.body),
+      signal: this.signal,
+    }).then(async (res) => {
+      let error = undefined
+      let data = undefined
+      let count = undefined
+      let status = res.status
+      let statusText = res.statusText
+
+      if (res.ok) {
+        const isReturnMinimal = this.headers['Prefer']?.split(',').includes('return=minimal')
+        if (this.method !== 'HEAD' && !isReturnMinimal) {
+          const text = await res.text()
+          if (!text) {
+            // discard `text`
+          } else if (this.headers['Accept'] === 'text/csv') {
+            data = text
+          } else if (
+            this.headers['Accept'] &&
+            this.headers['Accept'].indexOf('application/vnd.pgrst.plan+text') !== -1
+          ) {
+            data = text
+          } else {
+            data = JSON.parse(text)
+          }
+        }
+
+        const countHeader = this.headers['Prefer']?.match(/count=(exact|planned|estimated)/)
+        const contentRange = res.headers.get('content-range')?.split('/')
+        if (countHeader && contentRange && contentRange.length > 1) {
+          count = parseInt(contentRange[1])
+        }
+      } else {
+        const body = await res.text()
+
+        try {
+          error = JSON.parse(body)
+        } catch {
+          error = {
+            message: body,
+          }
+        }
+
+        if (error && this.allowEmpty && error?.details?.includes('Results contain 0 rows')) {
+          error = undefined
+          status = 200
+          statusText = 'OK'
+        }
+
+        if (error && this.shouldThrowOnError) {
+          throw error
+        }
+      }
+
+      const postgrestResponse = {
+        error,
+        data,
+        count,
+        status,
+        statusText,
+      }
+
+      return postgrestResponse
+    })
+    if (!this.shouldThrowOnError) {
+      res = res.catch((fetchError) => ({
+        error: {
+          message: `FetchError: ${fetchError.message}`,
+          details: '',
+          hint: '',
+          code: fetchError.code || '',
+        },
+        data: undefined,
+        count: undefined,
+        status: 400,
+        statusText: 'Bad Request',
+      }))
+    }
+
+    return res.then(onfulfilled, onrejected)
+  }
+}

package/src/PostgrestClient.ts

@@ -0,0 +1,124 @@
+import PostgrestQueryBuilder from './PostgrestQueryBuilder'
+import PostgrestFilterBuilder from './PostgrestFilterBuilder'
+import PostgrestBuilder from './PostgrestBuilder'
+import { DEFAULT_HEADERS } from './constants'
+import { Fetch, GenericSchema } from './types'
+
+export default class PostgrestClient<
+  Database = any,
+  SchemaName extends string & keyof Database = 'public' extends keyof Database
+    ? 'public'
+    : string & keyof Database,
+  Schema extends GenericSchema = Database[SchemaName] extends GenericSchema
+    ? Database[SchemaName]
+    : any
+> {
+  url: string
+  headers: Record<string, string>
+  schema?: SchemaName
+  fetch?: Fetch
+
+  // TODO: Add back shouldThrowOnError once we figure out the typings
+  /**
+   * Creates a PostgREST client.
+   *
+   * @param url  URL of the PostgREST endpoint.
+   * @param headers  Custom headers.
+   * @param schema  Postgres schema to switch to.
+   */
+  constructor(
+    url: string,
+    {
+      headers = {},
+      schema,
+      fetch,
+    }: {
+      headers?: Record<string, string>
+      schema?: SchemaName
+      fetch?: Fetch
+    } = {}
+  ) {
+    this.url = url
+    this.headers = { ...DEFAULT_HEADERS, ...headers }
+    this.schema = schema
+    this.fetch = fetch
+  }
+
+  /**
+   * Perform a table operation.
+   *
+   * @param table  The table name to operate on.
+   */
+  from<
+    TableName extends string & keyof Schema['Tables'],
+    Table extends Schema['Tables'][TableName]
+  >(table: TableName): PostgrestQueryBuilder<Table>
+  from(table: string): PostgrestQueryBuilder<any>
+  from(table: string): PostgrestQueryBuilder<any> {
+    const url = new URL(`${this.url}/${table}`)
+    return new PostgrestQueryBuilder<any>(url, {
+      headers: { ...this.headers },
+      schema: this.schema,
+      fetch: this.fetch,
+    })
+  }
+
+  /**
+   * Perform a function call.
+   *
+   * @param fn  The function name to call.
+   * @param args  The parameters to pass to the function call.
+   * @param options  Named parameters.
+   */
+  rpc<
+    FunctionName extends string & keyof Schema['Functions'],
+    Function_ extends Schema['Functions'][FunctionName]
+  >(
+    fn: FunctionName,
+    args: Function_['Args'] = {},
+    {
+      head = false,
+      count,
+    }: {
+      /** When set to true, no data will be returned. */
+      head?: boolean
+      /** Count algorithm to use to count rows in a table. */
+      count?: 'exact' | 'planned' | 'estimated'
+    } = {}
+  ): PostgrestFilterBuilder<
+    Function_['Returns'] extends any[]
+      ? Function_['Returns'][number] extends Record<string, unknown>
+        ? Function_['Returns'][number]
+        : never
+      : never,
+    Function_['Returns']
+  > {
+    let method: 'HEAD' | 'POST'
+    const url = new URL(`${this.url}/rpc/${fn}`)
+    let body: unknown | undefined
+    if (head) {
+      method = 'HEAD'
+      Object.entries(args).forEach(([name, value]) => {
+        url.searchParams.append(name, `${value}`)
+      })
+    } else {
+      method = 'POST'
+      body = args
+    }
+
+    const headers = { ...this.headers }
+    if (count) {
+      headers['Prefer'] = `count=${count}`
+    }
+
+    return new PostgrestFilterBuilder({
+      method,
+      url,
+      headers,
+      schema: this.schema,
+      body,
+      fetch: this.fetch,
+      allowEmpty: false,
+    } as unknown as PostgrestBuilder<Function_['Returns']>)
+  }
+}