@onreza/sqlx-js 0.0.0

package/dist/src/pg/oids.js

@@ -0,0 +1,137 @@
+const SCALAR = {
+    16: { ts: "boolean" },
+    17: { ts: "Uint8Array" },
+    18: { ts: "string" },
+    19: { ts: "string" },
+    20: { ts: "bigint", bigint: true },
+    21: { ts: "number" },
+    23: { ts: "number" },
+    25: { ts: "string" },
+    26: { ts: "number" },
+    27: { ts: "string" },
+    28: { ts: "string" },
+    29: { ts: "string" },
+    114: { ts: "unknown" },
+    142: { ts: "string" },
+    600: { ts: "string" },
+    601: { ts: "string" },
+    602: { ts: "string" },
+    603: { ts: "string" },
+    604: { ts: "string" },
+    628: { ts: "string" },
+    650: { ts: "string" },
+    700: { ts: "number" },
+    701: { ts: "number" },
+    718: { ts: "string" },
+    774: { ts: "string" },
+    790: { ts: "string" },
+    829: { ts: "string" },
+    869: { ts: "string" },
+    1042: { ts: "string" },
+    1043: { ts: "string" },
+    1082: { ts: "Date" },
+    1083: { ts: "string" },
+    1114: { ts: "Date" },
+    1184: { ts: "Date" },
+    1186: { ts: "string" },
+    1266: { ts: "string" },
+    1560: { ts: "string" },
+    1562: { ts: "string" },
+    1700: { ts: "string" },
+    2950: { ts: "string" },
+    2205: { ts: "string" },
+    2206: { ts: "string" },
+    3220: { ts: "string" },
+    3614: { ts: "string" },
+    3615: { ts: "string" },
+    3802: { ts: "unknown" },
+    3904: { ts: "string" },
+    3906: { ts: "string" },
+    3908: { ts: "string" },
+    3910: { ts: "string" },
+    3912: { ts: "string" },
+    3926: { ts: "string" },
+    4089: { ts: "string" },
+    4096: { ts: "string" },
+    4451: { ts: "string" },
+    4536: { ts: "string" },
+};
+const ARRAY = {
+    143: 142,
+    199: 114,
+    629: 628,
+    651: 650,
+    719: 718,
+    775: 774,
+    791: 790,
+    1000: 16,
+    1001: 17,
+    1002: 18,
+    1003: 19,
+    1005: 21,
+    1007: 23,
+    1009: 25,
+    1014: 1042,
+    1015: 1043,
+    1016: 20,
+    1017: 600,
+    1018: 601,
+    1019: 602,
+    1020: 603,
+    1021: 700,
+    1022: 701,
+    1027: 604,
+    1028: 26,
+    1040: 829,
+    1041: 869,
+    1115: 1114,
+    1182: 1082,
+    1183: 1083,
+    1185: 1184,
+    1187: 1186,
+    1231: 1700,
+    1270: 1266,
+    1561: 1560,
+    1563: 1562,
+    2951: 2950,
+    3221: 3220,
+    3643: 3614,
+    3644: 3615,
+    3807: 3802,
+    3905: 3904,
+    3907: 3906,
+    3909: 3908,
+    3911: 3910,
+    3913: 3912,
+    3927: 3926,
+    6150: 4451,
+    6157: 4536,
+};
+export function oidToTs(oid) {
+    const direct = SCALAR[oid];
+    if (direct)
+        return direct;
+    const inner = ARRAY[oid];
+    if (inner !== undefined) {
+        const t = SCALAR[inner];
+        return { ts: `(${t?.ts ?? "unknown"})[]`, bigint: t?.bigint };
+    }
+    return { ts: "unknown" };
+}
+export function isBuiltinOid(oid) {
+    return SCALAR[oid] !== undefined || ARRAY[oid] !== undefined;
+}
+export function builtinArrayOids() {
+    return Object.keys(ARRAY).map(Number);
+}
+export function arrayElementOid(oid) {
+    return ARRAY[oid];
+}
+export function makeResolver(custom) {
+    return (oid) => {
+        const c = custom(oid);
+        if (c !== undefined)
+            return c;
+        return oidToTs(oid).ts;
+    };
+}

