orez 0.2.27 → 0.2.30

package/src/pg-sqlite-compiler/index.ts

@@ -1,73 +0,0 @@
-/**
- * pg-sqlite-compiler — PostgreSQL SQL → SQLite SQL.
- *
- * Single-pass visitor over the libpg_query AST, emitting via pgsql-deparser.
- *
- * Public API:
- *   compile(pgSql, opts?) → { sql, warnings }
- *   compileMany(pgSqls, opts?) → results[]
- */
-import { deparseSync, parseSync } from 'pgsql-parser'
-
-import { runPasses } from './passes/index.js'
-
-import type { CompileOptions, CompileResult, SchemaInfo } from './types.js'
-
-const DEFAULT_VERSION = 170004
-
-const NOOP_SCHEMA: SchemaInfo = {
-  getColumnType: () => undefined,
-  getEnum: () => undefined,
-  isEnumValue: () => false,
-  getTableColumns: () => undefined,
-}
-
-function stripTrailingSemicolon(s: string): string {
-  let i = s.length
-  while (i > 0 && (s[i - 1] === ';' || s[i - 1] === ' ' || s[i - 1] === '\n')) i--
-  return s.slice(0, i)
-}
-
-/**
- * Compile a single PG SQL statement into a SQLite-compatible statement.
- *
- * The compiler is best-effort: it applies the registered passes and emits via
- * pgsql-deparser. Some PG-isms are not translatable; those produce warnings
- * but the SQL is still emitted (caller can decide to reject or run anyway).
- */
-export function compile(pgSql: string, opts: CompileOptions = {}): CompileResult {
-  const schema = opts.schema ?? NOOP_SCHEMA
-  const version = opts.pgVersion ?? DEFAULT_VERSION
-  const passes = opts.passes
-  const warnings: CompileResult['warnings'] = []
-
-  const trimmed = stripTrailingSemicolon(pgSql.trim())
-  if (!trimmed) return { sql: '', warnings }
-
-  // parseSync returns a ParseResult: { version, stmts: [{ stmt: {...} }, ...] }
-  const parsed = parseSync(trimmed) as { version?: number; stmts?: any[] } | any
-  const stmts: any[] = Array.isArray(parsed?.stmts) ? parsed.stmts : []
-  if (stmts.length === 0) {
-    return {
-      sql: trimmed,
-      warnings: [{ kind: 'parse-empty', message: 'no statements parsed' }],
-    }
-  }
-
-  // Run all passes on each top-level RawStmt entry (so passes can walk from root).
-  for (let i = 0; i < stmts.length; i++) {
-    runPasses(stmts[i], { schema, warnings, passes })
-  }
-
-  const emitted = deparseSync({ version: parsed.version ?? version, stmts } as any)
-  return { sql: stripTrailingSemicolon(emitted.trim()), warnings }
-}
-
-export function compileMany(
-  pgSqls: string[],
-  opts: CompileOptions = {}
-): CompileResult[] {
-  return pgSqls.map((s) => compile(s, opts))
-}
-
-export type { CompileOptions, CompileResult, SchemaInfo } from './types.js'

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

