@ankhorage/supabase-db 1.0.2 → 1.0.4

package/src/admin.test.ts

@@ -1,110 +1,106 @@
-import { describe, expect, test } from 'bun:test';
+import { expect, test } from 'bun:test';
 
 import { createSupabaseDbAdminAdapter } from './admin.js';
 
-describe('createSupabaseDbAdminAdapter', () => {
-  test('generates create collection SQL without executing by default', async () => {
-    const adapter = createSupabaseDbAdminAdapter({
-      url: 'https://example.supabase.co',
-      serviceRoleKey: 'service-role',
-    });
-
-    const result = await adapter.createCollection({
-      name: 'posts',
-      fields: [
-        { name: 'title', type: 'text', required: true },
-        { name: 'like_count', type: 'number', defaultValue: 0 },
-        { name: 'published', type: 'boolean', defaultValue: false },
-      ],
-    });
-
-    expect(adapter.capabilities).toEqual({
-      schemaGeneration: true,
-      directExecution: false,
-    });
-    expect(result.ok).toBe(true);
-    expect(result.ok ? result.executed : true).toBe(false);
-    expect(result.ok ? result.sql : '').toContain('create table if not exists "public"."posts"');
-    expect(result.ok ? result.sql : '').toContain(
-      '"id" uuid primary key default gen_random_uuid()',
-    );
-    expect(result.ok ? result.sql : '').toContain('"title" text not null');
-    expect(result.ok ? result.sql : '').toContain('"like_count" double precision default 0');
-    expect(result.ok ? result.sql : '').toContain('"published" boolean default false');
+test('generates create collection SQL without executing by default', async () => {
+  const adapter = createSupabaseDbAdminAdapter({
+    url: 'https://example.supabase.co',
+    serviceRoleKey: 'service-role',
   });
 
-  test('executes generated SQL only when explicitly configured', async () => {
-    const executedSql: string[] = [];
-    const adapter = createSupabaseDbAdminAdapter({
-      url: 'https://example.supabase.co',
-      serviceRoleKey: 'service-role',
-      execute: true,
-      executeSql: (sql) => {
-        executedSql.push(sql);
-        return Promise.resolve({ ok: true });
-      },
-    });
-
-    const result = await adapter.createCollection({
-      name: 'posts',
-      fields: [{ name: 'title', type: 'text' }],
-    });
-
-    expect(adapter.capabilities).toEqual({
-      schemaGeneration: true,
-      directExecution: true,
-    });
-    expect(result).toEqual({
-      ok: true,
-      sql: executedSql[0],
-      executed: true,
-    });
-    expect(executedSql).toHaveLength(1);
+  const result = await adapter.createCollection({
+    name: 'posts',
+    fields: [
+      { name: 'title', type: 'text', required: true },
+      { name: 'like_count', type: 'number', defaultValue: 0 },
+      { name: 'published', type: 'boolean', defaultValue: false },
+    ],
   });
 
-  test('refuses execution without a service role key', async () => {
-    const adapter = createSupabaseDbAdminAdapter({
-      url: 'https://example.supabase.co',
-      execute: true,
-      executeSql: () => Promise.resolve({ ok: true }),
-    });
+  expect(adapter.capabilities).toEqual({
+    schemaGeneration: true,
+    directExecution: false,
+  });
+  expect(result.ok).toBe(true);
+  expect(result.ok ? result.executed : true).toBe(false);
+  expect(result.ok ? result.sql : '').toContain('create table if not exists "public"."posts"');
+  expect(result.ok ? result.sql : '').toContain('"id" uuid primary key default gen_random_uuid()');
+  expect(result.ok ? result.sql : '').toContain('"title" text not null');
+  expect(result.ok ? result.sql : '').toContain('"like_count" double precision default 0');
+  expect(result.ok ? result.sql : '').toContain('"published" boolean default false');
+});
+
+test('executes generated SQL only when explicitly configured', async () => {
+  const executedSql: string[] = [];
+  const adapter = createSupabaseDbAdminAdapter({
+    url: 'https://example.supabase.co',
+    serviceRoleKey: 'service-role',
+    execute: true,
+    executeSql: (sql) => {
+      executedSql.push(sql);
+      return Promise.resolve({ ok: true });
+    },
+  });
 
-    const result = await adapter.createCollection({
-      name: 'posts',
-      fields: [{ name: 'title', type: 'text' }],
-    });
+  const result = await adapter.createCollection({
+    name: 'posts',
+    fields: [{ name: 'title', type: 'text' }],
+  });
+
+  expect(adapter.capabilities).toEqual({
+    schemaGeneration: true,
+    directExecution: true,
+  });
+  expect(result).toEqual({
+    ok: true,
+    sql: executedSql[0],
+    executed: true,
+  });
+  expect(executedSql).toHaveLength(1);
+});
 
-    expect(result.ok).toBe(false);
-    expect(result.ok === false ? result.error.code : '').toBe('missing_service_role_key');
+test('refuses execution without a service role key', async () => {
+  const adapter = createSupabaseDbAdminAdapter({
+    url: 'https://example.supabase.co',
+    execute: true,
+    executeSql: () => Promise.resolve({ ok: true }),
   });
 
-  test('generates delete collection SQL', () => {
-    const adapter = createSupabaseDbAdminAdapter({
-      url: 'https://example.supabase.co',
-      serviceRoleKey: 'service-role',
-    });
+  const result = await adapter.createCollection({
+    name: 'posts',
+    fields: [{ name: 'title', type: 'text' }],
+  });
 
-    const result = adapter.generateDeleteCollectionSql({ name: 'posts' });
+  expect(result.ok).toBe(false);
+  expect(result.ok === false ? result.error.code : '').toBe('missing_service_role_key');
+});
 
-    expect(result).toEqual({
-      ok: true,
-      sql: 'drop table if exists "public"."posts";',
-      executed: false,
-    });
+test('generates delete collection SQL', () => {
+  const adapter = createSupabaseDbAdminAdapter({
+    url: 'https://example.supabase.co',
+    serviceRoleKey: 'service-role',
   });
 
-  test('rejects invalid collection names', () => {
-    const adapter = createSupabaseDbAdminAdapter({
-      url: 'https://example.supabase.co',
-      serviceRoleKey: 'service-role',
-    });
+  const result = adapter.generateDeleteCollectionSql({ name: 'posts' });
+
+  expect(result).toEqual({
+    ok: true,
+    sql: 'drop table if exists "public"."posts";',
+    executed: false,
+  });
+});
 
-    const result = adapter.generateCreateCollectionSql({
-      name: 'invalid-name',
-      fields: [{ name: 'title', type: 'text' }],
-    });
+test('rejects invalid collection names', () => {
+  const adapter = createSupabaseDbAdminAdapter({
+    url: 'https://example.supabase.co',
+    serviceRoleKey: 'service-role',
+  });
 
-    expect(result.ok).toBe(false);
-    expect(result.ok === false ? result.error.code : '').toBe('validation_error');
+  const result = adapter.generateCreateCollectionSql({
+    name: 'invalid-name',
+    fields: [{ name: 'title', type: 'text' }],
   });
+
+  expect(result.ok).toBe(false);
+  expect(result.ok === false ? result.error.code : '').toBe('validation_error');
 });

package/src/realtime.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'bun:test';
+import { expect, test } from 'bun:test';
 
 import { createSupabaseDbAdapter } from './adapter.js';
 import { normalizeRealtimeEvent } from './realtime.js';
@@ -13,125 +13,121 @@ interface PostRecord {
   readonly title: string;
 }
 
-describe('normalizeRealtimeEvent', () => {
-  test('normalizes insert payloads', () => {
-    const event = normalizeRealtimeEvent<PostRecord>(
-      {
-        eventType: 'INSERT',
-        schema: 'public',
-        table: 'posts',
-        commit_timestamp: '2026-05-12T10:00:00Z',
-        new: { id: 'post-1', title: 'Hello' },
-      },
-      'fallback',
-      'public',
-    );
-
-    expect(event).toEqual({
-      table: 'posts',
+test('normalizes insert payloads', () => {
+  const event = normalizeRealtimeEvent<PostRecord>(
+    {
+      eventType: 'INSERT',
       schema: 'public',
-      kind: 'insert',
-      record: { id: 'post-1', title: 'Hello' },
-      committedAt: '2026-05-12T10:00:00Z',
-    });
+      table: 'posts',
+      commit_timestamp: '2026-05-12T10:00:00Z',
+      new: { id: 'post-1', title: 'Hello' },
+    },
+    'fallback',
+    'public',
+  );
+
+  expect(event).toEqual({
+    table: 'posts',
+    schema: 'public',
+    kind: 'insert',
+    record: { id: 'post-1', title: 'Hello' },
+    committedAt: '2026-05-12T10:00:00Z',
   });
+});
 
-  test('normalizes update payloads with previous record', () => {
-    const event = normalizeRealtimeEvent<PostRecord>(
-      {
-        eventType: 'UPDATE',
-        new: { id: 'post-1', title: 'Updated' },
-        old: { id: 'post-1', title: 'Old' },
-      },
-      'posts',
-      'public',
-    );
-
-    expect(event).toEqual({
-      table: 'posts',
-      schema: 'public',
-      kind: 'update',
-      record: { id: 'post-1', title: 'Updated' },
-      previousRecord: { id: 'post-1', title: 'Old' },
-      committedAt: undefined,
-    });
+test('normalizes update payloads with previous record', () => {
+  const event = normalizeRealtimeEvent<PostRecord>(
+    {
+      eventType: 'UPDATE',
+      new: { id: 'post-1', title: 'Updated' },
+      old: { id: 'post-1', title: 'Old' },
+    },
+    'posts',
+    'public',
+  );
+
+  expect(event).toEqual({
+    table: 'posts',
+    schema: 'public',
+    kind: 'update',
+    record: { id: 'post-1', title: 'Updated' },
+    previousRecord: { id: 'post-1', title: 'Old' },
+    committedAt: undefined,
   });
+});
 
-  test('normalizes delete payloads to a null current record', () => {
-    const event = normalizeRealtimeEvent<PostRecord>(
-      {
-        eventType: 'DELETE',
-        old: { id: 'post-1', title: 'Deleted' },
-      },
-      'posts',
-      'public',
-    );
-
-    expect(event).toEqual({
-      table: 'posts',
-      schema: 'public',
-      kind: 'delete',
-      record: null,
-      previousRecord: { id: 'post-1', title: 'Deleted' },
-      committedAt: undefined,
-    });
+test('normalizes delete payloads to a null current record', () => {
+  const event = normalizeRealtimeEvent<PostRecord>(
+    {
+      eventType: 'DELETE',
+      old: { id: 'post-1', title: 'Deleted' },
+    },
+    'posts',
+    'public',
+  );
+
+  expect(event).toEqual({
+    table: 'posts',
+    schema: 'public',
+    kind: 'delete',
+    record: null,
+    previousRecord: { id: 'post-1', title: 'Deleted' },
+    committedAt: undefined,
   });
+});
 
-  test('ignores unknown realtime events', () => {
-    const event = normalizeRealtimeEvent<PostRecord>({ eventType: 'TRUNCATE' }, 'posts', 'public');
+test('ignores unknown realtime events', () => {
+  const event = normalizeRealtimeEvent<PostRecord>({ eventType: 'TRUNCATE' }, 'posts', 'public');
 
-    expect(event).toBeNull();
-  });
+  expect(event).toBeNull();
 });
 
-describe('realtime adapter capability', () => {
-  test('subscribes and cleans up collection channels', async () => {
-    const client = createFakeRealtimeClient();
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      realtime: true,
-      realtimeClient: client,
-      fetch: () => Promise.resolve(new Response('[]')),
-    });
-
-    const received: unknown[] = [];
-    const subscription = adapter.realtime?.subscribeToCollection<PostRecord>(
-      { table: 'posts' },
-      (event) => {
-        received.push(event);
-      },
-    );
-
-    client.emit({
-      eventType: 'INSERT',
-      table: 'posts',
-      schema: 'public',
-      new: { id: '1', title: 'A' },
-    });
-    await subscription?.unsubscribe();
+test('subscribes and cleans up collection channels', async () => {
+  const client = createFakeRealtimeClient();
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    realtime: true,
+    realtimeClient: client,
+    fetch: () => Promise.resolve(new Response('[]')),
+  });
 
-    expect(received).toHaveLength(1);
-    expect(client.removedChannels).toBe(1);
+  const received: unknown[] = [];
+  const subscription = adapter.realtime?.subscribeToCollection<PostRecord>(
+    { table: 'posts' },
+    (event) => {
+      received.push(event);
+    },
+  );
+
+  client.emit({
+    eventType: 'INSERT',
+    table: 'posts',
+    schema: 'public',
+    new: { id: '1', title: 'A' },
   });
+  await subscription?.unsubscribe();
+
+  expect(received).toHaveLength(1);
+  expect(client.removedChannels).toBe(1);
+});
 
-  test('subscribes to a specific record using a Supabase filter', () => {
-    const client = createFakeRealtimeClient();
-    const adapter = createSupabaseDbAdapter({
-      url: 'https://example.supabase.co',
-      anonKey: 'anon',
-      realtime: true,
-      realtimeClient: client,
-      fetch: () => Promise.resolve(new Response('[]')),
-    });
-
-    adapter.realtime?.subscribeToRecord<PostRecord>(
-      { table: 'posts', id: 'post-1' },
-      () => undefined,
-    );
-
-    expect(client.lastFilter?.filter).toBe('id=eq.post-1');
+test('subscribes to a specific record using a Supabase filter', () => {
+  const client = createFakeRealtimeClient();
+  const adapter = createSupabaseDbAdapter({
+    url: 'https://example.supabase.co',
+    anonKey: 'anon',
+    realtime: true,
+    realtimeClient: client,
+    fetch: () => Promise.resolve(new Response('[]')),
   });
+
+  adapter.realtime?.subscribeToRecord<PostRecord>(
+    { table: 'posts', id: 'post-1' },
+    () => undefined,
+  );
+
+  expect(client.lastFilter?.filter).toBe('id=eq.post-1');
 });
 
 function createFakeRealtimeClient(): SupabaseRealtimeClient & {

package/src/realtime.ts

@@ -23,66 +23,13 @@ export function createRealtimeApi(config: RealtimeApiConfig): DbRealtimeAdapter[
       input: DbCollectionSubscriptionInput,
       listener: DbChangeListener<TRecord>,
     ): DbSubscription {
-      const schema = input.schema ?? config.defaultSchema;
-      const table = validateIdentifier(input.table, 'Realtime table');
-      const channel = config.client
-        .channel(`ankhorage-db:${schema}:${table}`)
-        .on(
-          'postgres_changes',
-          {
-            event: '*',
-            schema,
-            table,
-          },
-          (payload) => {
-            const event = normalizeRealtimeEvent<TRecord>(payload, table, schema);
-
-            if (event !== null) {
-              listener(event);
-            }
-          },
-        )
-        .subscribe();
-
-      return {
-        async unsubscribe(): Promise<void> {
-          await config.client.removeChannel(channel);
-        },
-      };
+      return createCollectionSubscription(config, input, listener);
     },
-
     subscribeToRecord<TRecord extends object = DbRecord>(
       input: DbRecordSubscriptionInput,
       listener: DbChangeListener<TRecord>,
     ): DbSubscription {
-      const schema = input.schema ?? config.defaultSchema;
-      const table = validateIdentifier(input.table, 'Realtime table');
-      const idField = validateIdentifier(input.idField ?? 'id', 'Realtime record id field');
-      const channel = config.client
-        .channel(`ankhorage-db:${schema}:${table}:${idField}:${String(input.id)}`)
-        .on(
-          'postgres_changes',
-          {
-            event: '*',
-            schema,
-            table,
-            filter: `${idField}=eq.${String(input.id)}`,
-          },
-          (payload) => {
-            const event = normalizeRealtimeEvent<TRecord>(payload, table, schema);
-
-            if (event !== null) {
-              listener(event);
-            }
-          },
-        )
-        .subscribe();
-
-      return {
-        async unsubscribe(): Promise<void> {
-          await config.client.removeChannel(channel);
-        },
-      };
+      return createRecordSubscription(config, input, listener);
     },
   };
 }
@@ -93,11 +40,7 @@ export function normalizeRealtimeEvent<TRecord extends object = DbRecord>(
   fallbackSchema: string,
 ): DbChangeEvent<TRecord> | null {
   const kind = normalizeKind(payload.eventType);
-
-  if (kind === null) {
-    return null;
-  }
-
+  if (kind === null) return null;
   const record = normalizeRecord<TRecord>(payload.new);
   const previousRecord = normalizeRecord<TRecord>(payload.old);
   const base = {
@@ -107,17 +50,65 @@ export function normalizeRealtimeEvent<TRecord extends object = DbRecord>(
     record: kind === 'delete' ? null : record,
     committedAt: payload.commit_timestamp,
   };
+  if (previousRecord === null) return base;
+  return { ...base, previousRecord };
+}
 
-  if (previousRecord === null) {
-    return base;
-  }
+function createCollectionSubscription<TRecord extends object>(
+  config: RealtimeApiConfig,
+  input: DbCollectionSubscriptionInput,
+  listener: DbChangeListener<TRecord>,
+): DbSubscription {
+  const schema = input.schema ?? config.defaultSchema;
+  const table = validateIdentifier(input.table, 'Realtime table');
+  return createSubscription(config, `ankhorage-db:${schema}:${table}`, schema, table, listener);
+}
+
+function createRecordSubscription<TRecord extends object>(
+  config: RealtimeApiConfig,
+  input: DbRecordSubscriptionInput,
+  listener: DbChangeListener<TRecord>,
+): DbSubscription {
+  const schema = input.schema ?? config.defaultSchema;
+  const table = validateIdentifier(input.table, 'Realtime table');
+  const idField = validateIdentifier(input.idField ?? 'id', 'Realtime record id field');
+  const id = String(input.id);
+  return createSubscription(
+    config,
+    `ankhorage-db:${schema}:${table}:${idField}:${id}`,
+    schema,
+    table,
+    listener,
+    `${idField}=eq.${id}`,
+  );
+}
 
+function createSubscription<TRecord extends object>(
+  config: RealtimeApiConfig,
+  channelName: string,
+  schema: string,
+  table: string,
+  listener: DbChangeListener<TRecord>,
+  filter?: string,
+): DbSubscription {
+  const channel = config.client
+    .channel(channelName)
+    .on('postgres_changes', { event: '*', schema, table, filter }, (payload) => {
+      const event = normalizeRealtimeEvent<TRecord>(payload, table, schema);
+      if (event !== null) listener(event);
+    })
+    .subscribe();
   return {
-    ...base,
-    previousRecord,
+    async unsubscribe(): Promise<void> {
+      await config.client.removeChannel(channel);
+    },
   };
 }
 
+function isRecord<TRecord extends object>(value: unknown): value is TRecord {
+  return typeof value === 'object' && value !== null;
+}
+
 function normalizeKind(value: string | undefined): DbChangeKind | null {
   switch (value) {
     case 'INSERT':
@@ -132,13 +123,5 @@ function normalizeKind(value: string | undefined): DbChangeKind | null {
 }
 
 function normalizeRecord<TRecord extends object>(value: unknown): TRecord | null {
-  if (!isRecord<TRecord>(value)) {
-    return null;
-  }
-
-  return value;
-}
-
-function isRecord<TRecord extends object>(value: unknown): value is TRecord {
-  return typeof value === 'object' && value !== null;
+  return isRecord<TRecord>(value) ? value : null;
 }