package/dist/src/pg/param-map.d.ts

@@ -0,0 +1,12 @@
+export type ParamTarget = {
+    schema?: string;
+    table: string;
+    column: string;
+};
+export type ParamMap = Map<number, ParamTarget>;
+export type ParamMapResult = {
+    targets: ParamMap;
+    forceNullable: Set<number>;
+    dmlBound: Set<number>;
+};
+export declare function buildParamMap(sql: string): Promise<ParamMapResult>;

package/dist/src/pg/param-map.js

@@ -0,0 +1,180 @@
+import { parse } from "libpg-query";
+export async function buildParamMap(sql) {
+    const targets = new Map();
+    const forceNullable = new Set();
+    const dmlBound = new Set();
+    const ast = await parse(sql);
+    const stmt = ast?.stmts?.[0]?.stmt;
+    if (!stmt)
+        return { targets, forceNullable, dmlBound };
+    if (stmt.InsertStmt)
+        walkInsert(stmt.InsertStmt, targets, dmlBound);
+    else if (stmt.UpdateStmt)
+        walkUpdate(stmt.UpdateStmt, targets, dmlBound);
+    else if (stmt.SelectStmt)
+        walkWhere(stmt.SelectStmt.whereClause, defaultRel(stmt.SelectStmt), targets);
+    else if (stmt.DeleteStmt)
+        walkWhere(stmt.DeleteStmt.whereClause, relOf(stmt.DeleteStmt.relation), targets);
+    walkForceNullable(stmt, false, forceNullable);
+    return { targets, forceNullable, dmlBound };
+}
+function walkInsert(ins, map, dmlBound) {
+    const rel = relOf(ins.relation);
+    if (!rel)
+        return;
+    const cols = (ins.cols ?? [])
+        .map((c) => c?.ResTarget?.name)
+        .filter((n) => typeof n === "string");
+    const valuesLists = ins.selectStmt?.SelectStmt?.valuesLists ?? [];
+    for (const row of valuesLists) {
+        const items = row?.List?.items ?? [];
+        for (let i = 0; i < items.length; i++) {
+            const colName = cols[i];
+            if (!colName)
+                continue;
+            const pn = paramNumber(items[i]);
+            if (pn !== null) {
+                map.set(pn, { ...rel, column: colName });
+                dmlBound.add(pn);
+            }
+        }
+    }
+    if (ins.returningList) {
+        for (const rt of ins.returningList) {
+            collectFromExpr(rt?.ResTarget?.val, rel, map);
+        }
+    }
+    walkWhere(ins.whereClause, rel, map);
+}
+function walkUpdate(upd, map, dmlBound) {
+    const rel = relOf(upd.relation);
+    if (!rel)
+        return;
+    for (const rt of upd.targetList ?? []) {
+        const colName = rt?.ResTarget?.name;
+        if (typeof colName !== "string")
+            continue;
+        const pn = paramNumber(rt.ResTarget.val);
+        if (pn !== null) {
+            map.set(pn, { ...rel, column: colName });
+            dmlBound.add(pn);
+        }
+    }
+    walkWhere(upd.whereClause, rel, map);
+}
+function walkWhere(node, defaultRel, map) {
+    if (!node || !defaultRel)
+        return;
+    if (node.BoolExpr) {
+        for (const a of node.BoolExpr.args ?? [])
+            walkWhere(a, defaultRel, map);
+        return;
+    }
+    if (node.A_Expr) {
+        collectFromExpr(node, defaultRel, map);
+        return;
+    }
+}
+function collectFromExpr(node, defaultRel, map) {
+    if (!node || !defaultRel)
+        return;
+    if (node.A_Expr) {
+        const e = node.A_Expr;
+        const opName = e.name?.[0]?.String?.sval;
+        if (e.kind === "AEXPR_OP" && opName === "=") {
+            tryBind(e.lexpr, e.rexpr, defaultRel, map);
+            tryBind(e.rexpr, e.lexpr, defaultRel, map);
+        }
+        if (e.kind === "AEXPR_IN") {
+            const colName = colNameOf(e.lexpr);
+            if (colName) {
+                const list = Array.isArray(e.rexpr) ? e.rexpr : [];
+                for (const item of list) {
+                    const pn = paramNumber(item);
+                    if (pn !== null)
+                        map.set(pn, { ...defaultRel, column: colName });
+                }
+            }
+        }
+    }
+}
+function tryBind(colSide, valSide, defaultRel, map) {
+    const colName = colNameOf(colSide);
+    const pn = paramNumber(valSide);
+    if (colName !== null && pn !== null)
+        map.set(pn, { ...defaultRel, column: colName });
+}
+function colNameOf(node) {
+    if (!node?.ColumnRef)
+        return null;
+    const fields = node.ColumnRef.fields;
+    if (!Array.isArray(fields) || fields.length === 0)
+        return null;
+    if (fields.some((f) => f.A_Star !== undefined))
+        return null;
+    return fields[fields.length - 1]?.String?.sval ?? null;
+}
+function paramNumber(node) {
+    if (node?.ParamRef && typeof node.ParamRef.number === "number")
+        return node.ParamRef.number;
+    if (node?.TypeCast)
+        return paramNumber(node.TypeCast.arg);
+    return null;
+}
+function relOf(relation) {
+    if (!relation)
+        return null;
+    const name = relation.relname;
+    if (typeof name !== "string")
+        return null;
+    return { schema: relation.schemaname || undefined, table: name };
+}
+function defaultRel(select) {
+    const from = select?.fromClause;
+    if (!Array.isArray(from) || from.length !== 1)
+        return null;
+    const node = from[0];
+    if (node?.RangeVar)
+        return relOf(node.RangeVar);
+    return null;
+}
+function walkForceNullable(node, forceContext, out) {
+    if (node === null || node === undefined)
+        return;
+    if (Array.isArray(node)) {
+        for (const item of node)
+            walkForceNullable(item, forceContext, out);
+        return;
+    }
+    if (typeof node !== "object")
+        return;
+    if (node.ParamRef && typeof node.ParamRef.number === "number") {
+        if (forceContext)
+            out.add(node.ParamRef.number);
+        return;
+    }
+    if (node.TypeCast) {
+        walkForceNullable(node.TypeCast.arg, forceContext, out);
+        return;
+    }
+    if (node.CoalesceExpr) {
+        for (const a of node.CoalesceExpr.args ?? [])
+            walkForceNullable(a, true, out);
+        return;
+    }
+    if (node.NullTest) {
+        walkForceNullable(node.NullTest.arg, true, out);
+        return;
+    }
+    if (node.A_Expr) {
+        const kind = node.A_Expr.kind;
+        if (kind === "AEXPR_NULLIF" || kind === "AEXPR_DISTINCT" || kind === "AEXPR_NOT_DISTINCT") {
+            walkForceNullable(node.A_Expr.lexpr, true, out);
+            walkForceNullable(node.A_Expr.rexpr, true, out);
+            return;
+        }
+    }
+    for (const key of Object.keys(node)) {
+        walkForceNullable(node[key], forceContext, out);
+    }
+}