@@ -1,136 +0,0 @@
-import Database from '@rocicorp/zero-sqlite3'
-/**
- * Integration test — drives the full pass pipeline against representative
- * chat-app workloads: CREATE TABLE + INSERT + SELECT + catalog probe, all
- * round-tripping through a real @rocicorp/zero-sqlite3 instance.
- *
- * Tests the END-TO-END story: "the compiler turns PG SQL into SQLite SQL
- * that executes correctly against DO storage, including the catalog probes
- * zero-cache makes on startup."
- */
-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, '?')
-}
-
-describe('full compiler pipeline against chat-app workload', () => {
-  it('round-trip: schema → insert → select → catalog probe', () => {
-    const db = new Database(':memory:')
-
-    // 1. CREATE TABLE with PG types — types pass should make these all
-    //    SQLite-valid and the DDL should execute.
-    const ddlStatements = [
-      `CREATE TABLE event (
-        id BIGSERIAL PRIMARY KEY,
-        user_id uuid NOT NULL,
-        "createdAt" timestamp with time zone DEFAULT NOW() NOT NULL,
-        payload jsonb NOT NULL DEFAULT '{}',
-        tags text[] NOT NULL DEFAULT '[]'
-      )`,
-      `CREATE TABLE message (
-        id text PRIMARY KEY,
-        content text NOT NULL,
-        sent_at timestamp DEFAULT NOW() NOT NULL,
-        read boolean NOT NULL DEFAULT false
-      )`,
-    ]
-    for (const s of ddlStatements) {
-      const { sql, warnings } = compile(s)
-      expect(warnings).toEqual([])
-      db.exec(sql)
-    }
-
-    // 2. INSERT + SELECT roundtrip
-    const { sql: insertSql } = compile(
-      'INSERT INTO message (id, content) VALUES ($1, $2)'
-    )
-    db.prepare(rewriteParams(insertSql)).run('m1', 'hello world')
-
-    const { sql: selectSql } = compile(
-      'SELECT id, content, sent_at FROM message WHERE id = $1'
-    )
-    const rows = db.prepare(rewriteParams(selectSql)).all('m1') as any[]
-    expect(rows).toHaveLength(1)
-    expect(rows[0].id).toBe('m1')
-    expect(rows[0].content).toBe('hello world')
-    expect(String(rows[0].sent_at)).toMatch(/^\d{4}-\d{2}-\d{2}/)
-
-    // 3. Catalog seed + probe — zero-cache on startup
-    buildCatalogTables(db, { publications: ['orez_zero_public'] })
-
-    const { sql: catalogSql } = compile(
-      "SELECT relname FROM pg_catalog.pg_class WHERE relkind = 'r' ORDER BY relname"
-    )
-    const catalogRows = db.prepare(rewriteParams(catalogSql)).all() as {
-      relname: string
-    }[]
-    const tableNames = catalogRows.map((r) => r.relname)
-    expect(tableNames).toContain('event')
-    expect(tableNames).toContain('message')
-
-    // 4. information_schema.columns probe
-    const { sql: colSql } = compile(
-      'SELECT column_name, data_type FROM information_schema.columns ' +
-        "WHERE table_name = 'message' ORDER BY ordinal_position"
-    )
-    const cols = db.prepare(rewriteParams(colSql)).all() as {
-      column_name: string
-      data_type: string
-    }[]
-    expect(cols.map((c) => c.column_name)).toEqual(['id', 'content', 'sent_at', 'read'])
-
-    // 5. pg_publication probe
-    const { sql: pubSql } = compile(
-      "SELECT pubname FROM pg_catalog.pg_publication WHERE pubname = 'orez_zero_public'"
-    )
-    const pubs = db.prepare(rewriteParams(pubSql)).all() as { pubname: string }[]
-    expect(pubs).toHaveLength(1)
-    expect(pubs[0].pubname).toBe('orez_zero_public')
-
-    db.close()
-  })
-
-  it('insert with ON CONFLICT + RETURNING', () => {
-    const db = new Database(':memory:')
-    const { sql: ddl } = compile(
-      'CREATE TABLE counter (key text PRIMARY KEY, count integer NOT NULL DEFAULT 0)'
-    )
-    db.exec(ddl)
-
-    const { sql: insertSql } = compile(
-      'INSERT INTO counter (key, count) VALUES ($1, 1) ' +
-        'ON CONFLICT (key) DO UPDATE SET count = counter.count + 1 ' +
-        'RETURNING key, count'
-    )
-    const r1 = db.prepare(rewriteParams(insertSql)).all('hits') as any[]
-    expect(r1).toEqual([{ key: 'hits', count: 1 }])
-    const r2 = db.prepare(rewriteParams(insertSql)).all('hits') as any[]
-    expect(r2).toEqual([{ key: 'hits', count: 2 }])
-    db.close()
-  })
-
-  it('UPDATE with NOW() in SET', () => {
-    const db = new Database(':memory:')
-    const { sql: ddl } = compile(
-      'CREATE TABLE event (id text PRIMARY KEY, "updatedAt" timestamp)'
-    )
-    db.exec(ddl)
-    db.prepare('INSERT INTO event (id) VALUES (?)').run('e1')
-
-    const { sql: updateSql } = compile(
-      'UPDATE event SET "updatedAt" = NOW() WHERE id = $1'
-    )
-    db.prepare(rewriteParams(updateSql)).run('e1')
-
-    const row = db
-      .prepare('SELECT id, "updatedAt" FROM event WHERE id = ?')
-      .get('e1') as any
-    expect(row.id).toBe('e1')
-    expect(String(row.updatedAt)).toMatch(/^\d{4}-\d{2}-\d{2}/)
-    db.close()
-  })
-})

