orez 0.2.26 → 0.2.29

package/dist/pg-sqlite-compiler/passes/ast-utils.js

@@ -0,0 +1,93 @@
+/**
+ * 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).
+ */
+/**
+ * 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 = {
+    // 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, childKey, childValue, parent) {
+    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, visitors) {
+    function recurse(node, parent, key) {
+        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, '');
+}
+//# sourceMappingURL=ast-utils.js.map

package/dist/pg-sqlite-compiler/passes/ast-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-utils.js","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/passes/ast-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAgBH;;;;GAIG;AACH,MAAM,gBAAgB,GAA2B;IAC/C,8EAA8E;IAC9E,QAAQ,EAAE,UAAU;IACpB,uEAAuE;IACvE,oEAAoE;IACpE,QAAQ,EAAE,UAAU;CACrB,CAAA;AAED,SAAS,YAAY,CACnB,QAAoB,EACpB,QAAgB,EAChB,UAAe,EACf,MAAW;IAEX,MAAM,GAAG,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAA;IACtC,IAAI,CAAC,GAAG;QAAE,OAAM;IAChB,IAAI,CAAC,UAAU,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC;QAAE,OAAM;IACtF,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAA;IACxB,IAAI,EAAE;QAAE,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAA;AAC1C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,OAAO,CAAC,IAAS,EAAE,QAAoB;IACrD,SAAS,OAAO,CAAC,IAAS,EAAE,MAAW,EAAE,GAAoB;QAC3D,IAAI,IAAI,IAAI,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAM;QAEpD,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE;gBAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAA;YAC/D,OAAM;QACR,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAE9B,gCAAgC;QAChC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAChD,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;YACnB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAA;YACtB,MAAM,EAAE,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAA;YACxB,IAAI,EAAE;gBAAE,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,CAAA;YAC7B,8BAA8B;YAC9B,IAAI,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACrC,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;oBACzC,gEAAgE;oBAChE,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAA;oBACtD,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAA;gBACzC,CAAC;YACH,CAAC;YACD,OAAM;QACR,CAAC;QAED,oEAAoE;QACpE,sEAAsE;QACtE,KAAK,MAAM,QAAQ,IAAI,IAAI,EAAE,CAAC;YAC5B,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAA;YACtD,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAA;QACzC,CAAC;IACH,CAAC;IAED,OAAO,CAAC,IAAI,EAAE,IAAW,EAAE,EAAS,CAAC,CAAA;AACvC,CAAC"}

package/dist/pg-sqlite-compiler/passes/catalog.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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';
+export declare const catalogPass: Pass;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/pg-sqlite-compiler/passes/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/passes/catalog.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAqBvC,eAAO,MAAM,WAAW,EAAE,IAUzB,CAAA"}

package/dist/pg-sqlite-compiler/passes/catalog.js

@@ -0,0 +1,30 @@
+import { walkAst } from './ast-utils.js';
+const CATALOG_PREFIX = '_orez_catalog__';
+const FLATTENED_SCHEMAS = new Set(['information_schema']);
+function rewriteRangeVar(node) {
+    // 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 = {
+    name: 'catalog',
+    run(rawStmt, _ctx) {
+        walkAst(rawStmt, {
+            RangeVar: (node) => {
+                if (!node || typeof node !== 'object')
+                    return;
+                rewriteRangeVar(node);
+            },
+        });
+    },
+};
+//# sourceMappingURL=catalog.js.map

package/dist/pg-sqlite-compiler/passes/catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/passes/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAmCxC,MAAM,cAAc,GAAG,iBAAiB,CAAA;AACxC,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAA;AAEzD,SAAS,eAAe,CAAC,IAAS;IAChC,8CAA8C;IAC9C,IAAI,IAAI,CAAC,UAAU,KAAK,YAAY,EAAE,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,GAAG,cAAc,GAAG,IAAI,CAAC,OAAO,EAAE,CAAA;QACjD,OAAO,IAAI,CAAC,UAAU,CAAA;QACtB,OAAM;IACR,CAAC;IAED,wEAAwE;IACxE,IAAI,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;QAC3C,IAAI,CAAC,OAAO,GAAG,GAAG,cAAc,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,OAAO,EAAE,CAAA;QACpE,OAAO,IAAI,CAAC,UAAU,CAAA;QACtB,OAAM;IACR,CAAC;AACH,CAAC;AAED,MAAM,CAAC,MAAM,WAAW,GAAS;IAC/B,IAAI,EAAE,SAAS;IACf,GAAG,CAAC,OAAO,EAAE,IAAI;QACf,OAAO,CAAC,OAAO,EAAE;YACf,QAAQ,EAAE,CAAC,IAAS,EAAE,EAAE;gBACtB,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;oBAAE,OAAM;gBAC7C,eAAe,CAAC,IAAI,CAAC,CAAA;YACvB,CAAC;SACF,CAAC,CAAA;IACJ,CAAC;CACF,CAAA"}

package/dist/pg-sqlite-compiler/passes/datetime.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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';
+export declare const datetimePass: Pass;
+//# sourceMappingURL=datetime.d.ts.map

package/dist/pg-sqlite-compiler/passes/datetime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.d.ts","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/passes/datetime.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAuBvC,eAAO,MAAM,YAAY,EAAE,IA8B1B,CAAA"}

package/dist/pg-sqlite-compiler/passes/datetime.js

@@ -0,0 +1,53 @@
+import { walkAst } from './ast-utils.js';
+function lowerFuncName(funcname) {
+    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) {
+    return {
+        SQLValueFunction: { op, typmod: -1, location: 0 },
+    };
+}
+export const datetimePass = {
+    name: 'datetime',
+    run(rawStmt, _ctx) {
+        walkAst(rawStmt, {
+            FuncCall: (node, parent, key) => {
+                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;
+                }
+            },
+        });
+    },
+};
+//# sourceMappingURL=datetime.js.map

package/dist/pg-sqlite-compiler/passes/datetime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.js","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/passes/datetime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAsBxC,SAAS,aAAa,CAAC,QAA2B;IAChD,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAA;IACxD,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;IAC1C,MAAM,GAAG,GAAG,IAAI,EAAE,MAAM,EAAE,IAAI,IAAI,IAAI,EAAE,MAAM,EAAE,GAAG,CAAA;IACnD,OAAO,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS,CAAA;AAChE,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,EAAU;IAG5B,OAAO;QACL,gBAAgB,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE;KAClD,CAAA;AACH,CAAC;AAED,MAAM,CAAC,MAAM,YAAY,GAAS;IAChC,IAAI,EAAE,UAAU;IAChB,GAAG,CAAC,OAAO,EAAE,IAAI;QACf,OAAO,CAAC,OAAO,EAAE;YACf,QAAQ,EAAE,CAAC,IAAS,EAAE,MAAW,EAAE,GAAoB,EAAE,EAAE;gBACzD,IAAI,MAAM,IAAI,IAAI;oBAAE,OAAM,CAAC,2CAA2C;gBACtE,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;gBACzC,IAAI,CAAC,IAAI;oBAAE,OAAM;gBACjB,MAAM,OAAO,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAA;gBAClF,IAAI,CAAC,OAAO;oBAAE,OAAM;gBAEpB,sEAAsE;gBACtE,8DAA8D;gBAC9D,oEAAoE;gBACpE,2DAA2D;gBAC3D,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,mBAAmB,EAAE,CAAC;oBACnD,MAAM,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,yBAAyB,CAAC,CAAA;oBACnD,OAAM;gBACR,CAAC;gBACD,IAAI,IAAI,KAAK,cAAc,EAAE,CAAC;oBAC5B,MAAM,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,oBAAoB,CAAC,CAAA;oBAC9C,OAAM;gBACR,CAAC;gBACD,IAAI,IAAI,KAAK,cAAc,EAAE,CAAC;oBAC5B,MAAM,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,oBAAoB,CAAC,CAAA;oBAC9C,OAAM;gBACR,CAAC;YACH,CAAC;SACF,CAAC,CAAA;IACJ,CAAC;CACF,CAAA"}

package/dist/pg-sqlite-compiler/passes/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 declare const DEFAULT_PASSES: Pass[];
+/**
+ * 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 declare function runPasses(rawStmt: any, ctx: PassContext): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/pg-sqlite-compiler/passes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/passes/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEpD,eAAO,MAAM,cAAc,EAAE,IAAI,EAShC,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,WAAW,GAAG,IAAI,CAc9D"}

package/dist/pg-sqlite-compiler/passes/index.js

@@ -0,0 +1,39 @@
+import { catalogPass } from './catalog.js';
+import { datetimePass } from './datetime.js';
+import { typesPass } from './types.js';
+export const DEFAULT_PASSES = [
+    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, ctx) {
+    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) {
+            ctx.warnings.push({
+                kind: 'pass-error',
+                message: `pass ${pass.name} threw: ${err.message}`,
+            });
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/pg-sqlite-compiler/passes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/passes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAatC,MAAM,CAAC,MAAM,cAAc,GAAW;IACpC,SAAS;IACT,YAAY;IACZ,WAAW;IACX,UAAU;IACV,cAAc;IACd,eAAe;IACf,cAAc;IACd,gBAAgB;CACjB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,SAAS,CAAC,OAAY,EAAE,GAAgB;IACtD,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,OAAO,CAAA;IACrC,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAM;IAC7C,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,IAAI,cAAc,CAAA;IAC3C,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;QAC1B,IAAI,CAAC;YACH,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QACrB,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAClB,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAChB,IAAI,EAAE,YAAY;gBAClB,OAAO,EAAE,QAAQ,IAAI,CAAC,IAAI,WAAW,GAAG,CAAC,OAAO,EAAE;aACnD,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/pg-sqlite-compiler/passes/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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';
+export declare const typesPass: Pass;
+//# sourceMappingURL=types.d.ts.map

package/dist/pg-sqlite-compiler/passes/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/passes/types.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AA0FvC,eAAO,MAAM,SAAS,EAAE,IAyBvB,CAAA"}

package/dist/pg-sqlite-compiler/passes/types.js

@@ -0,0 +1,103 @@
+import { walkAst } from './ast-utils.js';
+const TYPE_MAP = {
+    // 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) {
+    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, sqliteName) {
+    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 = {
+    name: 'types',
+    run(rawStmt, _ctx) {
+        walkAst(rawStmt, {
+            TypeName: (node) => {
+                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.
+            },
+        });
+    },
+};
+//# sourceMappingURL=types.js.map

package/dist/pg-sqlite-compiler/passes/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/passes/types.ts"],"names":[],"mappings":"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"}

package/dist/pg-sqlite-compiler/test/oracle.d.ts

@@ -0,0 +1,34 @@
+export declare function pgsqliteBinPath(): string | null;
+export declare const ORACLE_AVAILABLE: boolean;
+export interface OracleServer {
+    port: number;
+    dbPath: string;
+    stop(): Promise<void>;
+}
+/**
+ * Start a pgsqlite server on an OS-assigned ephemeral port with an ephemeral
+ * database. Throws on probe timeout. Caller is responsible for calling
+ * `stop()` in a `finally` / `afterAll` hook — `stop()` awaits child exit
+ * and cleans up the tempdir.
+ */
+export declare function startPgsqliteServer(): Promise<OracleServer>;
+/**
+ * Helper: open a postgres.js client to a running pgsqlite server.
+ * Requires `postgres` to be available (we already ship it via @rocicorp/zero).
+ */
+export declare function connectOracle(server: OracleServer): Promise<{
+    exec: (sql: string, params?: any[]) => Promise<any[]>;
+    end: () => Promise<void>;
+}>;
+/**
+ * Run the same query against pgsqlite (oracle) and our compiler+SQLite (under
+ * test). Return both result sets so the test can diff them however it wants.
+ *
+ * Uses freshly-spawned servers/dbs for each call — slow but isolated. For
+ * batches use the lower-level helpers above.
+ */
+export declare function runOracleAndCompiler(setupSql: string[], pgSql: string, params?: any[]): Promise<{
+    oracle: any[];
+    ours: any[];
+}>;
+//# sourceMappingURL=oracle.d.ts.map

package/dist/pg-sqlite-compiler/test/oracle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oracle.d.ts","sourceRoot":"","sources":["../../../src/pg-sqlite-compiler/test/oracle.ts"],"names":[],"mappings":"AA8BA,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAI/C;AAED,eAAO,MAAM,gBAAgB,SAA6B,CAAA;AAE1D,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACtB;AAgDD;;;;;GAKG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,YAAY,CAAC,CA8DjE;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC;IACjE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;IACrD,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAAC,CAsBD;AAED;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,GAAG,EAAO,GACjB,OAAO,CAAC;IACT,MAAM,EAAE,GAAG,EAAE,CAAA;IACb,IAAI,EAAE,GAAG,EAAE,CAAA;CACZ,CAAC,CA+BD"}