@ankhorage/supabase-db 1.0.2 → 1.0.4

package/src/adapter.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'bun:test';
+import { expect, test } from 'bun:test';
 
 import { createSupabaseDbAdapter } from './adapter.js';
 
@@ -12,139 +12,137 @@ interface PostRecord {
   readonly title: string;
 }
 
-describe('createSupabaseDbAdapter', () => {
-  test('maps select input to Supabase PostgREST query params', async () => {
-    const calls: FetchCall[] = [];
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      fetch: (input, init) => {
-        calls.push({ url: fetchInputToString(input), init });
-        return Promise.resolve(jsonResponse([{ id: 'post-1', title: 'Hello' }]));
-      },
-    });
-
-    const result = await adapter.select<PostRecord>({
-      table: 'posts',
-      columns: ['id', 'title'],
-      filters: [{ field: 'title', operator: 'startsWith', value: 'Hel' }],
-      sort: [{ field: 'title', direction: 'desc' }],
-      page: { limit: 10, offset: 5 },
-    });
-
-    expect(result).toEqual({ ok: true, data: [{ id: 'post-1', title: 'Hello' }] });
-    expect(calls).toHaveLength(1);
-
-    const url = new URL(calls[0]?.url ?? 'https://invalid.test');
-    expect(url.pathname).toBe('/rest/v1/posts');
-    expect(url.searchParams.get('select')).toBe('id,title');
-    expect(url.searchParams.get('title')).toBe('like.Hel*');
-    expect(url.searchParams.get('order')).toBe('title.desc');
-    expect(url.searchParams.get('limit')).toBe('10');
-    expect(url.searchParams.get('offset')).toBe('5');
-    expect(readHeader(calls[0]?.init, 'apikey')).toBe('anon');
-    expect(readHeader(calls[0]?.init, 'Prefer')).toBe('return=representation');
+test('maps select input to Supabase PostgREST query params', async () => {
+  const calls: FetchCall[] = [];
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    fetch: (input, init) => {
+      calls.push({ url: fetchInputToString(input), init });
+      return Promise.resolve(jsonResponse([{ id: 'post-1', title: 'Hello' }]));
+    },
   });
 
-  test('finds records by id', async () => {
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      fetch: () => Promise.resolve(jsonResponse([{ id: 'post-1', title: 'Hello' }])),
-    });
+  const result = await adapter.select<PostRecord>({
+    table: 'posts',
+    columns: ['id', 'title'],
+    filters: [{ field: 'title', operator: 'startsWith', value: 'Hel' }],
+    sort: [{ field: 'title', direction: 'desc' }],
+    page: { limit: 10, offset: 5 },
+  });
+
+  expect(result).toEqual({ ok: true, data: [{ id: 'post-1', title: 'Hello' }] });
+  expect(calls).toHaveLength(1);
+
+  const url = new URL(calls[0]?.url ?? 'https://invalid.test');
+  expect(url.pathname).toBe('/rest/v1/posts');
+  expect(url.searchParams.get('select')).toBe('id,title');
+  expect(url.searchParams.get('title')).toBe('like.Hel*');
+  expect(url.searchParams.get('order')).toBe('title.desc');
+  expect(url.searchParams.get('limit')).toBe('10');
+  expect(url.searchParams.get('offset')).toBe('5');
+  expect(readHeader(calls[0]?.init, 'apikey')).toBe('anon');
+  expect(readHeader(calls[0]?.init, 'Prefer')).toBe('return=representation');
+});
+
+test('finds records by id', async () => {
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    fetch: () => Promise.resolve(jsonResponse([{ id: 'post-1', title: 'Hello' }])),
+  });
+
+  const result = await adapter.findById<PostRecord>({ table: 'posts', id: 'post-1' });
 
-    const result = await adapter.findById<PostRecord>({ table: 'posts', id: 'post-1' });
+  expect(result).toEqual({ ok: true, data: { id: 'post-1', title: 'Hello' } });
+});
 
-    expect(result).toEqual({ ok: true, data: { id: 'post-1', title: 'Hello' } });
+test('normalizes empty findById result to null', async () => {
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    fetch: () => Promise.resolve(jsonResponse([])),
   });
 
-  test('normalizes empty findById result to null', async () => {
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      fetch: () => Promise.resolve(jsonResponse([])),
-    });
+  const result = await adapter.findById<PostRecord>({ table: 'posts', id: 'missing' });
 
-    const result = await adapter.findById<PostRecord>({ table: 'posts', id: 'missing' });
+  expect(result).toEqual({ ok: true, data: null });
+});
 