package/src/pg-sqlite-compiler/passes/ast-utils.ts

@@ -1,113 +0,0 @@
-/**
- * AST traversal helpers tailored to the libpg_query output.
- *
- * The official @pgsql/traverse offers two APIs:
- *
- *   walk()  — uses a runtime schema; recurses into both tag-wrapped nodes
- *             ({SelectStmt:...}) AND unwrapped sub-fields (ColumnDef.typeName
- *             is *not* tag-wrapped — it's a plain object). Good for traversal,
- *             but mutation requires keyPath bookkeeping.
- *
- *   visit() — only recurses into tag-wrapped objects with exactly one key.
- *             Misses non-wrapped sub-fields like typeName.
- *
- * For our compiler passes we want: "visit every node of a given tag, AND
- * also visit unwrapped sub-objects that have a known tag-like field set."
- * The simplest reliable approach is a hand-rolled walk: recurse over every
- * object/array, fire callbacks keyed by either (a) the tag wrapper key, or
- * (b) the parent field-name for in-place node types we want to visit
- * (typeName etc.).
- *
- * Each callback gets `(node, parent, key)` so mutation is local: just
- * reassign `parent[key]` (for tag-wrapped) or mutate `node` in place (for
- * unwrapped sub-fields).
- */
-
-export type NodeCallback = (node: any, parent: any, key: string | number) => void
-
-export interface VisitorMap {
-  /**
-   * Tag-wrapped nodes: keyed by the wrapper tag name (FuncCall, SelectStmt,
-   * SQLValueFunction, etc.). The callback receives the *inner* node data.
-   *
-   * Also accepts the synthetic tag names for unwrapped sub-fields listed in
-   * UNWRAPPED_FIELDS — e.g. `TypeName` fires for the value at any
-   * `someParent.typeName` slot.
-   */
-  [tag: string]: NodeCallback | undefined
-}
-
-/**
- * Unwrapped fields: child-key → semantic tag name. When a node has a child
- * field with one of these names whose value is a plain object (no tag wrapper),
- * we fire the corresponding visitor against that value.
- */
-const UNWRAPPED_FIELDS: Record<string, string> = {
-  // ColumnDef.typeName, TypeCast.typeName, etc. are TypeName nodes, not wrapped
-  typeName: 'TypeName',
-  // SelectStmt.fromClause[i] is sometimes a wrapped RangeVar but in some
-  // sub-positions (FROM-list with single table) it appears unwrapped.
-  relation: 'RangeVar',
-}
-
-function fireForChild(
-  visitors: VisitorMap,
-  childKey: string,
-  childValue: any,
-  parent: any
-): void {
-  const tag = UNWRAPPED_FIELDS[childKey]
-  if (!tag) return
-  if (!childValue || typeof childValue !== 'object' || Array.isArray(childValue)) return
-  const cb = visitors[tag]
-  if (cb) cb(childValue, parent, childKey)
-}
-
-/**
- * Walk a node tree firing callbacks. For tag-wrapped nodes ({Tag: data}),
- * the callback fires on `data` (inner) with parent=the wrapper's parent,
- * key=where the wrapper sits. For unwrapped sub-fields (typeName etc.),
- * fires on the object directly with parent=its container, key=field name.
- *
- * Mutation rules:
- *   - tag-wrapped: assign `parent[key] = newWrapper` to replace the node
- *   - unwrapped:   mutate `node` in place (it's already the live object)
- */
-export function walkAst(root: any, visitors: VisitorMap): void {
-  function recurse(node: any, parent: any, key: string | number): void {
-    if (node == null || typeof node !== 'object') return
-
-    if (Array.isArray(node)) {
-      for (let i = 0; i < node.length; i++) recurse(node[i], node, i)
-      return
-    }
-
-    const keys = Object.keys(node)
-
-    // Tag-wrapper case: {Tag: data}
-    if (keys.length === 1 && /^[A-Z]/.test(keys[0])) {
-      const tag = keys[0]
-      const data = node[tag]
-      const cb = visitors[tag]
-      if (cb) cb(data, parent, key)
-      // recurse into the inner data
-      if (data && typeof data === 'object') {
-        for (const childKey of Object.keys(data)) {
-          // fire unwrapped-field visitors BEFORE recursing into the field
-          fireForChild(visitors, childKey, data[childKey], data)
-          recurse(data[childKey], data, childKey)
-        }
-      }
-      return
-    }
-
-    // Non-wrapper object case (already an unwrapped sub-tree). Recurse,
-    // firing unwrapped-field visitors as we encounter named child fields.
-    for (const childKey of keys) {
-      fireForChild(visitors, childKey, node[childKey], node)
-      recurse(node[childKey], node, childKey)
-    }
-  }
-
-  recurse(root, null as any, '' as any)
-}

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

