orez 0.2.26 → 0.2.27

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

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

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

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

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

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

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

@@ -0,0 +1,156 @@
+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.
+      },
+    })
+  },
+}