Merge branch 'avallete/fix-add-returns-to-builder' into avallete/feat-add-overrideTypes-method

Author: avallete

Diff for: jest.config.js

@@ -1,4 +1,5 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
+  collectCoverageFrom: ['src/**/*'],
 }

Diff for: src/PostgrestBuilder.ts

@@ -224,6 +224,7 @@ export default abstract class PostgrestBuilder<Result, ThrowOnError extends bool
    * @deprecated Use overrideTypes<yourType, { merge: false }>() method at the end of your call chain instead
    */
   returns<NewResult>(): PostgrestBuilder<CheckMatchingArrayTypes<Result, NewResult>, ThrowOnError> {
+    /* istanbul ignore next */
     return this as unknown as PostgrestBuilder<
       CheckMatchingArrayTypes<Result, NewResult>,
       ThrowOnError

Diff for: src/PostgrestTransformBuilder.ts

@@ -307,7 +307,7 @@ export default class PostgrestTransformBuilder<
    * Override the type of the returned `data`.
    *
    * @typeParam NewResult - The new result type to override with
-   * @deprecated Use overrideTypes<yourType, { partial: false }>() method at the end of your call chain instead
+   * @deprecated Use overrideTypes<yourType, { merge: false }>() method at the end of your call chain instead
    */
   returns<NewResult>(): PostgrestTransformBuilder<
     Schema,

Diff for: test/basic.ts

@@ -161,6 +161,42 @@ test('basic select overrideTypes from builder', async () => {
       "status": 200,
       "statusText": "OK",
     }
+  `);
+})
+
+test('basic select with maybeSingle yielding more than one result', async () => {
+  const res = await postgrest.from('users').select().maybeSingle()
+  expect(res).toMatchInlineSnapshot(`
+    Object {
+      "count": null,
+      "data": null,
+      "error": Object {
+        "code": "PGRST116",
+        "details": "Results contain 5 rows, application/vnd.pgrst.object+json requires 1 row",
+        "hint": null,
+        "message": "JSON object requested, multiple (or no) rows returned",
+      },
+      "status": 406,
+      "statusText": "Not Acceptable",
+    }
+  `)
+})
+
+test('basic select with single yielding more than one result', async () => {
+  const res = await postgrest.from('users').select().single()
+  expect(res).toMatchInlineSnapshot(`
+    Object {
+      "count": null,
+      "data": null,
+      "error": Object {
+        "code": "PGRST116",
+        "details": "The result contains 5 rows",
+        "hint": null,
+        "message": "JSON object requested, multiple (or no) rows returned",
+      },
+      "status": 406,
+      "statusText": "Not Acceptable",
+    }
   `)
 })
 
@@ -2011,3 +2047,187 @@ test('join on 1-1 relation with nullables', async () => {
     }
   `)
 })
