orez 0.2.27 → 0.2.30

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

@@ -1,69 +0,0 @@
-/**
- * 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

@@ -1,171 +0,0 @@
-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

@@ -1,161 +0,0 @@
-/**
- * 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

@@ -1,102 +0,0 @@
-/**
- * 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)
-})