package/dist/src/pg/schema.d.ts

@@ -0,0 +1,61 @@
+import { PgClient } from "./wire.js";
+export type ColumnInfo = {
+    attrelid: number;
+    attnum: number;
+    notNull: boolean;
+    name?: string;
+};
+export type EnumInfo = {
+    kind: "enum";
+    name: string;
+    values: string[];
+};
+export type EnumArrayInfo = {
+    kind: "enumArray";
+    element: EnumInfo;
+};
+export type ScalarInfo = {
+    kind: "scalar";
+    name: string;
+    tsType: string;
+};
+export type ScalarArrayInfo = {
+    kind: "scalarArray";
+    name: string;
+    element: ScalarInfo;
+};
+export type CustomTypeInfo = EnumInfo | EnumArrayInfo | ScalarInfo | ScalarArrayInfo;
+export declare class SchemaCache {
+    private client;
+    private byOidNum;
+    private nameToOid;
+    private oidToName;
+    private columnsByOid;
+    private fullyLoaded;
+    private customTypes;
+    private typesProbed;
+    private typeRegistry;
+    constructor(client: PgClient);
+    setTypeRegistry(registry: Record<string, string>): void;
+    loadAttributes(refs: {
+        tableOid: number;
+        attno: number;
+    }[]): Promise<void>;
+    loadTableNames(names: {
+        schema?: string;
+        name: string;
+    }[]): Promise<void>;
+    isNotNull(tableOid: number, attno: number): boolean | undefined;
+    resolveTable(schema: string | undefined, name: string): number | undefined;
+    tableNameByOid(oid: number): {
+        schema: string;
+        name: string;
+    } | undefined;
+    loadTableNamesByOid(oids: number[]): Promise<void>;
+    columnNameByAttno(tableOid: number, attno: number): string | undefined;
+    loadColumnsForTables(tableOids: number[]): Promise<void>;
+    columnsOf(tableOid: number): Map<string, ColumnInfo> | undefined;
+    loadCustomTypes(typeOids: number[]): Promise<void>;
+    private resolveBaseTs;
+    customType(oid: number): CustomTypeInfo | undefined;
+}

