@dotdo/postgres 0.1.0

package/src/worker/supabase-compat.test.ts

@@ -0,0 +1,621 @@
+/**
+ * Backend compatibility tests for @supabase/supabase-js client
+ *
+ * These tests verify that the PostgREST-compatible router can accept requests
+ * from the actual @supabase/supabase-js client.
+ *
+ * The Supabase JS client sends HTTP requests to PostgREST-style endpoints:
+ * - GET /tablename for selects
+ * - POST /tablename for inserts
+ * - PATCH /tablename for updates
+ * - DELETE /tablename for deletes
+ * - POST /rpc/functionname for RPC calls
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Hono } from 'hono';
+
+/**
+ * Simulated PostgREST-compatible router that mirrors real Supabase behavior
+ * This tests the request/response format expected by @supabase/supabase-js
+ */
+interface SupabaseQueryOptions {
+  select?: string;
+  order?: string;
+  limit?: number;
+  offset?: number;
+  count?: 'exact' | 'planned' | 'estimated';
+  filters?: Record<string, unknown>;
+  headers?: Record<string, string>;
+}
+
+function createSupabaseCompatibleRouter(
+  executeQuery: (sql: string, params: unknown[]) => Promise<{ rows: unknown[]; rowCount?: number }>
+): Hono {
+  const app = new Hono();
+
+  // Helper to parse PostgREST filter query params
+  function parseFilters(searchParams: URLSearchParams): Array<{ column: string; op: string; value: string }> {
+    const filters: Array<{ column: string; op: string; value: string }> = [];
+    const ops = ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'like', 'ilike', 'is', 'in'];
+
+    searchParams.forEach((value, key) => {
+      if (key !== 'select' && key !== 'order' && key !== 'limit' && key !== 'offset') {
+        for (const op of ops) {
+          if (value.startsWith(`${op}.`)) {
+            filters.push({
+              column: key,
+              op,
+              value: value.substring(op.length + 1),
+            });
+            break;
+          }
+        }
+      }
+    });
+
+    return filters;
+  }
+
+  // GET /tablename - Select
+  app.get('/:table', async (c) => {
+    try {
+      const table = c.req.param('table');
+      const url = new URL(c.req.url);
+      const select = url.searchParams.get('select') || '*';
+      const order = url.searchParams.get('order');
+      const limit = url.searchParams.get('limit');
+      const offset = url.searchParams.get('offset');
+      const filters = parseFilters(url.searchParams);
+
+      // Build SQL
+      let sql = `SELECT ${select} FROM "${table}"`;
+      const params: unknown[] = [];
+
+      if (filters.length > 0) {
+        const whereClauses = filters.map((f, i) => {
+          params.push(f.value);
+          const colName = `"${f.column}"`;
+          switch (f.op) {
+            case 'eq':
+              return `${colName} = $${i + 1}`;
+            case 'neq':
+              return `${colName} != $${i + 1}`;
+            case 'gt':
+              return `${colName} > $${i + 1}`;
+            case 'gte':
+              return `${colName} >= $${i + 1}`;
+            case 'lt':
+              return `${colName} < $${i + 1}`;
+            case 'lte':
+              return `${colName} <= $${i + 1}`;
+            case 'like':
+              return `${colName} LIKE $${i + 1}`;
+            case 'ilike':
+              return `${colName} ILIKE $${i + 1}`;
+            case 'is':
+              return `${colName} IS ${f.value === 'null' ? 'NULL' : f.value}`;
+            default:
+              return `${colName} = $${i + 1}`;
+          }
+        });
+        sql += ` WHERE ${whereClauses.join(' AND ')}`;
+      }
+
+      if (order) {
+        const [col, dir] = order.split('.');
+        sql += ` ORDER BY "${col}" ${dir?.toUpperCase() === 'DESC' ? 'DESC' : 'ASC'}`;
+      }
+
+      if (limit) {
+        sql += ` LIMIT ${parseInt(limit, 10)}`;
+      }
+
+      if (offset) {
+        sql += ` OFFSET ${parseInt(offset, 10)}`;
+      }
+
+      const result = await executeQuery(sql, params);
+
+      // Set headers
+      c.header('Content-Type', 'application/json');
+      c.header('Content-Range', `items 0-${result.rows.length - 1}/*`);
+
+      // Handle Prefer: count header
+      const prefer = c.req.header('Prefer');
+      if (prefer?.includes('count=')) {
+        c.header('Content-Range', `items 0-${result.rows.length - 1}/${result.rowCount || result.rows.length}`);
+      }
+
+      return c.json(result.rows);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return c.json({ message, code: 'PGRST000' }, 500);
+    }
+  });
+
+  // POST /tablename - Insert
+  app.post('/:table', async (c) => {
+    try {
+      const table = c.req.param('table');
+      const body = await c.req.json();
+      const prefer = c.req.header('Prefer') || '';
+
+      const rows = Array.isArray(body) ? body : [body];
+      const columns = Object.keys(rows[0]);
+      const values = rows.map((row, i) =>
+        `(${columns.map((_, j) => `$${i * columns.length + j + 1}`).join(', ')})`
+      ).join(', ');
+
+      let sql = `INSERT INTO "${table}" (${columns.map((c) => `"${c}"`).join(', ')}) VALUES ${values}`;
+
+      if (prefer.includes('return=representation')) {
+        sql += ' RETURNING *';
+      }
+
+      const params = rows.flatMap((row) => columns.map((col) => row[col]));
+      const result = await executeQuery(sql, params);
+
+      // Set Location header for created resources
+      if (result.rows.length > 0 && result.rows[0] && typeof result.rows[0] === 'object') {
+        const firstRow = result.rows[0] as Record<string, unknown>;
+        if ('id' in firstRow) {
+          c.header('Location', `/${table}?id=eq.${firstRow.id}`);
+        }
+      }
+
+      c.header('Content-Type', 'application/json');
+
+      if (prefer.includes('return=representation')) {
+        return c.json(Array.isArray(body) ? result.rows : result.rows[0], 201);
+      }
+
+      return c.body(null, 201);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return c.json({ message, code: 'PGRST000' }, 500);
+    }
+  });
+
+  // PATCH /tablename - Update
+  app.patch('/:table', async (c) => {
+    try {
+      const table = c.req.param('table');
+      const url = new URL(c.req.url);
+      const body = await c.req.json();
+      const prefer = c.req.header('Prefer') || '';
+      const filters = parseFilters(url.searchParams);
+
+      if (filters.length === 0) {
+        return c.json({ message: 'Filters are required for UPDATE', code: 'PGRST103' }, 400);
+      }
+
+      const setClauses = Object.keys(body);
+      const params: unknown[] = setClauses.map((k) => body[k]);
+
+      let sql = `UPDATE "${table}" SET ${setClauses.map((k, i) => `"${k}" = $${i + 1}`).join(', ')}`;
+
+      const whereClauses = filters.map((f, i) => {
+        params.push(f.value);
+        const colName = `"${f.column}"`;
+        const paramIdx = setClauses.length + i + 1;
+        switch (f.op) {
+          case 'eq':
+            return `${colName} = $${paramIdx}`;
+          default:
+            return `${colName} = $${paramIdx}`;
+        }
+      });
+      sql += ` WHERE ${whereClauses.join(' AND ')}`;
+
+      if (prefer.includes('return=representation')) {
+        sql += ' RETURNING *';
+      }
+
+      const result = await executeQuery(sql, params);
+
+      if (prefer.includes('return=representation')) {
+        return c.json(result.rows, 200);
+      }
+
+      return c.body(null, 204);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return c.json({ message, code: 'PGRST000' }, 500);
+    }
+  });
+
+  // DELETE /tablename - Delete
+  app.delete('/:table', async (c) => {
+    try {
+      const table = c.req.param('table');
+      const url = new URL(c.req.url);
+      const prefer = c.req.header('Prefer') || '';
+      const filters = parseFilters(url.searchParams);
+
+      if (filters.length === 0) {
+        return c.json({ message: 'Filters are required for DELETE', code: 'PGRST104' }, 400);
+      }
+
+      const params: unknown[] = [];
+      const whereClauses = filters.map((f, i) => {
+        params.push(f.value);
+        const colName = `"${f.column}"`;
+        switch (f.op) {
+          case 'eq':
+            return `${colName} = $${i + 1}`;
+          default:
+            return `${colName} = $${i + 1}`;
+        }
+      });
+
+      let sql = `DELETE FROM "${table}" WHERE ${whereClauses.join(' AND ')}`;
+
+      if (prefer.includes('return=representation')) {
+        sql += ' RETURNING *';
+      }
+
+      const result = await executeQuery(sql, params);
+
+      if (prefer.includes('return=representation')) {
+        return c.json(result.rows, 200);
+      }
+
+      return c.body(null, 204);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return c.json({ message, code: 'PGRST000' }, 500);
+    }
+  });
+
+  // POST /rpc/:function - RPC call
+  app.post('/rpc/:function', async (c) => {
+    try {
+      const fn = c.req.param('function');
+      const body = await c.req.json().catch(() => ({}));
+
+      const params = Object.values(body);
+      const argNames = Object.keys(body);
+      const args = argNames.length > 0
+        ? argNames.map((name, i) => `${name} => $${i + 1}`).join(', ')
+        : '';
+
+      const sql = `SELECT * FROM "${fn}"(${args})`;
+      const result = await executeQuery(sql, params);
+
+      return c.json(result.rows);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return c.json({ message, code: 'PGRST000' }, 500);
+    }
+  });
+
+  return app;
+}
+
+describe('Backend: @supabase/supabase-js compatibility', () => {
+  let app: Hono;
+  let mockExecute: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    mockExecute = vi.fn();
+    app = createSupabaseCompatibleRouter(mockExecute);
+  });
+
+  const makeRequest = async (
+    method: string,
+    path: string,
+    options: {
+      body?: unknown;
+      headers?: Record<string, string>;
+    } = {}
+  ): Promise<Response> => {
+    const init: RequestInit = {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        'apikey': 'test-api-key',
+        ...options.headers,
+      },
+    };
+
+    if (options.body) {
+      init.body = JSON.stringify(options.body);
+    }
+
+    return app.request(`http://localhost${path}`, init);
+  };
+
+  describe('SELECT operations (GET)', () => {
+    it('should select all rows from a table', async () => {
+      mockExecute.mockResolvedValue({
+        rows: [
+          { id: 1, name: 'Alice' },
+          { id: 2, name: 'Bob' },
+        ],
+      });
+
+      const res = await makeRequest('GET', '/users');
+      const data = await res.json();
+
+      expect(res.status).toBe(200);
+      expect(data).toHaveLength(2);
+      expect(mockExecute).toHaveBeenCalledWith(
+        'SELECT * FROM "users"',
+        []
+      );
+    });
+
+    it('should select specific columns', async () => {
+      mockExecute.mockResolvedValue({ rows: [{ id: 1, name: 'Alice' }] });
+
+      await makeRequest('GET', '/users?select=id,name');
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        'SELECT id,name FROM "users"',
+        []
+      );
+    });
+
+    it('should handle eq filter', async () => {
+      mockExecute.mockResolvedValue({ rows: [{ id: 1, name: 'Alice' }] });
+
+      await makeRequest('GET', '/users?id=eq.1');
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('WHERE "id" = $1'),
+        ['1']
+      );
+    });
+
+    it('should handle multiple filters', async () => {
+      mockExecute.mockResolvedValue({ rows: [] });
+
+      await makeRequest('GET', '/users?status=eq.active&age=gte.18');
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('WHERE'),
+        expect.arrayContaining(['active', '18'])
+      );
+    });
+
+    it('should handle order parameter', async () => {
+      mockExecute.mockResolvedValue({ rows: [] });
+
+      await makeRequest('GET', '/users?order=name.asc');
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('ORDER BY "name" ASC'),
+        []
+      );
+    });
+
+    it('should handle limit and offset', async () => {
+      mockExecute.mockResolvedValue({ rows: [] });
+
+      await makeRequest('GET', '/users?limit=10&offset=20');
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('LIMIT 10'),
+        []
+      );
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('OFFSET 20'),
+        []
+      );
+    });
+
+    it('should set Content-Range header', async () => {
+      mockExecute.mockResolvedValue({
+        rows: [{ id: 1 }, { id: 2 }],
+      });
+
+      const res = await makeRequest('GET', '/users');
+
+      expect(res.headers.get('Content-Range')).toContain('items');
+    });
+  });
+
+  describe('INSERT operations (POST)', () => {
+    it('should insert a single row', async () => {
+      mockExecute.mockResolvedValue({ rows: [{ id: 1, name: 'Alice' }] });
+
+      const res = await makeRequest('POST', '/users', {
+        body: { name: 'Alice', email: 'alice@example.com' },
+        headers: { Prefer: 'return=representation' },
+      });
+
+      expect(res.status).toBe(201);
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('INSERT INTO "users"'),
+        ['Alice', 'alice@example.com']
+      );
+    });
+
+    it('should insert multiple rows', async () => {
+      mockExecute.mockResolvedValue({
+        rows: [{ id: 1 }, { id: 2 }],
+      });
+
+      await makeRequest('POST', '/users', {
+        body: [
+          { name: 'Alice' },
+          { name: 'Bob' },
+        ],
+        headers: { Prefer: 'return=representation' },
+      });
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('VALUES'),
+        ['Alice', 'Bob']
+      );
+    });
+
+    it('should return 201 status code', async () => {
+      mockExecute.mockResolvedValue({ rows: [] });
+
+      const res = await makeRequest('POST', '/users', {
+        body: { name: 'Alice' },
+      });
+
+      expect(res.status).toBe(201);
+    });
+
+    it('should return inserted row with return=representation', async () => {
+      mockExecute.mockResolvedValue({
+        rows: [{ id: 1, name: 'Alice' }],
+      });
+
+      const res = await makeRequest('POST', '/users', {
+        body: { name: 'Alice' },
+        headers: { Prefer: 'return=representation' },
+      });
+
+      const data = await res.json();
+      expect(data).toHaveProperty('id', 1);
+      expect(data).toHaveProperty('name', 'Alice');
+    });
+
+    it('should set Location header', async () => {
+      mockExecute.mockResolvedValue({
+        rows: [{ id: 1, name: 'Alice' }],
+      });
+
+      const res = await makeRequest('POST', '/users', {
+        body: { name: 'Alice' },
+        headers: { Prefer: 'return=representation' },
+      });
+
+      expect(res.headers.get('Location')).toContain('/users?id=eq.1');
+    });
+  });
+
+  describe('UPDATE operations (PATCH)', () => {
+    it('should update rows with filters', async () => {
+      mockExecute.mockResolvedValue({ rows: [] });
+
+      const res = await makeRequest('PATCH', '/users?id=eq.1', {
+        body: { name: 'Jane' },
+      });
+
+      expect(res.status).toBe(204);
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('UPDATE "users" SET'),
+        expect.arrayContaining(['Jane', '1'])
+      );
+    });
+
+    it('should require filters for safety', async () => {
+      const res = await makeRequest('PATCH', '/users', {
+        body: { name: 'Jane' },
+      });
+
+      expect(res.status).toBe(400);
+    });
+
+    it('should return updated rows with return=representation', async () => {
+      mockExecute.mockResolvedValue({
+        rows: [{ id: 1, name: 'Jane' }],
+      });
+
+      const res = await makeRequest('PATCH', '/users?id=eq.1', {
+        body: { name: 'Jane' },
+        headers: { Prefer: 'return=representation' },
+      });
+
+      expect(res.status).toBe(200);
+      const data = await res.json() as { name: string }[];
+      expect(data).toHaveLength(1);
+      expect(data[0]).toHaveProperty('name', 'Jane');
+    });
+  });
+
+  describe('DELETE operations', () => {
+    it('should delete rows with filters', async () => {
+      mockExecute.mockResolvedValue({ rows: [] });
+
+      const res = await makeRequest('DELETE', '/users?id=eq.1');
+
+      expect(res.status).toBe(204);
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('DELETE FROM "users"'),
+        ['1']
+      );
+    });
+
+    it('should require filters for safety', async () => {
+      const res = await makeRequest('DELETE', '/users');
+
+      expect(res.status).toBe(400);
+    });
+
+    it('should return deleted rows with return=representation', async () => {
+      mockExecute.mockResolvedValue({
+        rows: [{ id: 1, name: 'Alice' }],
+      });
+
+      const res = await makeRequest('DELETE', '/users?id=eq.1', {
+        headers: { Prefer: 'return=representation' },
+      });
+
+      expect(res.status).toBe(200);
+      const data = await res.json();
+      expect(data).toHaveLength(1);
+    });
+  });
+
+  describe('RPC operations (POST /rpc)', () => {
+    it('should call RPC function with parameters', async () => {
+      mockExecute.mockResolvedValue({
+        rows: [{ result: 42 }],
+      });
+
+      const res = await makeRequest('POST', '/rpc/my_function', {
+        body: { user_id: 1 },
+      });
+
+      expect(res.status).toBe(200);
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.stringContaining('SELECT * FROM "my_function"'),
+        [1]
+      );
+    });
+
+    it('should call RPC function without parameters', async () => {
+      mockExecute.mockResolvedValue({
+        rows: [{ now: '2024-01-01' }],
+      });
+
+      const res = await makeRequest('POST', '/rpc/get_current_time');
+
+      expect(res.status).toBe(200);
+    });
+  });
+
+  describe('Supabase client request format', () => {
+    it('should match expected Supabase client request format for select', async () => {
+      mockExecute.mockResolvedValue({ rows: [] });
+
+      // This is how @supabase/supabase-js sends select requests
+      const res = await makeRequest('GET', '/users?select=*&id=eq.1&order=created_at.desc&limit=10');
+
+      expect(res.status).toBe(200);
+    });
+
+    it('should match expected Supabase client request format for insert', async () => {
+      mockExecute.mockResolvedValue({ rows: [{ id: 1 }] });
+
+      // This is how @supabase/supabase-js sends insert requests
+      const res = await makeRequest('POST', '/users', {
+        body: { name: 'Alice', email: 'alice@example.com' },
+        headers: {
+          'Prefer': 'return=representation',
+          'apikey': 'test-key',
+          'Authorization': 'Bearer test-token',
+        },
+      });
+
+      expect(res.status).toBe(201);
+    });
+  });
+});