@@ -1,65 +0,0 @@
-import { walkAst } from './ast-utils.js'
-
-/**
- * Catalog pass.
- *
- * Rewrites schema-qualified PG catalog references to the
- * `_orez_catalog__*` namespace (seeded by `catalog/seed.ts` at DO init):
- *
- *   pg_catalog.pg_class       → _orez_catalog__pg_class
- *   information_schema.columns → _orez_catalog__information_schema_columns
- *
- * Why this matters:
- *   zero-cache (and most PG client libraries) probes the PG system catalog
- *   on startup. They always qualify these references with `pg_catalog.` or
- *   `information_schema.` — that's how `search_path` resolution works in PG
- *   and how every generated catalog query (libpq, psql, postgres.js) emits
- *   them.
- *
- * Why we DON'T rewrite bare `pg_class` (no schema):
- *   - it's user-table-namespace ambiguous (an app could legitimately call
- *     a table `pg_user`, `pg_views`, etc.)
- *   - bare catalog refs only resolve in PG via search_path; clients
- *     emitting catalog queries qualify them explicitly. Bare references in
- *     real apps are essentially always user tables.
- *   - silently hijacking them caused WRITE-path bugs (DML against a user
- *     table got routed to a synthetic catalog table) in earlier iterations
- *
- * If a future workload sends bare catalog refs we'll add a per-statement
- * opt-in (e.g. `WHERE rewrite_unqualified_catalog`) rather than a
- * footgun-prone global toggle.
- *
- * Companion module: `catalog/seed.ts` creates the target tables on DO init.
- */
-import type { Pass } from '../types.js'
-
-const CATALOG_PREFIX = '_orez_catalog__'
-const FLATTENED_SCHEMAS = new Set(['information_schema'])
-
-function rewriteRangeVar(node: any): void {
-  // pg_catalog.X — strip schema, prefix relname
-  if (node.schemaname === 'pg_catalog') {
-    node.relname = `${CATALOG_PREFIX}${node.relname}`
-    delete node.schemaname
-    return
-  }
-
-  // information_schema.X — flatten to _orez_catalog__information_schema_X
-  if (FLATTENED_SCHEMAS.has(node.schemaname)) {
-    node.relname = `${CATALOG_PREFIX}${node.schemaname}_${node.relname}`
-    delete node.schemaname
-    return
-  }
-}
-
-export const catalogPass: Pass = {
-  name: 'catalog',
-  run(rawStmt, _ctx) {
-    walkAst(rawStmt, {
-      RangeVar: (node: any) => {
-        if (!node || typeof node !== 'object') return
-        rewriteRangeVar(node)
-      },
-    })
-  },
-}