package/dist/src/pg/schema.js

@@ -0,0 +1,225 @@
+import { decodeText } from "./wire.js";
+import { isBuiltinOid, oidToTs } from "./oids.js";
+export class SchemaCache {
+    client;
+    byOidNum = new Map();
+    nameToOid = new Map();
+    oidToName = new Map();
+    columnsByOid = new Map();
+    fullyLoaded = new Set();
+    customTypes = new Map();
+    typesProbed = new Set();
+    typeRegistry = {};
+    constructor(client) {
+        this.client = client;
+    }
+    setTypeRegistry(registry) {
+        this.typeRegistry = registry;
+    }
+    async loadAttributes(refs) {
+        const need = refs.filter((r) => r.tableOid !== 0 && r.attno !== 0 && !this.byOidNum.has(key(r.tableOid, r.attno)));
+        if (need.length === 0)
+            return;
+        const seen = new Set();
+        const pairs = [];
+        for (const r of need) {
+            const k = key(r.tableOid, r.attno);
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            pairs.push(`(${r.tableOid},${r.attno})`);
+        }
+        const sql = `SELECT attrelid::int8, attnum::int4, attnotnull, attname FROM pg_attribute WHERE (attrelid, attnum) IN (${pairs.join(",")})`;
+        const r = await this.client.simpleQueryAll(sql);
+        for (const row of r.rows) {
+            const attrelid = Number(decodeText(row[0]));
+            const attnum = Number(decodeText(row[1]));
+            const notNull = decodeText(row[2]) === "t";
+            const name = decodeText(row[3]) ?? undefined;
+            this.byOidNum.set(key(attrelid, attnum), { attrelid, attnum, notNull, name });
+        }
+    }
+    async loadTableNames(names) {
+        const need = [];
+        for (const n of names) {
+            const schema = n.schema ?? "public";
+            const key = `${schema}.${n.name}`;
+            if (!this.nameToOid.has(key))
+                need.push({ schema, name: n.name });
+        }
+        if (need.length === 0)
+            return;
+        const where = need.map((n) => `(n.nspname = ${quote(n.schema)} AND c.relname = ${quote(n.name)})`).join(" OR ");
+        const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE ${where}`;
+        const r = await this.client.simpleQueryAll(sql);
+        for (const row of r.rows) {
+            const oid = Number(decodeText(row[0]));
+            const schema = decodeText(row[1]);
+            const name = decodeText(row[2]);
+            const k = `${schema}.${name}`;
+            const arr = this.nameToOid.get(k) ?? [];
+            arr.push(oid);
+            this.nameToOid.set(k, arr);
+            this.oidToName.set(oid, { schema, name });
+        }
+    }
+    isNotNull(tableOid, attno) {
+        return this.byOidNum.get(key(tableOid, attno))?.notNull;
+    }
+    resolveTable(schema, name) {
+        const k = `${schema ?? "public"}.${name}`;
+        const arr = this.nameToOid.get(k);
+        return arr?.[0];
+    }
+    tableNameByOid(oid) {
+        return this.oidToName.get(oid);
+    }
+    async loadTableNamesByOid(oids) {
+        const need = [...new Set(oids.filter((o) => o > 0 && !this.oidToName.has(o)))];
+        if (need.length === 0)
+            return;
+        const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE c.oid IN (${need.join(",")})`;
+        const r = await this.client.simpleQueryAll(sql);
+        for (const row of r.rows) {
+            const oid = Number(decodeText(row[0]));
+            const schema = decodeText(row[1]);
+            const name = decodeText(row[2]);
+            const k = `${schema}.${name}`;
+            const arr = this.nameToOid.get(k) ?? [];
+            if (!arr.includes(oid))
+                arr.push(oid);
+            this.nameToOid.set(k, arr);
+            this.oidToName.set(oid, { schema, name });
+        }
+    }
+    columnNameByAttno(tableOid, attno) {
+        return this.byOidNum.get(key(tableOid, attno))?.name;
+    }
+    async loadColumnsForTables(tableOids) {
+        const need = tableOids.filter((oid) => !this.fullyLoaded.has(oid));
+        if (need.length === 0)
+            return;
+        const list = [...new Set(need)].join(",");
+        const sql = `SELECT attrelid::int8, attnum::int4, attname, attnotnull FROM pg_attribute WHERE attrelid IN (${list}) AND attnum > 0 AND NOT attisdropped`;
+        const r = await this.client.simpleQueryAll(sql);
+        const grouped = new Map();
+        for (const row of r.rows) {
+            const attrelid = Number(decodeText(row[0]));
+            const attnum = Number(decodeText(row[1]));
+            const attname = decodeText(row[2]);
+            const notNull = decodeText(row[3]) === "t";
+            const info = { attrelid, attnum, notNull, name: attname };
+            this.byOidNum.set(key(attrelid, attnum), info);
+            const m = grouped.get(attrelid) ?? new Map();
+            m.set(attname, info);
+            grouped.set(attrelid, m);
+        }
+        for (const oid of need) {
+            const m = grouped.get(oid) ?? new Map();
+            this.columnsByOid.set(oid, m);
+            this.fullyLoaded.add(oid);
+        }
+    }
+    columnsOf(tableOid) {
+        return this.columnsByOid.get(tableOid);
+    }
+    async loadCustomTypes(typeOids) {
+        const need = typeOids.filter((oid) => oid > 0 && !this.typesProbed.has(oid));
+        if (need.length === 0)
+            return;
+        for (const oid of need)
+            this.typesProbed.add(oid);
+        const list1 = [...new Set(need)].join(",");
+        const sql1 = `SELECT oid::int8, typname, typtype, typcategory, typelem::int8, typbasetype::int8 FROM pg_type WHERE oid IN (${list1})`;
+        const r1 = await this.client.simpleQueryAll(sql1);
+        const enumOids = [];
+        const arrayInfos = [];
+        const domainInfos = [];
+        for (const row of r1.rows) {
+            const oid = Number(decodeText(row[0]));
+            const name = decodeText(row[1]);
+            const typtype = decodeText(row[2]);
+            const typcategory = decodeText(row[3]);
+            const typelem = Number(decodeText(row[4]));
+            const typbasetype = Number(decodeText(row[5]));
+            if (typtype === "e") {
+                enumOids.push(oid);
+                this.customTypes.set(oid, { kind: "enum", name, values: [] });
+            }
+            else if (typcategory === "A" && typelem > 0) {
+                arrayInfos.push({ arrayOid: oid, arrayName: name, elemOid: typelem });
+            }
+            else if (typtype === "b" && this.typeRegistry[name]) {
+                this.customTypes.set(oid, { kind: "scalar", name, tsType: this.typeRegistry[name] });
+            }
+            else if (typtype === "d" && typbasetype > 0) {
+                domainInfos.push({ oid, name, baseOid: typbasetype });
+            }
+        }
+        const elemsToProbe = arrayInfos.map((a) => a.elemOid).filter((o) => !this.typesProbed.has(o));
+        const basesToProbe = domainInfos.map((d) => d.baseOid).filter((o) => !this.typesProbed.has(o) && !isBuiltinOid(o));
+        const recurse = [...new Set([...elemsToProbe, ...basesToProbe])];
+        if (recurse.length > 0)
+            await this.loadCustomTypes(recurse);
+        for (const { oid, name, baseOid } of domainInfos) {
+            const resolved = this.resolveBaseTs(baseOid);
+            if (resolved) {
+                this.customTypes.set(oid, { kind: "scalar", name, tsType: resolved });
+            }
+        }
+        for (const { arrayOid, arrayName, elemOid } of arrayInfos) {
+            const elem = this.customTypes.get(elemOid);
+            if (elem && elem.kind === "enum") {
+                this.customTypes.set(arrayOid, { kind: "enumArray", element: elem });
+            }
+            else if (elem && elem.kind === "scalar") {
+                this.customTypes.set(arrayOid, { kind: "scalarArray", name: arrayName, element: elem });
+            }
+        }
+        if (enumOids.length > 0) {
+            const list2 = enumOids.join(",");
+            const sql2 = `SELECT enumtypid::int8, enumlabel FROM pg_enum WHERE enumtypid IN (${list2}) ORDER BY enumtypid, enumsortorder`;
+            const r2 = await this.client.simpleQueryAll(sql2);
+            for (const row of r2.rows) {
+                const oid = Number(decodeText(row[0]));
+                const label = decodeText(row[1]);
+                const t = this.customTypes.get(oid);
+                if (t && t.kind === "enum")
+                    t.values.push(label);
+            }
+        }
+    }
+    resolveBaseTs(baseOid) {
+        if (baseOid === 0)
+            return undefined;
+        if (isBuiltinOid(baseOid))
+            return oidToTs(baseOid).ts;
+        const info = this.customTypes.get(baseOid);
+        if (!info)
+            return undefined;
+        if (info.kind === "scalar")
+            return info.tsType;
+        if (info.kind === "scalarArray")
+            return `(${info.element.tsType})[]`;
+        if (info.kind === "enum") {
+            if (info.values.length === 0)
+                return "string";
+            return info.values.map((v) => JSON.stringify(v)).join(" | ");
+        }
+        if (info.kind === "enumArray") {
+            if (info.element.values.length === 0)
+                return "string[]";
+            return `(${info.element.values.map((v) => JSON.stringify(v)).join(" | ")})[]`;
+        }
+        return undefined;
+    }
+    customType(oid) {
+        return this.customTypes.get(oid);
+    }
+}
+function key(oid, attno) {
+    return `${oid}/${attno}`;
+}
+function quote(s) {
+    return `'${s.replace(/'/g, "''")}'`;
+}