orez 0.2.25 → 0.2.27

package/src/pg-sqlite-compiler/smoke.test.ts

@@ -0,0 +1,69 @@
+/**
+ * Smoke test for the compiler scaffold.
+ *
+ * Validates the pipeline (parse → passes → emit) works end-to-end on a few
+ * representative cases. Real coverage comes from the snapshot + oracle tests.
+ */
+import { describe, expect, it } from 'vitest'
+
+import { compile } from './index.js'
+
+describe('pg-sqlite-compiler smoke', () => {
+  it('passes through trivial select', () => {
+    const { sql, warnings } = compile('SELECT 1 AS ok')
+    expect(warnings).toEqual([])
+    expect(sql).toMatch(/SELECT\s+1\s+AS\s+ok/i)
+  })
+
+  it('rewrites NOW() to CURRENT_TIMESTAMP', () => {
+    const { sql } = compile('SELECT NOW() AS t')
+    expect(sql).toMatch(/CURRENT_TIMESTAMP/i)
+    expect(sql).not.toMatch(/NOW\s*\(/i)
+  })
+
+  it('rewrites NOW() inside CREATE TABLE DEFAULT', () => {
+    const { sql } = compile(
+      'CREATE TABLE event (id text PRIMARY KEY, "createdAt" timestamp DEFAULT NOW() NOT NULL)'
+    )
+    expect(sql).toMatch(/CURRENT_TIMESTAMP/i)
+    expect(sql).not.toMatch(/NOW\s*\(/i)
+  })
+
+  it('passes CURRENT_TIMESTAMP keyword through unchanged', () => {
+    // CURRENT_TIMESTAMP is a SQL bareword, not a function call — should already
+    // round-trip cleanly without our pass touching it.
+    const { sql } = compile('SELECT CURRENT_TIMESTAMP AS t')
+    expect(sql).toMatch(/CURRENT_TIMESTAMP/i)
+  })
+
+  it('rewrites pg_catalog.now() to CURRENT_TIMESTAMP', () => {
+    const { sql } = compile('SELECT pg_catalog.now() AS t')
+    expect(sql).toMatch(/CURRENT_TIMESTAMP/i)
+    expect(sql).not.toMatch(/pg_catalog/i)
+  })
+
+  it('rewrites NOW() in an UPDATE SET clause', () => {
+    const { sql } = compile('UPDATE event SET "updatedAt" = NOW() WHERE id = $1')
+    expect(sql).toMatch(/CURRENT_TIMESTAMP/i)
+    expect(sql).not.toMatch(/now\s*\(/i)
+  })
+
+  it('rewrites CURRENT_DATE used as DEFAULT', () => {
+    const { sql } = compile(
+      'CREATE TABLE log (id text PRIMARY KEY, "day" date DEFAULT CURRENT_DATE NOT NULL)'
+    )
+    expect(sql).toMatch(/CURRENT_DATE/i)
+  })
+
+  it('preserves multi-statement input', () => {
+    const { sql } = compile('SELECT 1; SELECT 2')
+    expect(sql).toMatch(/SELECT\s+1/i)
+    expect(sql).toMatch(/SELECT\s+2/i)
+  })
+
+  it('preserves quoted identifiers', () => {
+    const { sql } = compile('SELECT id, "createdAt" FROM public.message')
+    expect(sql).toMatch(/"createdAt"/)
+    expect(sql).toMatch(/public\.message/i)
+  })
+})

package/src/pg-sqlite-compiler/test/catalog.test.ts

@@ -0,0 +1,171 @@
+import Database from '@rocicorp/zero-sqlite3'
+/**
+ * Catalog pass tests.
+ *
+ * Validates two things in tandem:
+ *   1. The pass rewrites catalog refs to _orez_catalog__* (snapshot-style).
+ *   2. The seed creates matching tables that the rewritten query can
+ *      actually execute against (semantic equivalence with a real catalog).
+ */
+import { describe, expect, it } from 'vitest'
+
+import { buildCatalogTables } from '../catalog/seed.js'
+import { compile } from '../index.js'
+
+function rewriteParams(sql: string): string {
+  return sql.replace(/\$\d+/g, '?')
+}
+
+function freshDb(): { db: any; setup: (s: string[]) => void } {
+  const db = new Database(':memory:')
+  return {
+    db,
+    setup: (statements: string[]) => {
+      for (const s of statements) {
+        const { sql } = compile(s)
+        db.exec(sql)
+      }
+    },
+  }
+}
+
+describe('catalog pass — rewrite', () => {
+  it('pg_catalog.pg_class → _orez_catalog__pg_class', () => {
+    const { sql } = compile('SELECT relname FROM pg_catalog.pg_class WHERE relkind = $1')
+    expect(sql).toMatch(/_orez_catalog__pg_class/)
+    expect(sql).not.toMatch(/pg_catalog\./)
+  })
+
+  it('bare pg_class (no schema) is NOT rewritten — would hijack user tables', () => {
+    // Apps may legitimately have a table called `pg_user`/`pg_views`/etc.
+    // Catalog clients always qualify (`pg_catalog.pg_class`), so the bare
+    // form is treated as a user table.
+    const { sql } = compile('SELECT relname FROM pg_class WHERE relkind = $1')
+    expect(sql).not.toMatch(/_orez_catalog/)
+    expect(sql).toMatch(/FROM pg_class/i)
+  })
+
+  it('information_schema.columns → _orez_catalog__information_schema_columns', () => {
+    const { sql } = compile(
+      "SELECT column_name FROM information_schema.columns WHERE table_name = 't'"
+    )
+    expect(sql).toMatch(/_orez_catalog__information_schema_columns/)
+    expect(sql).not.toMatch(/information_schema\./)
+  })
+
+  it('user table refs (e.g. message) are NOT rewritten', () => {
+    const { sql } = compile('SELECT id FROM message WHERE id = $1')
+    expect(sql).not.toMatch(/_orez_catalog/)
+    expect(sql).toMatch(/FROM message/i)
+  })
+
+  it('information_schema.tables → flat name', () => {
+    const { sql } = compile(
+      "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'"
+    )
+    expect(sql).toMatch(/_orez_catalog__information_schema_tables/)
+  })
+
+  it('schema-qualified pg_publication → flat name', () => {
+    const { sql } = compile(
+      'SELECT pubname FROM pg_catalog.pg_publication WHERE pubname IN ($1)'
+    )
+    expect(sql).toMatch(/_orez_catalog__pg_publication/)
+  })
+
+  it('INSERT INTO pg_user (bare) is NOT rewritten — user-owned table', () => {
+    // Regression guard: earlier iterations rewrote bare PG catalog names,
+    // which silently redirected user DML at synthetic catalog tables.
+    const { sql } = compile('INSERT INTO pg_user (id) VALUES ($1)')
+    expect(sql).not.toMatch(/_orez_catalog/)
+  })
+})
+
+describe('catalog seed + pass roundtrip — executable', () => {
+  it('pg_class returns the user-table rows after seeding', () => {
+    const { db, setup } = freshDb()
+    setup([
+      'CREATE TABLE message (id text PRIMARY KEY, content text)',
+      'CREATE TABLE event (id text PRIMARY KEY, ts timestamp)',
+    ])
+    buildCatalogTables(db)
+    const { sql } = compile(`SELECT relname FROM pg_catalog.pg_class WHERE relkind = 'r'`)
+    const rows = db.prepare(rewriteParams(sql)).all() as { relname: string }[]
+    const names = rows.map((r) => r.relname).sort()
+    expect(names).toContain('message')
+    expect(names).toContain('event')
+    db.close()
+  })
+
+  it('pg_attribute returns column info per table', () => {
+    const { db, setup } = freshDb()
+    setup(['CREATE TABLE message (id text PRIMARY KEY, content text NOT NULL)'])
+    buildCatalogTables(db)
+    const { sql } = compile(`
+      SELECT a.attname, a.attnotnull
+      FROM pg_catalog.pg_attribute a
+      JOIN pg_catalog.pg_class c ON a.attrelid = c.oid
+      WHERE c.relname = 'message'
+      ORDER BY a.attnum
+    `)
+    const rows = db.prepare(rewriteParams(sql)).all() as {
+      attname: string
+      attnotnull: number
+    }[]
+    expect(rows.map((r) => r.attname)).toEqual(['id', 'content'])
+    // `content text NOT NULL` is reported NOT NULL; SQLite's PRAGMA table_info
+    // reports `id text PRIMARY KEY` as NOT NULL only when explicitly written
+    // that way (historical SQLite quirk), so we only check `content` here.
+    expect(rows[1].attnotnull).toBe(1)
+    db.close()
+  })
+
+  it('information_schema.columns returns column metadata', () => {
+    const { db, setup } = freshDb()
+    setup(['CREATE TABLE event (id text PRIMARY KEY, "createdAt" timestamp)'])
+    buildCatalogTables(db)
+    const { sql } = compile(
+      "SELECT column_name, data_type FROM information_schema.columns WHERE table_name = 'event' ORDER BY ordinal_position"
+    )
+    const rows = db.prepare(rewriteParams(sql)).all() as {
+      column_name: string
+      data_type: string
+    }[]
+    expect(rows.map((r) => r.column_name)).toEqual(['id', 'createdAt'])
+    db.close()
+  })
+
+  it('pg_namespace contains public + pg_catalog', () => {
+    const { db, setup } = freshDb()
+    setup([])
+    buildCatalogTables(db)
+    const { sql } = compile('SELECT nspname FROM pg_catalog.pg_namespace ORDER BY oid')
+    const rows = db.prepare(rewriteParams(sql)).all() as { nspname: string }[]
+    expect(rows.map((r) => r.nspname)).toEqual([
+      'pg_catalog',
+      'information_schema',
+      'public',
+    ])
+    db.close()
+  })
+
+  it('pg_publication is populated when ZERO_APP_PUBLICATIONS-style names supplied', () => {
+    const { db, setup } = freshDb()
+    setup(['CREATE TABLE message (id text PRIMARY KEY)'])
+    buildCatalogTables(db, { publications: ['orez_zero_public'] })
+    const { sql } = compile('SELECT pubname FROM pg_catalog.pg_publication')
+    const rows = db.prepare(rewriteParams(sql)).all() as { pubname: string }[]
+    expect(rows.map((r) => r.pubname)).toEqual(['orez_zero_public'])
+
+    const { sql: sql2 } = compile(
+      "SELECT pubname, tablename FROM pg_catalog.pg_publication_tables WHERE pubname = 'orez_zero_public'"
+    )
+    const ptRows = db.prepare(rewriteParams(sql2)).all() as {
+      pubname: string
+      tablename: string
+    }[]
+    expect(ptRows.length).toBeGreaterThanOrEqual(1)
+    expect(ptRows[0].tablename).toBe('message')
+    db.close()
+  })
+})

package/src/pg-sqlite-compiler/test/corpus.test.ts

@@ -0,0 +1,161 @@
+/**
+ * Corpus tests — run every vendored pgsqlite fixture through the compiler.
+ *
+ * Asserts the compiler doesn't throw for fixtures in each bucket, against a
+ * per-bucket **minimum-passing-count ratchet** (`BASELINE_OK`). Pass rates
+ * are already 94–100% — a flat 50% floor would silently mask real
+ * regressions. The ratchet is in absolute counts (not percentages) so adding
+ * new fixtures to a bucket can't make the threshold easier to clear.
+ *
+ * Bumping a baseline: improve coverage, run the test, copy the new count
+ * from the summary table into `BASELINE_OK`. Never lower a baseline without
+ * understanding *why* — that's the regression alarm.
+ *
+ * Specific buckets have their own oracle tests (datetime.oracle.test.ts,
+ * etc.) that check translation correctness in detail.
+ */
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import { describe, expect, it } from 'vitest'
+
+import { compile } from '../index.js'
+
+const FIXTURES_DIR = resolve(import.meta.dirname, '..', 'fixtures', 'pgsqlite')
+
+interface BucketFixture {
+  source: string
+  bucket: string
+  count: number
+  cases: { name: string; sql: string; source: string }[]
+}
+
+function loadBucket(bucket: string): BucketFixture {
+  return JSON.parse(readFileSync(resolve(FIXTURES_DIR, `${bucket}.json`), 'utf-8'))
+}
+
+const BUCKETS = [
+  'datetime',
+  'array',
+  'cast',
+  'json',
+  'catalog',
+  'enum',
+  'create-table',
+  'insert',
+  'arithmetic',
+  'misc',
+]
+
+/**
+ * Minimum non-throwing fixture count per bucket. The corpus today passes at
+ * 99.2% overall; these baselines lock that in. Bump (never lower) when
+ * coverage improves.
+ */
+const BASELINE_OK: Record<string, number> = {
+  arithmetic: 60,
+  array: 74,
+  cast: 1,
+  catalog: 87,
+  'create-table': 5,
+  datetime: 74,
+  enum: 66,
+  insert: 65,
+  json: 106,
+  misc: 365,
+}
+
+interface BucketResult {
+  bucket: string
+  total: number
+  parseOk: number
+  compileOk: number
+  // examples of failures (first 5) — useful when diagnosing regressions
+  failures: { name: string; sql: string; error: string }[]
+}
+
+const results: BucketResult[] = []
+
+describe('pgsqlite corpus survival', () => {
+  for (const bucket of BUCKETS) {
+    describe(bucket, () => {
+      let fixture: BucketFixture
+      try {
+        fixture = loadBucket(bucket)
+      } catch {
+        it.skip(`fixture missing for ${bucket}`, () => {})
+        return
+      }
+
+      it(`compiles ${fixture.cases.length} cases without throwing`, () => {
+        const result: BucketResult = {
+          bucket,
+          total: fixture.cases.length,
+          parseOk: 0,
+          compileOk: 0,
+          failures: [],
+        }
+        for (const c of fixture.cases) {
+          try {
+            const { sql, warnings } = compile(c.sql)
+            if (sql) {
+              result.compileOk++
+              result.parseOk++
+            } else if (warnings.length === 0) {
+              result.compileOk++
+              result.parseOk++
+            }
+          } catch (err: any) {
+            if (result.failures.length < 5) {
+              result.failures.push({
+                name: c.name,
+                sql: c.sql.slice(0, 200),
+                error: (err.message || String(err)).slice(0, 200),
+              })
+            }
+          }
+        }
+        results.push(result)
+        const baseline = BASELINE_OK[bucket] ?? 0
+        if (result.compileOk < baseline) {
+          const sample = result.failures
+            .slice(0, 3)
+            .map((f) => `  - ${f.name}: ${f.error}`)
+            .join('\n')
+          throw new Error(
+            `corpus regression in bucket "${bucket}": got ${result.compileOk}/${result.total} passing, baseline is ${baseline}.\n` +
+              `If this is intentional (e.g. fixture set changed), update BASELINE_OK.\n` +
+              `Sample failures:\n${sample}`
+          )
+        }
+        // also require coverage doesn't collapse against the fixture set
+        expect(result.compileOk).toBeGreaterThanOrEqual(baseline)
+      })
+    })
+  }
+})
+
+// emit a summary table after all tests run
+import { afterAll } from 'vitest'
+afterAll(() => {
+  if (results.length === 0) return
+  console.log('\n========== CORPUS COMPILER SURVIVAL ==========')
+  console.log('bucket         total   ok    pct  example-failures')
+  console.log('--------------------------------------------------')
+  let totalAll = 0
+  let okAll = 0
+  for (const r of results.sort((a, b) => a.bucket.localeCompare(b.bucket))) {
+    const pct = ((r.compileOk / Math.max(1, r.total)) * 100).toFixed(1).padStart(5)
+    const ex = r.failures[0] ? `${r.failures[0].error.slice(0, 50)}` : ''
+    console.log(
+      `${r.bucket.padEnd(14)} ${String(r.total).padStart(5)} ${String(r.compileOk).padStart(5)} ${pct}%  ${ex}`
+    )
+    totalAll += r.total
+    okAll += r.compileOk
+  }
+  console.log('--------------------------------------------------')
+  console.log(
+    `${'TOTAL'.padEnd(14)} ${String(totalAll).padStart(5)} ${String(okAll).padStart(5)} ${((okAll / Math.max(1, totalAll)) * 100).toFixed(1).padStart(5)}%`
+  )
+  console.log('==============================================')
+})

package/src/pg-sqlite-compiler/test/datetime.oracle.test.ts

@@ -0,0 +1,102 @@
+/**
+ * Oracle tests for the datetime pass.
+ *
+ * For each PG query: run it against pgsqlite (oracle) AND through our
+ * compile() + bun:sqlite. Compare result shapes. We don't compare exact
+ * timestamps (CURRENT_TIMESTAMP returns "now" — non-deterministic) — just
+ * that both sides return a row of the same shape with a parseable timestamp.
+ */
+import { describe, expect, it } from 'vitest'
+
+import { compile } from '../index.js'
+import {
+  ORACLE_AVAILABLE,
+  connectOracle,
+  runOracleAndCompiler,
+  startPgsqliteServer,
+} from './oracle.js'
+
+const describeOracle = ORACLE_AVAILABLE ? describe : describe.skip
+
+describeOracle('datetime pass against pgsqlite oracle', () => {
+  it('NOW() in SELECT — both sides return a timestamp', async () => {
+    const { oracle, ours } = await runOracleAndCompiler([], 'SELECT NOW() AS t')
+    expect(oracle).toHaveLength(1)
+    expect(ours).toHaveLength(1)
+    // both should expose 't' with something Date-parseable
+    const ot = String((oracle[0] as any).t)
+    const ut = String((ours[0] as any).t)
+    expect(Number.isNaN(Date.parse(ot))).toBe(false)
+    expect(Number.isNaN(Date.parse(ut))).toBe(false)
+  }, 30_000)
+
+  /**
+   * pgsqlite has a known bug here: it rewrites `DEFAULT NOW()` →
+   * `DEFAULT datetime('now')`, which isn't valid in a SQLite CREATE TABLE
+   * DEFAULT clause (only a small expression grammar is permitted). Our
+   * compiler rewrites to `DEFAULT CURRENT_TIMESTAMP` which IS valid.
+   *
+   * So this test validates *our* side standalone; if pgsqlite ever fixes
+   * this bug, we can promote it to a full oracle test.
+   */
+  it('NOW() in CREATE TABLE DEFAULT — ours works (pgsqlite has a known bug here)', async () => {
+    // @ts-expect-error — test-only sqlite driver
+    const { default: Database } = await import('@rocicorp/zero-sqlite3')
+    const db = new Database(':memory:')
+    const { sql: c1 } = compile(
+      'CREATE TABLE event (id text PRIMARY KEY, ts timestamp DEFAULT NOW() NOT NULL)'
+    )
+    db.exec(c1)
+    db.prepare('INSERT INTO event (id) VALUES (?)').run('e1')
+    const ours = db.prepare('SELECT id, ts FROM event WHERE id = ?').all('e1') as any[]
+    db.close()
+    expect(ours).toHaveLength(1)
+    expect(ours[0].id).toBe('e1')
+    expect(String(ours[0].ts)).toMatch(/^\d{4}-\d{2}-\d{2}/)
+  })
+
+  it('CURRENT_DATE in DEFAULT — both sides accept', async () => {
+    const server = await startPgsqliteServer()
+    try {
+      const conn = await connectOracle(server)
+      try {
+        await conn.exec(
+          'CREATE TABLE log (id text PRIMARY KEY, day date DEFAULT CURRENT_DATE NOT NULL)'
+        )
+        await conn.exec('INSERT INTO log (id) VALUES ($1)', ['l1'])
+        const oracle = (await conn.exec('SELECT id, day FROM log WHERE id = $1', [
+          'l1',
+        ])) as any[]
+
+        // @ts-expect-error — test-only sqlite driver
+        const { default: Database } = await import('@rocicorp/zero-sqlite3')
+        const db = new Database(':memory:')
+        const { sql: c1 } = compile(
+          'CREATE TABLE log (id text PRIMARY KEY, day date DEFAULT CURRENT_DATE NOT NULL)'
+        )
+        db.exec(c1)
+        db.prepare('INSERT INTO log (id) VALUES (?)').run('l1')
+        const ours = db.prepare('SELECT id, day FROM log WHERE id = ?').all('l1') as any[]
+        db.close()
+
+        expect(oracle).toHaveLength(1)
+        expect(ours).toHaveLength(1)
+        // postgres.js parses DATE values into JS Date objects; verify both
+        // sides produced a Date-equivalent (today). Don't compare strings —
+        // pgsqlite returns ISO, sqlite returns YYYY-MM-DD, both valid.
+        const oracleDate = new Date(String(oracle[0].day))
+        const ourDate = new Date(String(ours[0].day))
+        expect(Number.isNaN(oracleDate.getTime())).toBe(false)
+        expect(Number.isNaN(ourDate.getTime())).toBe(false)
+        // Within ~24h of each other (allowing for TZ).
+        expect(Math.abs(oracleDate.getTime() - ourDate.getTime())).toBeLessThan(
+          86_400_000
+        )
+      } finally {
+        await conn.end()
+      }
+    } finally {
+      await server.stop()
+    }
+  }, 30_000)
+})