package/src/pg-sqlite-compiler/passes/datetime.ts

@@ -1,74 +0,0 @@
-import { walkAst } from './ast-utils.js'
-
-/**
- * datetime pass.
- *
- * Rewrites PG datetime functions to SQLite-native equivalents:
- *   NOW()              → CURRENT_TIMESTAMP   (function call → keyword)
- *   CURRENT_TIMESTAMP() → CURRENT_TIMESTAMP  (if it ever parses as a FuncCall)
- *   CURRENT_DATE()     → CURRENT_DATE
- *   CURRENT_TIME()     → CURRENT_TIME
- *   pg_catalog.now()   → CURRENT_TIMESTAMP
- *
- * Why it matters: in SQLite, `DEFAULT NOW()` is rejected because column
- * defaults only accept a small expression grammar. `DEFAULT CURRENT_TIMESTAMP`
- * is accepted everywhere (and is what every "I want NOW() in a default" PG
- * user actually wants).
- *
- * For richer datetime work (EXTRACT, DATE_TRUNC, INTERVAL arithmetic) we'll
- * extend this pass in follow-ups. v1 covers the high-frequency cases.
- */
-import type { Pass } from '../types.js'
-
-function lowerFuncName(funcname: any[] | undefined): string | undefined {
-  if (!funcname || funcname.length === 0) return undefined
-  const last = funcname[funcname.length - 1]
-  const str = last?.String?.sval ?? last?.String?.str
-  return typeof str === 'string' ? str.toLowerCase() : undefined
-}
-
-/**
- * Build a PG `SQLValueFunction` node — this is the canonical AST representation
- * of bareword time keywords like CURRENT_TIMESTAMP / CURRENT_DATE / CURRENT_TIME.
- * The deparser emits these as bareword keywords (no quotes, no parens), and
- * SQLite accepts CURRENT_TIMESTAMP/CURRENT_DATE/CURRENT_TIME as keywords too.
- */
-function svfWrapper(op: string): {
-  SQLValueFunction: { op: string; typmod: number; location: number }
-} {
-  return {
-    SQLValueFunction: { op, typmod: -1, location: 0 },
-  }
-}
-
-export const datetimePass: Pass = {
-  name: 'datetime',
-  run(rawStmt, _ctx) {
-    walkAst(rawStmt, {
-      FuncCall: (node: any, parent: any, key: string | number) => {
-        if (parent == null) return // can't replace a root-positioned FuncCall
-        const name = lowerFuncName(node.funcname)
-        if (!name) return
-        const argless = !node.args || (Array.isArray(node.args) && node.args.length === 0)
-        if (!argless) return
-
-        // Map PG datetime function calls → SQL bareword time keywords. The PG
-        // AST distinguishes function-form (`now()`) from keyword-form
-        // (`CURRENT_TIMESTAMP`) at the parse level; SQLite only accepts the
-        // keyword form in DEFAULT clauses and uniformly elsewhere.
-        if (name === 'now' || name === 'current_timestamp') {
-          parent[key] = svfWrapper('SVFOP_CURRENT_TIMESTAMP')
-          return
-        }
-        if (name === 'current_date') {
-          parent[key] = svfWrapper('SVFOP_CURRENT_DATE')
-          return
-        }
-        if (name === 'current_time') {
-          parent[key] = svfWrapper('SVFOP_CURRENT_TIME')
-          return
-        }
-      },
-    })
-  },
-}