+
+test('custom fetch function', async () => {
+  const customFetch = jest.fn().mockImplementation(() =>
+    Promise.resolve({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      text: () => Promise.resolve('[]'),
+    })
+  )
+
+  const postgrestWithCustomFetch = new PostgrestClient<Database>(REST_URL, {
+    fetch: customFetch,
+  })
+
+  await postgrestWithCustomFetch.from('users').select()
+
+  expect(customFetch).toHaveBeenCalledWith(
+    expect.stringContaining(REST_URL),
+    expect.objectContaining({
+      method: 'GET',
+      headers: expect.any(Object),
+    })
+  )
+})
+
+test('handles undefined global fetch', async () => {
+  // Store original fetch
+  const originalFetch = globalThis.fetch
+  // Delete global fetch to simulate environments where it's undefined
+  delete (globalThis as any).fetch
+
+  try {
+    const postgrestClient = new PostgrestClient<Database>(REST_URL)
+    const result = await postgrestClient.from('users').select()
+    expect(result).toMatchInlineSnapshot(`
+          Object {
+            "count": null,
+            "data": Array [
+              Object {
+                "age_range": "[1,2)",
+                "catchphrase": "'cat' 'fat'",
+                "data": null,
+                "status": "ONLINE",
+                "username": "supabot",
+              },
+              Object {
+                "age_range": "[25,35)",
+                "catchphrase": "'bat' 'cat'",
+                "data": null,
+                "status": "OFFLINE",
+                "username": "kiwicopple",
+              },
+              Object {
+                "age_range": "[25,35)",
+                "catchphrase": "'bat' 'rat'",
+                "data": null,
+                "status": "ONLINE",
+                "username": "awailas",
+              },
+              Object {
+                "age_range": "[20,30)",
+                "catchphrase": "'json' 'test'",
+                "data": Object {
+                  "foo": Object {
+                    "bar": Object {
+                      "nested": "value",
+                    },
+                    "baz": "string value",
+                  },
+                },
+                "status": "ONLINE",
+                "username": "jsonuser",
+              },
+              Object {
+                "age_range": "[20,30)",
+                "catchphrase": "'fat' 'rat'",
+                "data": null,
+                "status": "ONLINE",
+                "username": "dragarcia",
+              },
+            ],
+            "error": null,
+            "status": 200,
+            "statusText": "OK",
+          }
+      `)
+    // Test passes if we reach here without errors, as it means nodeFetch was used
+  } finally {
+    // Restore original fetch
+    globalThis.fetch = originalFetch
+  }
+})
+
+test('handles array error with 404 status', async () => {
+  // Mock the fetch response to return an array error with 404
+  const customFetch = jest.fn().mockImplementation(() =>
+    Promise.resolve({
+      ok: false,
+      status: 404,
+      statusText: 'Not Found',
+      text: () => Promise.resolve('[]'),
+    })
+  )
+
+  const postgrestWithCustomFetch = new PostgrestClient<Database>(REST_URL, {
+    fetch: customFetch,
+  })
+
+  const res = await postgrestWithCustomFetch.from('users').select()
+
+  expect(res).toMatchInlineSnapshot(`
+      Object {
+        "count": null,
+        "data": Array [],
+        "error": null,
+        "status": 200,
+        "statusText": "OK",
+      }
+    `)
+})
+
+test('handles empty body with 404 status', async () => {
+  // Mock the fetch response to return an empty body with 404
+  const customFetch = jest.fn().mockImplementation(() =>
+    Promise.resolve({
+      ok: false,
+      status: 404,
+      statusText: 'Not Found',
+      text: () => Promise.resolve(''),
+    })
+  )
+
+  const postgrestWithCustomFetch = new PostgrestClient<Database>(REST_URL, {
+    fetch: customFetch,
+  })
+
+  const res = await postgrestWithCustomFetch.from('users').select()
+
+  expect(res).toMatchInlineSnapshot(`
+      Object {
+        "count": null,
+        "data": null,
+        "error": null,
+        "status": 204,
+        "statusText": "No Content",
+      }
+    `)
+})
+
+test('maybeSingle handles zero rows error', async () => {
+  const customFetch = jest.fn().mockImplementation(() =>
+    Promise.resolve({
+      ok: false,
+      status: 406,
+      statusText: 'Not Acceptable',
+      text: () =>
+        Promise.resolve(
+          JSON.stringify({
+            code: 'PGRST116',
+            details: '0 rows',
+            hint: null,
+            message: 'JSON object requested, multiple (or no) rows returned',
+          })
+        ),
+    })
+  )
+
+  const postgrestWithCustomFetch = new PostgrestClient<Database>(REST_URL, {
+    fetch: customFetch,
+  })
+
+  const res = await postgrestWithCustomFetch.from('users').select().maybeSingle()
+
+  expect(res).toMatchInlineSnapshot(`
+    Object {
+      "count": null,
+      "data": null,
+      "error": null,
+      "status": 200,
+      "statusText": "OK",
+    }
+  `)
+})