@edge-base/server 0.1.1

package/src/__tests__/postgres-dialect.test.ts

@@ -0,0 +1,328 @@
+/**
+ * 서버 단위 테스트 — PostgreSQL dialect (query engine + executor)
+ *
+ * 실행: cd packages/server && npx vitest run src/__tests__/postgres-dialect.test.ts
+ *
+ * 테스트 대상:
+ *   A. Query engine — PostgreSQL dialect ($1,$2... bind params)
+ *   B. Query engine — PostgreSQL contains (ILIKE)
+ *   C. Query engine — PostgreSQL IN operator
+ *   D. Query engine — PostgreSQL OR filters
+ *   E. Query engine — PostgreSQL search (ILIKE across columns, no FTS5)
+ *   F. Query engine — PostgreSQL countSql consistency
+ *   G. Default dialect behavior (SQLite fallback)
+ *   H. executePostgresQuery — export validation
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  buildListQuery,
+  buildCountQuery,
+  buildGetQuery,
+  buildSearchQuery,
+} from '../lib/query-engine.js';
+import { executePostgresQuery } from '../lib/postgres-executor.js';
+
+// ─── A. PostgreSQL dialect — bind params ($1, $2, ...) ────────────────────────
+
+describe('PostgreSQL dialect — bind params', () => {
+  it('buildGetQuery uses $1 placeholder', () => {
+    const { sql, params } = buildGetQuery('products', 'p-1', undefined, 'postgres');
+    expect(sql).toContain('"id" = $1');
+    expect(sql).not.toContain('?');
+    expect(params).toEqual(['p-1']);
+  });
+
+  it('buildGetQuery with fields uses $1', () => {
+    const { sql } = buildGetQuery('products', 'p-1', ['id', 'name'], 'postgres');
+    expect(sql).toContain('"id", "name"');
+    expect(sql).toContain('$1');
+  });
+
+  it('buildListQuery no filters → default limit uses $1', () => {
+    const { sql, params } = buildListQuery('products', {}, 'postgres');
+    expect(sql).toContain('LIMIT $1');
+    expect(sql).not.toContain('?');
+    expect(params).toEqual([20]);
+  });
+
+  it('buildListQuery with offset → $1 OFFSET $2', () => {
+    const { sql, params } = buildListQuery('products', {
+      pagination: { limit: 10, offset: 5 },
+    }, 'postgres');
+    expect(sql).toContain('LIMIT $1 OFFSET $2');
+    expect(params).toEqual([10, 5]);
+  });
+
+  it('buildListQuery with filter + limit → correct $N sequence', () => {
+    const { sql, params } = buildListQuery('products', {
+      filters: [['status', '==', 'active']],
+      pagination: { limit: 10, offset: 0 },
+    }, 'postgres');
+    expect(sql).toContain('"status" = $1');
+    expect(sql).toContain('LIMIT $2 OFFSET $3');
+    expect(params).toEqual(['active', 10, 0]);
+  });
+
+  it('buildListQuery with multiple filters → $1, $2, ...', () => {
+    const { sql, params } = buildListQuery('products', {
+      filters: [['status', '==', 'active'], ['price', '>', 100]],
+    }, 'postgres');
+    expect(sql).toContain('"status" = $1');
+    expect(sql).toContain('"price" > $2');
+    expect(sql).toContain('LIMIT $3');
+    expect(params).toEqual(['active', 100, 20]);
+  });
+
+  it('buildListQuery cursor after → $1 for cursor, $2 for limit', () => {
+    const { sql, params } = buildListQuery('products', {
+      pagination: { after: 'cursor-abc', limit: 5 },
+    }, 'postgres');
+    expect(sql).toContain('"id" > $1');
+    expect(sql).toContain('LIMIT $2');
+    expect(params).toEqual(['cursor-abc', 5]);
+  });
+
+  it('buildListQuery cursor before → $1 for cursor, $2 for limit', () => {
+    const { sql, params } = buildListQuery('products', {
+      pagination: { before: 'cursor-xyz', limit: 5 },
+    }, 'postgres');
+    expect(sql).toContain('"id" < $1');
+    expect(sql).toContain('LIMIT $2');
+    expect(params).toEqual(['cursor-xyz', 5]);
+  });
+
+  it('buildCountQuery with filter → $1', () => {
+    const { sql, params } = buildCountQuery('products', [['status', '==', 'active']], undefined, 'postgres');
+    expect(sql).toContain('"status" = $1');
+    expect(sql).not.toContain('?');
+    expect(params).toEqual(['active']);
+  });
+
+  it('buildCountQuery no filters → no placeholders', () => {
+    const { sql, params } = buildCountQuery('products', undefined, undefined, 'postgres');
+    expect(sql).toBe('SELECT COUNT(*) as total FROM "products"');
+    expect(params).toEqual([]);
+  });
+});
+
+// ─── B. PostgreSQL dialect — contains operator (ILIKE) ────────────────────────
+
+describe('PostgreSQL dialect — contains operator', () => {
+  it('contains uses ILIKE instead of INSTR', () => {
+    const { sql, params } = buildListQuery('products', {
+      filters: [['name', 'contains', 'widget']],
+    }, 'postgres');
+    expect(sql).toContain("ILIKE '%' || $1 || '%'");
+    expect(sql).not.toContain('INSTR');
+    expect(params).toContain('widget');
+  });
+
+  it('SQLite contains still uses INSTR (default dialect)', () => {
+    const { sql } = buildListQuery('products', {
+      filters: [['name', 'contains', 'widget']],
+    });
+    expect(sql).toContain('INSTR("name", ?) > 0');
+    expect(sql).not.toContain('ILIKE');
+  });
+});
+
+// ─── C. PostgreSQL dialect — IN operator ─────────────────────────────────────
+
+describe('PostgreSQL dialect — IN operator', () => {
+  it('in → IN ($1, $2, $3)', () => {
+    const { sql, params } = buildListQuery('products', {
+      filters: [['status', 'in', ['a', 'b', 'c']]],
+    }, 'postgres');
+    expect(sql).toContain('IN ($1, $2, $3)');
+    expect(params).toContain('a');
+    expect(params).toContain('b');
+    expect(params).toContain('c');
+  });
+
+  it('not in → NOT IN ($1, $2)', () => {
+    const { sql } = buildListQuery('products', {
+      filters: [['status', 'not in', ['deleted', 'spam']]],
+    }, 'postgres');
+    expect(sql).toContain('NOT IN ($1, $2)');
+  });
+});
+
+// ─── D. PostgreSQL dialect — OR filters ───────────────────────────────────────
+
+describe('PostgreSQL dialect — OR filters', () => {
+  it('OR filters use $N placeholders', () => {
+    const { sql, params } = buildListQuery('products', {
+      orFilters: [['a', '==', 'v1'], ['b', '==', 'v2']],
+    }, 'postgres');
+    expect(sql).toContain('$1');
+    expect(sql).toContain('$2');
+    expect(sql).toContain('OR');
+    expect(sql).not.toContain('?');
+    expect(params).toContain('v1');
+    expect(params).toContain('v2');
+  });
+
+  it('AND + OR combined with $N', () => {
+    const { sql, params } = buildListQuery('products', {
+      filters: [['category', '==', 'tech']],
+      orFilters: [['status', '==', 'draft'], ['status', '==', 'pub']],
+    }, 'postgres');
+    expect(sql).toContain('"category" = $1');
+    expect(sql).toContain('$2');
+    expect(sql).toContain('$3');
+    expect(sql).toContain('AND');
+    expect(sql).toContain('OR');
+    expect(params).toContain('tech');
+    expect(params).toContain('draft');
+    expect(params).toContain('pub');
+  });
+});
+
+// ─── E. PostgreSQL dialect — search (ILIKE, no FTS5) ──────────────────────────
+
+describe('PostgreSQL dialect — search', () => {
+  it('buildListQuery search serializes the row instead of casting the table name', () => {
+    const { sql, params } = buildListQuery('products', {
+      search: 'widget',
+      filters: [['status', '==', 'active']],
+      pagination: { limit: 10 },
+    }, 'postgres');
+    expect(sql).toContain('to_jsonb("products")::text ILIKE');
+    expect(sql).toContain('"status" = $1');
+    expect(sql).toContain('LIMIT $3 OFFSET $4');
+    expect(params).toEqual(['active', 'widget', 10, 0]);
+  });
+
+  it('uses ILIKE instead of FTS5 MATCH', () => {
+    const { sql, params } = buildSearchQuery('products', 'widget', {
+      ftsFields: ['name', 'description'],
+    }, 'postgres');
+    expect(sql).toContain('ILIKE');
+    expect(sql).not.toContain('MATCH');
+    expect(sql).not.toContain('_fts');
+    expect(sql).not.toContain('highlight(');
+    expect(params).toContain('widget');
+  });
+
+  it('search with no ftsFields uses id as default search field', () => {
+    const { sql } = buildSearchQuery('products', 'query', undefined, 'postgres');
+    expect(sql).toContain('"id"::text ILIKE');
+  });
+
+  it('search ILIKE produces OR conditions for multiple fields', () => {
+    const { sql } = buildSearchQuery('products', 'q', {
+      ftsFields: ['name', 'description', 'sku'],
+    }, 'postgres');
+    expect(sql).toContain('OR');
+    expect(sql).toContain('"name"::text ILIKE');
+    expect(sql).toContain('"description"::text ILIKE');
+    expect(sql).toContain('"sku"::text ILIKE');
+  });
+
+  it('search params: one per field + limit + offset', () => {
+    const { params } = buildSearchQuery('products', 'q', {
+      ftsFields: ['name', 'description'],
+      limit: 10,
+      offset: 5,
+    }, 'postgres');
+    // 2 fields + limit + offset
+    expect(params).toEqual(['q', 'q', 10, 5]);
+  });
+
+  it('search uses $N placeholders', () => {
+    const { sql } = buildSearchQuery('products', 'q', {
+      ftsFields: ['name'],
+      limit: 10,
+      offset: 0,
+    }, 'postgres');
+    expect(sql).toContain('$1');
+    expect(sql).toContain('$2');
+    expect(sql).toContain('$3');
+    expect(sql).not.toContain('?');
+  });
+
+  it('SQLite search still uses FTS5 (default dialect)', () => {
+    const { sql } = buildSearchQuery('products', 'widget');
+    expect(sql).toContain('MATCH ?');
+    expect(sql).toContain('_fts');
+  });
+});
+
+// ─── F. PostgreSQL dialect — countSql consistency ─────────────────────────────
+
+describe('PostgreSQL dialect — countSql', () => {
+  it('countSql uses independent $N sequence', () => {
+    const { countSql, countParams } = buildListQuery('products', {
+      filters: [['status', '==', 'active']],
+    }, 'postgres');
+    // countSql gets its own BindTracker, so starts at $1
+    expect(countSql).toContain('"status" = $1');
+    expect(countParams).toEqual(['active']);
+  });
+
+  it('no countSql for cursor pagination (postgres)', () => {
+    const { countSql } = buildListQuery('products', {
+      pagination: { after: 'c1' },
+    }, 'postgres');
+    expect(countSql).toBeUndefined();
+  });
+
+  it('countSql no filters → no WHERE (postgres)', () => {
+    const { countSql } = buildListQuery('products', {}, 'postgres');
+    expect(countSql).not.toContain('WHERE');
+  });
+
+  it('countSql includes postgres search predicates', () => {
+    const { countSql, countParams } = buildListQuery('products', {
+      filters: [['status', '==', 'active']],
+      search: 'widget',
+    }, 'postgres');
+    expect(countSql).toContain('"status" = $1');
+    expect(countSql).toContain('to_jsonb("products")::text ILIKE');
+    expect(countParams).toEqual(['active', 'widget']);
+  });
+});
+
+// ─── G. Default dialect behavior ───────────────────────────────────────────────
+
+describe('default dialect behavior', () => {
+  it('buildGetQuery default → sqlite (? placeholder)', () => {
+    const { sql } = buildGetQuery('t', 'id-1');
+    expect(sql).toContain('?');
+    expect(sql).not.toContain('$');
+  });
+
+  it('buildListQuery default → sqlite', () => {
+    const { sql } = buildListQuery('t', {});
+    expect(sql).toContain('?');
+    expect(sql).not.toContain('$');
+  });
+
+  it('buildCountQuery default → sqlite', () => {
+    const { sql } = buildCountQuery('t', [['a', '==', 1]]);
+    expect(sql).toContain('?');
+    expect(sql).not.toContain('$');
+  });
+
+  it('buildSearchQuery default → sqlite (FTS5)', () => {
+    const { sql } = buildSearchQuery('t', 'q');
+    expect(sql).toContain('MATCH ?');
+  });
+});
+
+// ─── H. executePostgresQuery — export validation ─────────────────────────────
+
+describe('executePostgresQuery', () => {
+  it('is a function', () => {
+    expect(typeof executePostgresQuery).toBe('function');
+  });
+
+  it('rejects invalid connection string', async () => {
+    // pg Client connect will fail against an unreachable host.
+    // Use connect_timeout=1 to fail quickly instead of default timeout.
+    await expect(
+      executePostgresQuery('postgres://user:pass@127.0.0.1:1/db?connect_timeout=1', 'SELECT 1', []),
+    ).rejects.toThrow();
+  }, 10_000);
+});

package/src/__tests__/postgres-executor.test.ts

@@ -0,0 +1,79 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+function mockPgClient() {
+  const connect = vi.fn().mockResolvedValue(undefined);
+  const query = vi.fn();
+  const end = vi.fn().mockResolvedValue(undefined);
+  const Client = vi.fn(() => ({
+    connect,
+    query,
+    end,
+  }));
+
+  vi.doMock('pg', () => ({ Client }));
+
+  return { Client, connect, query, end };
+}
+
+describe('postgres executor helpers', () => {
+  afterEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    vi.doUnmock('pg');
+  });
+
+  it('executes a query and normalizes result metadata', async () => {
+    const pg = mockPgClient();
+    pg.query.mockResolvedValue({
+      fields: [{ name: 'id' }, { name: 'title' }],
+      rows: [{ id: 'post-1', title: 'Hello' }],
+      rowCount: 1,
+    });
+
+    const { executePostgresQuery } = await import('../lib/postgres-executor.js');
+    const result = await executePostgresQuery('postgres://edgebase:test@localhost/db', 'SELECT * FROM posts');
+
+    expect(pg.Client).toHaveBeenCalledWith({ connectionString: 'postgres://edgebase:test@localhost/db' });
+    expect(pg.connect).toHaveBeenCalledTimes(1);
+    expect(pg.query).toHaveBeenCalledWith('SELECT * FROM posts', []);
+    expect(pg.end).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({
+      columns: ['id', 'title'],
+      rows: [{ id: 'post-1', title: 'Hello' }],
+      rowCount: 1,
+    });
+  });
+
+  it('reuses a single client within withPostgresConnection and exposes a query helper', async () => {
+    const pg = mockPgClient();
+    pg.query.mockResolvedValue({
+      fields: [{ name: 'id' }],
+      rows: [{ id: 'row-1' }],
+      rowCount: 1,
+    });
+
+    const {
+      _resetPostgresPoolCache,
+      getProviderBindingName,
+      withPostgresConnection,
+    } = await import('../lib/postgres-executor.js');
+
+    await expect(_resetPostgresPoolCache()).resolves.toBeUndefined();
+    expect(getProviderBindingName('tenant-app')).toBe('DB_POSTGRES_TENANT_APP');
+
+    const result = await withPostgresConnection(
+      'postgres://edgebase:test@localhost/db',
+      async (query) => query('SELECT * FROM posts WHERE id = $1', ['row-1']),
+    );
+
+    expect(pg.Client).toHaveBeenCalledWith({ connectionString: 'postgres://edgebase:test@localhost/db' });
+    expect(pg.connect).toHaveBeenCalledTimes(1);
+    expect(pg.query).toHaveBeenCalledWith('SELECT * FROM posts WHERE id = $1', ['row-1']);
+    expect(pg.end).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({
+      columns: ['id'],
+      rows: [{ id: 'row-1' }],
+      rowCount: 1,
+    });
+  });
+});

package/src/__tests__/postgres-field-ops-compat.test.ts

@@ -0,0 +1,222 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { defineConfig } from '@edge-base/shared';
+import { buildInternalHandlerContext } from '../lib/internal-request.js';
+import type { Env } from '../types.js';
+
+describe('postgres field operator compatibility', () => {
+  afterEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it.each(['PATCH', 'PUT'])('translates %s field operators into PostgreSQL update SQL', async (method) => {
+    const executePostgresQuery = vi.fn()
+      .mockResolvedValueOnce({
+        rows: [{
+          id: 'post-1',
+          viewCount: 1,
+          avatar: 'old.png',
+        }],
+        rowCount: 1,
+      })
+      .mockResolvedValueOnce({
+        rows: [{
+          id: 'post-1',
+          viewCount: 2,
+          avatar: null,
+        }],
+        rowCount: 1,
+      });
+
+    vi.doMock('../lib/postgres-executor.js', () => ({
+      executePostgresQuery,
+      ensureLocalDevPostgresSchema: vi.fn().mockResolvedValue(undefined),
+      withPostgresConnection: vi.fn(async (_connectionString, fn) =>
+        fn((sql: string, params: unknown[] = []) => executePostgresQuery(_connectionString, sql, params))),
+      getLocalDevPostgresExecOptions: vi.fn(() => undefined),
+      getProviderBindingName: () => 'DB_SHARED',
+    }));
+    vi.doMock('../lib/postgres-schema-init.js', () => ({
+      ensurePgSchema: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { handlePgRequest } = await import('../lib/postgres-handler.js');
+
+    const env = {
+      EDGEBASE_CONFIG: defineConfig({
+        release: true,
+        databases: {
+          shared: {
+            provider: 'postgres',
+            connectionString: 'DB_POSTGRES_SHARED_URL',
+            tables: {
+              posts: {
+                schema: {
+                  title: { type: 'string' },
+                  viewCount: { type: 'number' },
+                  avatar: { type: 'string' },
+                },
+                access: {
+                  update: () => true,
+                },
+              },
+            },
+          },
+        },
+      }),
+      DB_POSTGRES_SHARED_URL: 'postgres://edgebase:test@localhost/shared',
+    } as unknown as Env;
+
+    const request = new Request(
+      'http://internal/api/db/shared/tables/posts/post-1',
+      {
+        method,
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Is-Service-Key': 'true',
+        },
+      },
+    );
+
+    const ctx = buildInternalHandlerContext({
+      env,
+      request,
+      body: {
+        viewCount: { $op: 'increment', value: 1 },
+        avatar: { $op: 'deleteField' },
+      },
+    });
+
+    const response = await handlePgRequest(ctx, 'shared', 'posts', '/tables/posts/post-1');
+    expect(response.status).toBe(200);
+    expect(executePostgresQuery).toHaveBeenCalledTimes(2);
+
+    const updateSql = executePostgresQuery.mock.calls[1][1] as string;
+    const updateParams = executePostgresQuery.mock.calls[1][2] as unknown[];
+
+    expect(updateSql).toContain('"viewCount" = COALESCE("viewCount", 0) + $1');
+    expect(updateSql).toContain('"avatar" = NULL');
+    expect(updateSql).toContain('"updatedAt" = $2');
+    expect(updateSql).toContain('WHERE "id" = $3');
+    expect(updateParams[0]).toBe(1);
+    expect(typeof updateParams[1]).toBe('string');
+    expect(updateParams[2]).toBe('post-1');
+  });
+
+  it('translates batch-by-filter update field operators into PostgreSQL update SQL', async () => {
+    const executePostgresQuery = vi.fn()
+      .mockResolvedValueOnce({
+        rows: [{ id: 'post-1' }],
+        rowCount: 1,
+      })
+      .mockResolvedValueOnce({
+        rows: [{
+          id: 'post-1',
+          viewCount: 3,
+          avatar: null,
+        }],
+        rowCount: 1,
+      });
+
+    vi.doMock('../lib/postgres-executor.js', () => ({
+      executePostgresQuery,
+      ensureLocalDevPostgresSchema: vi.fn().mockResolvedValue(undefined),
+      withPostgresConnection: vi.fn(async (_connectionString, fn) =>
+        fn((sql: string, params: unknown[] = []) => executePostgresQuery(_connectionString, sql, params))),
+      getLocalDevPostgresExecOptions: vi.fn(() => undefined),
+      getProviderBindingName: () => 'DB_SHARED',
+    }));
+    vi.doMock('../lib/postgres-schema-init.js', () => ({
+      ensurePgSchema: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { handlePgRequest } = await import('../lib/postgres-handler.js');
+
+    const env = {
+      EDGEBASE_CONFIG: defineConfig({
+        release: true,
+        databases: {
+          shared: {
+            provider: 'postgres',
+            connectionString: 'DB_POSTGRES_SHARED_URL',
+            tables: {
+              posts: {
+                schema: {
+                  viewCount: { type: 'number' },
+                  avatar: { type: 'string' },
+                },
+                access: {
+                  update: () => true,
+                },
+              },
+            },
+          },
+        },
+      }),
+      DB_POSTGRES_SHARED_URL: 'postgres://edgebase:test@localhost/shared',
+    } as unknown as Env;
+
+    const request = new Request(
+      'http://internal/api/db/shared/tables/posts/batch-by-filter',
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Is-Service-Key': 'true',
+        },
+      },
+    );
+
+    const waitUntil = vi.fn();
+    const executionCtx = { waitUntil } as unknown as ExecutionContext;
+    const ctx = buildInternalHandlerContext({
+      env,
+      request,
+      executionCtx,
+      body: {
+        action: 'update',
+        filter: [['id', '==', 'post-1']],
+        update: {
+          viewCount: { $op: 'increment', value: 2 },
+          avatar: { $op: 'deleteField' },
+        },
+      },
+    });
+
+    const response = await handlePgRequest(ctx, 'shared', 'posts', '/tables/posts/batch-by-filter');
+    const json = await response.json() as {
+      processed: number;
+      succeeded: number;
+      updated: number;
+      items: Array<Record<string, unknown>>;
+    };
+
+    expect(response.status).toBe(200);
+    expect(json).toMatchObject({
+      processed: 1,
+      succeeded: 1,
+      updated: 1,
+    });
+    expect(executePostgresQuery).toHaveBeenCalledTimes(2);
+
+    const selectSql = executePostgresQuery.mock.calls[0][1] as string;
+    const selectParams = executePostgresQuery.mock.calls[0][2] as unknown[];
+    expect(selectSql).toContain('SELECT "posts"."id" FROM "posts"');
+    expect(selectSql).toContain('WHERE "id" = $1');
+    expect(selectSql).toContain('LIMIT $2');
+    expect(selectSql).toContain('OFFSET $3');
+    expect(selectParams).toEqual(['post-1', 500, 0]);
+
+    const updateSql = executePostgresQuery.mock.calls[1][1] as string;
+    const updateParams = executePostgresQuery.mock.calls[1][2] as unknown[];
+
+    expect(updateSql).toContain('SET "viewCount" = COALESCE("viewCount", 0) + $2, "avatar" = NULL');
+    expect(updateSql).toContain('"updatedAt" = $3');
+    expect(updateSql).toContain('WHERE "id" IN ($1)');
+    expect(updateParams[0]).toBe('post-1');
+    expect(updateParams[1]).toBe(2);
+    expect(typeof updateParams[2]).toBe('string');
+    expect(waitUntil).toHaveBeenCalledTimes(1);
+  });
+});