package/src/pg-sqlite-compiler/passes/index.ts

@@ -1,49 +0,0 @@
-import { catalogPass } from './catalog.js'
-import { datetimePass } from './datetime.js'
-import { typesPass } from './types.js'
-
-/**
- * Pass pipeline.
- *
- * Each pass is a focused visitor over the PG AST that mutates nodes in place
- * to make the tree SQLite-emittable. Order matters: type normalization runs
- * first (so other passes see SQLite-native type names), datetime runs after
- * (function-form → SQLValueFunction), catalog rewrites last (after every
- * other pass has stabilized).
- */
-import type { Pass, PassContext } from '../types.js'
-
-export const DEFAULT_PASSES: Pass[] = [
-  typesPass,
-  datetimePass,
-  catalogPass,
-  // future:
-  //   castPass,
-  //   arrayPass,
-  //   jsonPass,
-  //   insertPass,
-]
-
-/**
- * Run all passes on a single top-level RawStmt entry.
- *
- * Input shape: `{ stmt: { TagName: data } }` (a libpg_query RawStmt).
- * Passes use `walkAst()` (in passes/ast-utils.ts) which expects a tag-wrapped
- * node — so we hand them `rawStmt.stmt`, the inner `{ TagName: data }`.
- * Callbacks receive (data, parent, key) and mutate via `parent[key] = ...`.
- */
-export function runPasses(rawStmt: any, ctx: PassContext): void {
-  const stmt = rawStmt?.stmt ?? rawStmt
-  if (!stmt || typeof stmt !== 'object') return
-  const passes = ctx.passes ?? DEFAULT_PASSES
-  for (const pass of passes) {
-    try {
-      pass.run(stmt, ctx)
-    } catch (err: any) {
-      ctx.warnings.push({
-        kind: 'pass-error',
-        message: `pass ${pass.name} threw: ${err.message}`,
-      })
-    }
-  }
-}

package/src/pg-sqlite-compiler/passes/types.ts