-    expect(result).toEqual({ ok: true, data: null });
+test('maps insert values to POST with returning representation', async () => {
+  const calls: FetchCall[] = [];
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    fetch: (input, init) => {
+      calls.push({ url: fetchInputToString(input), init });
+      return Promise.resolve(jsonResponse([{ id: 'post-1', title: 'Hello' }]));
+    },
   });
 
-  test('maps insert values to POST with returning representation', async () => {
-    const calls: FetchCall[] = [];
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      fetch: (input, init) => {
-        calls.push({ url: fetchInputToString(input), init });
-        return Promise.resolve(jsonResponse([{ id: 'post-1', title: 'Hello' }]));
-      },
-    });
-
-    const result = await adapter.insert<PostRecord>({
-      table: 'posts',
-      values: { id: 'post-1', title: 'Hello' },
-    });
-
-    expect(result.ok).toBe(true);
-    expect(calls[0]?.init?.method).toBe('POST');
-    expect(calls[0]?.init?.body).toBe(JSON.stringify({ id: 'post-1', title: 'Hello' }));
+  const result = await adapter.insert<PostRecord>({
+    table: 'posts',
+    values: { id: 'post-1', title: 'Hello' },
   });
 
-  test('requires filters for update', async () => {
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      fetch: () => Promise.resolve(jsonResponse([])),
-    });
-
-    const result = await adapter.update<PostRecord>({
-      table: 'posts',
-      values: { title: 'Updated' },
-      filters: [],
-    });
-
-    expect(result.ok).toBe(false);
-    expect(result.ok === false ? result.error.code : '').toBe('validation_error');
+  expect(result.ok).toBe(true);
+  expect(calls[0]?.init?.method).toBe('POST');
+  expect(calls[0]?.init?.body).toBe(JSON.stringify({ id: 'post-1', title: 'Hello' }));
+});
+
+test('requires filters for update', async () => {
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    fetch: () => Promise.resolve(jsonResponse([])),
   });
 
-  test('requires filters for delete', async () => {
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      fetch: () => Promise.resolve(jsonResponse([])),
-    });
+  const result = await adapter.update<PostRecord>({
+    table: 'posts',
+    values: { title: 'Updated' },
+    filters: [],
+  });
 
-    const result = await adapter.delete<PostRecord>({ table: 'posts', filters: [] });
+  expect(result.ok).toBe(false);
+  expect(result.ok === false ? result.error.code : '').toBe('validation_error');
+});
 
-    expect(result.ok).toBe(false);
-    expect(result.ok === false ? result.error.code : '').toBe('validation_error');
+test('requires filters for delete', async () => {
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    fetch: () => Promise.resolve(jsonResponse([])),
   });
 
-  test('normalizes provider errors', async () => {
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      fetch: () => Promise.resolve(jsonResponse({ message: 'permission denied' }, 403)),
-    });
+  const result = await adapter.delete<PostRecord>({ table: 'posts', filters: [] });
 
-    const result = await adapter.select<PostRecord>({ table: 'posts' });
+  expect(result.ok).toBe(false);
+  expect(result.ok === false ? result.error.code : '').toBe('validation_error');
+});
 
-    expect(result.ok).toBe(false);
-    expect(result.ok === false ? result.error.code : '').toBe('permission_denied');
+test('normalizes provider errors', async () => {
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    fetch: () => Promise.resolve(jsonResponse({ message: 'permission denied' }, 403)),
   });
 
-  test('exposes realtime capability only when configured with a client', () => {
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      realtime: false,
-      fetch: () => Promise.resolve(jsonResponse([])),
-    });
+  const result = await adapter.select<PostRecord>({ table: 'posts' });
+
+  expect(result.ok).toBe(false);
+  expect(result.ok === false ? result.error.code : '').toBe('permission_denied');
+});
 
-    expect(adapter.capabilities.realtime).toBe(false);
-    expect('realtime' in adapter).toBe(false);
+test('exposes realtime capability only when configured with a client', () => {
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    realtime: false,
+    fetch: () => Promise.resolve(jsonResponse([])),
   });