@@ -1,156 +0,0 @@
-import { walkAst } from './ast-utils.js'
-
-/**
- * Types pass.
- *
- * Normalizes PG type names in CREATE TABLE / ALTER TABLE / CAST / column
- * defs to SQLite-compatible equivalents:
- *
- *   bigserial / serial    → INTEGER     (and PRIMARY KEY on INTEGER becomes
- *                                        SQLite's rowid alias, equivalent to
- *                                        AUTOINCREMENT for our purposes)
- *   smallserial           → INTEGER
- *   jsonb / json          → TEXT        (stored as JSON text; SQLite json
- *                                        functions operate on TEXT directly)
- *   uuid                  → TEXT
- *   bytea                 → BLOB
- *   varchar / character varying → TEXT  (drop length typmods)
- *   char(N) / character(N)→ TEXT        (drop length typmods)
- *   text                  → TEXT
- *   timestamp / timestamptz / timestamp with time zone → TEXT
- *                                       (stored as ISO; SQLite datetime fns
- *                                        accept ISO text)
- *   date / time / timetz  → TEXT
- *   interval              → TEXT
- *   numeric / decimal     → NUMERIC     (SQLite native affinity; precision/
- *                                        scale typmods dropped)
- *   real / float4         → REAL
- *   double precision / float8 → REAL
- *   integer / int / int4  → INTEGER
- *   bigint / int8         → INTEGER
- *   smallint / int2       → INTEGER
- *   boolean               → INTEGER     (0/1; SQLite has no BOOLEAN type but
- *                                        the BOOLEAN keyword is accepted as
- *                                        affinity)
- *
- * Array types (any T[] with arrayBounds) become TEXT (stored as JSON arrays).
- *
- * pg_catalog.* prefix is stripped (libpg-query adds it canonically; SQLite
- * doesn't know about pg_catalog).
- */
-import type { Pass } from '../types.js'
-
-const TYPE_MAP: Record<string, string> = {
-  // serial → integer (PRIMARY KEY on INTEGER is rowid alias in SQLite)
-  bigserial: 'INTEGER',
-  serial: 'INTEGER',
-  serial4: 'INTEGER',
-  serial8: 'INTEGER',
-  smallserial: 'INTEGER',
-  serial2: 'INTEGER',
-
-  // integer
-  int: 'INTEGER',
-  integer: 'INTEGER',
-  int2: 'INTEGER',
-  int4: 'INTEGER',
-  int8: 'INTEGER',
-  bigint: 'INTEGER',
-  smallint: 'INTEGER',
-
-  // floats
-  real: 'REAL',
-  float4: 'REAL',
-  float8: 'REAL',
-  'double precision': 'REAL',
-  double: 'REAL',
-
-  // numerics — keep affinity name; SQLite parses but ignores precision
-  numeric: 'NUMERIC',
-  decimal: 'NUMERIC',
-
-  // text-ish
-  text: 'TEXT',
-  varchar: 'TEXT',
-  'character varying': 'TEXT',
-  bpchar: 'TEXT',
-  character: 'TEXT',
-  char: 'TEXT',
-  name: 'TEXT',
-  citext: 'TEXT',
-
-  // json / structured
-  json: 'TEXT',
-  jsonb: 'TEXT',
-  uuid: 'TEXT',
-  xml: 'TEXT',
-
-  // bin
-  bytea: 'BLOB',
-
-  // bools
-  bool: 'INTEGER',
-  boolean: 'INTEGER',
-
-  // time
-  timestamp: 'TEXT',
-  timestamptz: 'TEXT',
-  'timestamp with time zone': 'TEXT',
-  'timestamp without time zone': 'TEXT',
-  date: 'TEXT',
-  time: 'TEXT',
-  timetz: 'TEXT',
-  'time with time zone': 'TEXT',
-  'time without time zone': 'TEXT',
-  interval: 'TEXT',
-
-  // network / ranges → TEXT for storage compatibility
-  inet: 'TEXT',
-  cidr: 'TEXT',
-  macaddr: 'TEXT',
-  macaddr8: 'TEXT',
-  money: 'NUMERIC',
-}
-
-function extractName(names: any[] | undefined): string | undefined {
-  if (!Array.isArray(names) || names.length === 0) return undefined
-  // strip pg_catalog. prefix if present
-  const last = names[names.length - 1]
-  const sval = last?.String?.sval ?? last?.String?.str
-  return typeof sval === 'string' ? sval.toLowerCase() : undefined
-}
-
-function setTypeName(typeName: any, sqliteName: string): void {
-  typeName.names = [{ String: { sval: sqliteName } }]
-  // drop length/precision typmods
-  delete typeName.typmods
-  // drop array bounds (SQLite has no array type; we store as JSON text)
-  delete typeName.arrayBounds
-}
-
-export const typesPass: Pass = {
-  name: 'types',
-  run(rawStmt, _ctx) {
-    walkAst(rawStmt, {
-      TypeName: (node: any) => {
-        const pgName = extractName(node.names)
-        if (!pgName) return
-        const hasArrayBounds =
-          Array.isArray(node.arrayBounds) && node.arrayBounds.length > 0
-
-        // Array of anything → TEXT
-        if (hasArrayBounds) {
-          setTypeName(node, 'TEXT')
-          return
-        }
-
-        const sqliteName = TYPE_MAP[pgName]
-        if (sqliteName) {
-          setTypeName(node, sqliteName)
-        }
-        // Unknown types we leave alone — let SQLite reject loudly so we know
-        // to add a mapping.
-      },
-    })
-  },
-}