+
+  expect(adapter.capabilities.realtime).toBe(false);
+  expect('realtime' in adapter).toBe(false);
 });
 
 function jsonResponse(body: unknown, status = 200): Response {

package/src/adapter.ts

@@ -33,113 +33,91 @@ interface DbFindByIdSuccessResult<TRecord extends object> {
 
 export function createSupabaseDbAdapter(options: SupabaseDbAdapterOptions): SupabaseDbAdapter {
   const config = normalizeConfig(options);
-  const baseAdapter: DbAdapter = {
+  const baseAdapter = createBaseAdapter(config);
+  if (!config.realtime || config.realtimeClient === undefined) return baseAdapter;
+  return {
+    ...baseAdapter,
+    realtime: createRealtimeApi({
+      client: config.realtimeClient,
+      defaultSchema: config.schema,
+    }),
+  };
+}
+
+function createBaseAdapter(config: NormalizedConfig): DbAdapter {
+  return {
     capabilities: {
       transactions: false,
       returning: true,
       realtime: config.realtime && config.realtimeClient !== undefined,
     },
-
-    async select<TRecord extends object = DbRecord>(
-      input: DbSelectInput,
-    ): Promise<DbResult<TRecord[]>> {
-      return requestRows<TRecord>(config, buildSelectUrl(config.url, input), {
-        method: 'GET',
-      });
+    select<TRecord extends object = DbRecord>(input: DbSelectInput) {
+      return selectRows<TRecord>(config, input);
     },
-
-    async findById<TRecord extends object = DbRecord>(
-      input: DbFindByIdInput,
-    ): Promise<DbResult<TRecord | null>> {
-      const result = await requestRows<TRecord>(
-        config,
-        buildSelectUrl(config.url, {
-          table: input.table,
-          columns: input.columns,
-          filters: [{ field: input.idField ?? 'id', operator: 'eq', value: input.id }],
-          page: { limit: 1 },
-          schema: input.schema,
-        }),
-        { method: 'GET' },
-      );
-
-      if (!result.ok) {
-        return result;
-      }
-
-      const success: DbFindByIdSuccessResult<TRecord> = {
-        ok: true,
-        data: result.data[0] ?? null,
-      };
-
-      return success;
+    findById<TRecord extends object = DbRecord>(input: DbFindByIdInput) {
+      return findRowById<TRecord>(config, input);
     },
-
-    async insert<TRecord extends object = DbRecord>(
-      input: DbInsertInput<TRecord>,
-    ): Promise<DbResult<TRecord[]>> {
-      const url = buildMutationUrl(config.url, input.table, []);
-
-      return requestRows<TRecord>(config, url, {
-        method: 'POST',
-        body: JSON.stringify(input.values),
-      });
+    insert<TRecord extends object = DbRecord>(input: DbInsertInput<TRecord>) {
+      return insertRows<TRecord>(config, input);
     },
-
-    async update<TRecord extends object = DbRecord>(
-      input: DbUpdateInput<TRecord>,
-    ): Promise<DbResult<TRecord[]>> {
-      const validationError = validateRequiredFilters(input.filters, 'Update');
-
-      if (validationError !== null) {
-        return validationError;
-      }
-
-      const url = buildMutationUrl(config.url, input.table, input.filters);
-
-      return requestRows<TRecord>(config, url, {
-        method: 'PATCH',
-        body: JSON.stringify(input.values),
-      });
+    update<TRecord extends object = DbRecord>(input: DbUpdateInput<TRecord>) {
+      return updateRows<TRecord>(config, input);
     },
-
-    async delete<TRecord extends object = DbRecord>(
-      input: DbDeleteInput,
-    ): Promise<DbResult<TRecord[]>> {
-      const validationError = validateRequiredFilters(input.filters, 'Delete');
-
-      if (validationError !== null) {
-        return validationError;
-      }
-
-      const url = buildMutationUrl(config.url, input.table, input.filters);
-
-      return requestRows<TRecord>(config, url, {
-        method: 'DELETE',
-      });
+    delete<TRecord extends object = DbRecord>(input: DbDeleteInput) {
+      return deleteRows<TRecord>(config, input);
     },
   };
+}
 
-  if (!config.realtime || config.realtimeClient === undefined) {
-    return baseAdapter;
-  }
+function deleteRows<TRecord extends object>(
+  config: NormalizedConfig,
+  input: DbDeleteInput,
+): Promise<DbResult<TRecord[]>> {
+  const validationError = validateRequiredFilters(input.filters, 'Delete');
+  if (validationError !== null) return Promise.resolve(validationError);
+  const url = buildMutationUrl(config.url, input.table, input.filters);
+  return requestRows<TRecord>(config, url, { method: 'DELETE' });
+}
 
-  return {
-    ...baseAdapter,
-    realtime: createRealtimeApi({
-      client: config.realtimeClient,
-      defaultSchema: config.schema,
+async function findRowById<TRecord extends object>(
+  config: NormalizedConfig,
+  input: DbFindByIdInput,
+): Promise<DbResult<TRecord | null>> {
+  const result = await requestRows<TRecord>(
+    config,
+    buildSelectUrl(config.url, {
+      table: input.table,
+      columns: input.columns,
+      filters: [{ field: input.idField ?? 'id', operator: 'eq', value: input.id }],
+      page: { limit: 1 },
+      schema: input.schema,
     }),
+    { method: 'GET' },
+  );
+  if (!result.ok) return result;
+  const success: DbFindByIdSuccessResult<TRecord> = {
+    ok: true,
+    data: result.data[0] ?? null,
   };
+  return success;
+}
+
+function insertRows<TRecord extends object>(
+  config: NormalizedConfig,
+  input: DbInsertInput<TRecord>,
+): Promise<DbResult<TRecord[]>> {
+  const url = buildMutationUrl(config.url, input.table, []);
+  return requestRows<TRecord>(config, url, {
+    method: 'POST',
+    body: JSON.stringify(input.values),
+  });
 }
 
 function normalizeConfig(options: SupabaseDbAdapterOptions): NormalizedConfig {
   const fetchImplementation = options.fetch ?? globalThis.fetch;
-
   if (typeof fetchImplementation !== 'function') {
     throw new TypeError('A fetch implementation is required to use Supabase Database.');
   }
-
   return {
     url: validateUrl(options.url),
     anonKey: validateKey(options.anonKey, 'Supabase anon key'),
@@ -161,13 +139,8 @@ async function requestRows<TRecord extends object>(
       headers: createHeaders(config, init.headers),
     });
     const body = await readJsonBody(response);
-
-    if (!response.ok) {
-      return { ok: false, error: mapHttpError(response.status, body) };
-    }
-
+    if (!response.ok) return { ok: false, error: mapHttpError(response.status, body) };
     const records = normalizeRecords<TRecord>(body);
-
     if (records === null) {
       return {
         ok: false,
@@ -178,17 +151,35 @@ async function requestRows<TRecord extends object>(
         ),
       };
     }
-
     return { ok: true, data: records };
   } catch (error) {
     if (error instanceof TypeError) {
       return { ok: false, error: createDbError('validation_error', error.message, error) };
     }
-
     return { ok: false, error: mapNetworkError(error) };
   }
 }
 
+function selectRows<TRecord extends object>(
+  config: NormalizedConfig,
+  input: DbSelectInput,
+): Promise<DbResult<TRecord[]>> {
+  return requestRows<TRecord>(config, buildSelectUrl(config.url, input), { method: 'GET' });
+}
+
+function updateRows<TRecord extends object>(
+  config: NormalizedConfig,
+  input: DbUpdateInput<TRecord>,
+): Promise<DbResult<TRecord[]>> {
+  const validationError = validateRequiredFilters(input.filters, 'Update');
+  if (validationError !== null) return Promise.resolve(validationError);
+  const url = buildMutationUrl(config.url, input.table, input.filters);
+  return requestRows<TRecord>(config, url, {
+    method: 'PATCH',
+    body: JSON.stringify(input.values),
+  });
+}
+
 function validateRequiredFilters(
   filters: readonly DbFilter[],
   label: string,
@@ -213,28 +204,21 @@ function createHeaders(
   existingHeaders: HeadersInit | undefined,
 ): Headers {
   const headers = new Headers(existingHeaders);
-
   headers.set('apikey', config.anonKey);
   headers.set('Authorization', `Bearer ${config.anonKey}`);
   headers.set('Accept', 'application/json');
   headers.set('Content-Type', 'application/json');
   headers.set('Prefer', 'return=representation');
-
   if (config.schema !== 'public') {
     headers.set('Accept-Profile', config.schema);
     headers.set('Content-Profile', config.schema);
   }
-
   return headers;
 }
 
 async function readJsonBody(response: Response): Promise<unknown> {
   const text = await response.text();
-
-  if (text.trim().length === 0) {
-    return [];
-  }
-
+  if (text.trim().length === 0) return [];
   try {
     return JSON.parse(text);
   } catch {
@@ -243,14 +227,8 @@ async function readJsonBody(response: Response): Promise<unknown> {
 }
 
 function normalizeRecords<TRecord extends object>(value: unknown): TRecord[] | null {
-  if (Array.isArray(value)) {
-    return value.filter(isRecord<TRecord>);
-  }
-
-  if (isRecord<TRecord>(value)) {
-    return [value];
-  }
-
+  if (Array.isArray(value)) return value.filter(isRecord<TRecord>);
+  if (isRecord<TRecord>(value)) return [value];
   return null;
 }