@onreza/sqlx-js 0.2.0 → 0.4.0

package/dist/src/pg/functions.js

@@ -0,0 +1,150 @@
+import { decodeText } from "./wire.js";
+const JSON_OIDS = new Set([114, 3802]);
+const JSON_ARRAY_OIDS = new Set([199, 3807]);
+const JSON_INPUT = 'import("@onreza/sqlx-js").JsonInput';
+export async function introspectFunctions(client, schema) {
+    const rows = await loadFunctionRows(client);
+    const typeOids = new Set();
+    for (const row of rows) {
+        typeOids.add(row.returnOid);
+        for (const oid of row.inputArgOids)
+            typeOids.add(oid);
+        for (const oid of row.allArgOids ?? [])
+            typeOids.add(oid);
+    }
+    await schema.loadCustomTypes([...typeOids]);
+    return rows.map((row) => toEntry(row, schema)).sort((a, b) => a.signature.localeCompare(b.signature));
+}
+async function loadFunctionRows(client) {
+    const result = await client.simpleQueryAll(`
+    SELECT
+      n.nspname,
+      p.proname,
+      p.prokind::text,
+      pg_get_function_identity_arguments(p.oid),
+      to_json(
+        CASE
+          WHEN p.proargtypes::text = '' THEN ARRAY[]::oid[]
+          ELSE string_to_array(p.proargtypes::text, ' ')::oid[]
+        END
+      )::text,
+      to_json(p.proallargtypes)::text,
+      to_json(p.proargmodes)::text,
+      to_json(p.proargnames)::text,
+      p.prorettype::int8,
+      p.proretset
+    FROM pg_proc p
+    JOIN pg_namespace n ON n.oid = p.pronamespace
+    WHERE ${userSchemaFilter("n")}
+    ORDER BY n.nspname, p.proname, pg_get_function_identity_arguments(p.oid)
+  `);
+    return result.rows.map((row) => ({
+        schema: decodeText(row[0]),
+        name: decodeText(row[1]),
+        kind: functionKind(decodeText(row[2])),
+        identityArguments: decodeText(row[3]) ?? "",
+        inputArgOids: parseNumberJsonArray(decodeText(row[4])),
+        allArgOids: parseNullableNumberJsonArray(decodeText(row[5] ?? null)),
+        argModes: parseNullableStringJsonArray(decodeText(row[6] ?? null)),
+        argNames: parseNullableStringJsonArray(decodeText(row[7] ?? null)),
+        returnOid: Number(decodeText(row[8])),
+        returnsSet: decodeText(row[9]) === "t",
+    }));
+}
+function toEntry(row, schema) {
+    const allArgOids = row.allArgOids ?? row.inputArgOids;
+    const modes = row.argModes ?? allArgOids.map(() => "i");
+    const params = allArgOids.map((oid, i) => {
+        const mode = paramMode(modes[i]);
+        const resultTsType = outputTsType(oid, schema);
+        return {
+            mode,
+            tsType: mode === "out" || mode === "table" ? resultTsType : inputTsType(oid, schema),
+            ...(mode === "inout" ? { resultTsType } : {}),
+            ...(row.argNames?.[i] ? { name: row.argNames[i] } : {}),
+        };
+    });
+    const output = params.filter((p) => p.mode === "out" || p.mode === "inout" || p.mode === "table");
+    return {
+        schema: row.schema,
+        name: row.name,
+        signature: `${row.schema}.${row.name}(${row.identityArguments})`,
+        kind: row.kind,
+        params: params.map(persistedParam),
+        returns: returnTsType(row, output, schema),
+        returnsSet: row.returnsSet,
+    };
+}
+function persistedParam(param) {
+    return {
+        mode: param.mode,
+        tsType: param.tsType,
+        ...(param.name ? { name: param.name } : {}),
+    };
+}
+function returnTsType(row, output, schema) {
+    if (output.length > 0)
+        return outputObject(output);
+    if (row.kind === "procedure")
+        return "void";
+    return nullableReturn(schema.tsType(row.returnOid));
+}
+function outputObject(output) {
+    const fields = output.map((p, i) => {
+        const name = p.name && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name ?? `column${i + 1}`);
+        return `${name}: ${nullableReturn(p.resultTsType ?? p.tsType)}`;
+    });
+    return `{ ${fields.join("; ")} }`;
+}
+function inputTsType(oid, schema) {
+    if (JSON_OIDS.has(oid))
+        return JSON_INPUT;
+    if (JSON_ARRAY_OIDS.has(oid))
+        return `(${JSON_INPUT})[]`;
+    return schema.tsType(oid);
+}
+function outputTsType(oid, schema) {
+    return schema.tsType(oid);
+}
+function nullableReturn(tsType) {
+    if (tsType === "void")
+        return tsType;
+    return `${tsType} | null`;
+}
+function parseNumberJsonArray(raw) {
+    if (!raw)
+        return [];
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.map(Number).filter((n) => Number.isFinite(n)) : [];
+}
+function parseNullableNumberJsonArray(raw) {
+    if (raw === null)
+        return null;
+    return parseNumberJsonArray(raw);
+}
+function parseNullableStringJsonArray(raw) {
+    if (raw === null)
+        return null;
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.map((v) => (typeof v === "string" ? v : "")) : [];
+}
+function paramMode(raw) {
+    switch (raw) {
+        case "o": return "out";
+        case "b": return "inout";
+        case "v": return "variadic";
+        case "t": return "table";
+        default: return "in";
+    }
+}
+function functionKind(raw) {
+    switch (raw) {
+        case "p": return "procedure";
+        case "a": return "aggregate";
+        case "w": return "window";
+        default: return "function";
+    }
+}
+function userSchemaFilter(alias) {
+    return `${alias}.nspname <> 'information_schema' AND ${alias}.nspname NOT LIKE 'pg\\_%' ESCAPE '\\'`;
+}

package/dist/src/pg/oids.js

@@ -1,3 +1,4 @@
+const JSON_VALUE = 'import("@onreza/sqlx-js").JsonValue';
 const SCALAR = {
     16: { ts: "boolean" },
     17: { ts: "Uint8Array" },
@@ -11,7 +12,7 @@ const SCALAR = {
     27: { ts: "string" },
     28: { ts: "string" },
     29: { ts: "string" },
-    114: { ts: "unknown" },
+    114: { ts: JSON_VALUE },
     142: { ts: "string" },
     600: { ts: "string" },
     601: { ts: "string" },
@@ -41,10 +42,12 @@ const SCALAR = {
     2950: { ts: "string" },
     2205: { ts: "string" },
     2206: { ts: "string" },
+    2249: { ts: "Record<string, unknown>" },
+    2278: { ts: "void" },
     3220: { ts: "string" },
     3614: { ts: "string" },
     3615: { ts: "string" },
-    3802: { ts: "unknown" },
+    3802: { ts: JSON_VALUE },
     3904: { ts: "string" },
     3906: { ts: "string" },
     3908: { ts: "string" },

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

@@ -1,7 +1,8 @@
 export type ParamTarget = {
     schema?: string;
     table: string;
-    column: string;
+    column?: string;
+    columnIndex?: number;
 };
 export type ParamMap = Map<number, ParamTarget>;
 export type ParamMapResult = {

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

@@ -12,9 +12,9 @@ export async function buildParamMap(sql) {
     else if (stmt.UpdateStmt)
         walkUpdate(stmt.UpdateStmt, targets, dmlBound);
     else if (stmt.SelectStmt)
-        walkWhere(stmt.SelectStmt.whereClause, defaultRel(stmt.SelectStmt), targets);
+        walkSelect(stmt.SelectStmt, targets, dmlBound);
     else if (stmt.DeleteStmt)
-        walkWhere(stmt.DeleteStmt.whereClause, relOf(stmt.DeleteStmt.relation), targets);
+        walkDelete(stmt.DeleteStmt, targets, dmlBound);
     walkForceNullable(stmt, false, forceNullable);
     return { targets, forceNullable, dmlBound };
 }
@@ -22,6 +22,7 @@ function walkInsert(ins, map, dmlBound) {
     const rel = relOf(ins.relation);
     if (!rel)
         return;
+    const scope = scopeFromRelationNode(ins.relation, rel);
     const cols = (ins.cols ?? [])
         .map((c) => c?.ResTarget?.name)
         .filter((n) => typeof n === "string");
@@ -29,82 +30,162 @@ function walkInsert(ins, map, dmlBound) {
     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);
+                bindParam(map, dmlBound, pn, insertTarget(rel, cols, i), true);
             }
         }
     }
-    if (ins.returningList) {
-        for (const rt of ins.returningList) {
-            collectFromExpr(rt?.ResTarget?.val, rel, map);
+    const select = ins.selectStmt?.SelectStmt;
+    if (select && !select.valuesLists && Array.isArray(select.targetList)) {
+        for (let i = 0; i < select.targetList.length; i++) {
+            const pn = paramNumber(select.targetList[i]?.ResTarget?.val);
+            if (pn !== null) {
+                bindParam(map, dmlBound, pn, insertTarget(rel, cols, i), true);
+            }
         }
+        walkSelect(select, map, dmlBound);
     }
-    walkWhere(ins.whereClause, rel, map);
+    if (ins.returningList)
+        walkExpr(ins.returningList, scope, map, dmlBound);
+    walkOnConflict(ins.onConflictClause, rel, scope, map, dmlBound);
+    walkExpr(ins.whereClause, scope, map, dmlBound);
+}
+function walkOnConflict(conflict, rel, scope, map, dmlBound) {
+    if (!conflict || conflict.action !== "ONCONFLICT_UPDATE")
+        return;
+    for (const rt of conflict.targetList ?? []) {
+        const colName = rt?.ResTarget?.name;
+        if (typeof colName !== "string")
+            continue;
+        const pn = paramNumber(rt.ResTarget.val);
+        if (pn !== null) {
+            bindParam(map, dmlBound, pn, { ...rel, column: colName }, true);
+        }
+    }
+    walkExpr(conflict.whereClause, scope, map, dmlBound);
 }
 function walkUpdate(upd, map, dmlBound) {
     const rel = relOf(upd.relation);
     if (!rel)
         return;
+    const scope = scopeFromRelationNode(upd.relation, rel);
+    addRangeVars(upd.fromClause ?? [], scope);
     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);
+            bindParam(map, dmlBound, pn, { ...rel, column: colName }, true);
         }
     }
-    walkWhere(upd.whereClause, rel, map);
+    walkExpr(upd.whereClause, scope, map, dmlBound);
 }
-function walkWhere(node, defaultRel, map) {
-    if (!node || !defaultRel)
+function walkDelete(del, map, dmlBound) {
+    const rel = relOf(del.relation);
+    if (!rel)
         return;
+    const scope = scopeFromRelationNode(del.relation, rel);
+    addRangeVars(del.usingClause ?? [], scope);
+    walkExpr(del.whereClause, scope, map, dmlBound);
+}
+function walkSelect(select, map, dmlBound) {
+    const scope = scopeFromSelect(select);
+    walkJoinQuals(select.fromClause ?? [], scope, map, dmlBound);
+    walkExpr(select.whereClause, scope, map, dmlBound);
+}
+function walkExpr(node, scope, map, dmlBound) {
+    if (!node)
+        return;
+    if (Array.isArray(node)) {
+        for (const item of node)
+            walkExpr(item, scope, map, dmlBound);
+        return;
+    }
     if (node.BoolExpr) {
         for (const a of node.BoolExpr.args ?? [])
-            walkWhere(a, defaultRel, map);
+            walkExpr(a, scope, map, dmlBound);
         return;
     }
     if (node.A_Expr) {
-        collectFromExpr(node, defaultRel, map);
+        collectFromExpr(node, scope, map, dmlBound);
+        walkExpr(node.A_Expr.lexpr, scope, map, dmlBound);
+        walkExpr(node.A_Expr.rexpr, scope, map, dmlBound);
+        return;
+    }
+    if (node.TypeCast) {
+        walkExpr(node.TypeCast.arg, scope, map, dmlBound);
+        return;
+    }
+    if (node.NullTest) {
+        walkExpr(node.NullTest.arg, scope, map, dmlBound);
+        return;
+    }
+    if (node.CoalesceExpr) {
+        walkExpr(node.CoalesceExpr.args ?? [], scope, map, dmlBound);
+        return;
+    }
+    if (node.FuncCall) {
+        walkExpr(node.FuncCall.args ?? [], scope, map, dmlBound);
+        return;
+    }
+    if (node.CaseExpr) {
+        walkExpr(node.CaseExpr.arg, scope, map, dmlBound);
+        walkExpr(node.CaseExpr.args ?? [], scope, map, dmlBound);
+        walkExpr(node.CaseExpr.defresult, scope, map, dmlBound);
+        return;
+    }
+    if (node.CaseWhen) {
+        walkExpr(node.CaseWhen.expr, scope, map, dmlBound);
+        walkExpr(node.CaseWhen.result, scope, map, dmlBound);
+        return;
+    }
+    if (node.SubLink) {
+        const sub = node.SubLink.subselect?.SelectStmt;
+        if (sub)
+            walkSelect(sub, map, dmlBound);
+        walkExpr(node.SubLink.testexpr, scope, map, dmlBound);
         return;
     }
 }
-function collectFromExpr(node, defaultRel, map) {
-    if (!node || !defaultRel)
+function collectFromExpr(node, scope, map, dmlBound) {
+    if (!node)
         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);
+            tryBind(e.lexpr, e.rexpr, scope, map, dmlBound);
+            tryBind(e.rexpr, e.lexpr, scope, map, dmlBound);
         }
         if (e.kind === "AEXPR_IN") {
-            const colName = colNameOf(e.lexpr);
-            if (colName) {
-                const list = Array.isArray(e.rexpr) ? e.rexpr : [];
+            const target = targetOfColumnRef(e.lexpr, scope);
+            if (target) {
+                const list = Array.isArray(e.rexpr) ? e.rexpr : e.rexpr?.List?.items ?? [];
                 for (const item of list) {
                     const pn = paramNumber(item);
                     if (pn !== null)
-                        map.set(pn, { ...defaultRel, column: colName });
+                        bindParam(map, dmlBound, pn, target, false);
                 }
             }
         }
     }
 }
-function tryBind(colSide, valSide, defaultRel, map) {
-    const colName = colNameOf(colSide);
+function tryBind(colSide, valSide, scope, map, dmlBound) {
+    const target = targetOfColumnRef(colSide, scope);
     const pn = paramNumber(valSide);
-    if (colName !== null && pn !== null)
-        map.set(pn, { ...defaultRel, column: colName });
+    if (target && pn !== null)
+        bindParam(map, dmlBound, pn, target, false);
 }
-function colNameOf(node) {
+function bindParam(map, dmlBound, pn, target, dml) {
+    if (!dml && dmlBound.has(pn))
+        return;
+    map.set(pn, target);
+    if (dml)
+        dmlBound.add(pn);
+}
+function stringFields(node) {
     if (!node?.ColumnRef)
         return null;
     const fields = node.ColumnRef.fields;
@@ -112,7 +193,25 @@ function colNameOf(node) {
         return null;
     if (fields.some((f) => f.A_Star !== undefined))
         return null;
-    return fields[fields.length - 1]?.String?.sval ?? null;
+    const out = fields.map((f) => f.String?.sval);
+    return out.every((s) => typeof s === "string") ? out : null;
+}
+function targetOfColumnRef(node, scope) {
+    const fields = stringFields(node);
+    if (!fields)
+        return null;
+    const column = fields[fields.length - 1];
+    if (fields.length === 1) {
+        return scope.defaultRel ? { ...scope.defaultRel, column } : null;
+    }
+    if (fields.length === 2) {
+        const qualifier = fields[0];
+        const rel = scope.aliases.get(qualifier) ?? scope.relations.find((r) => r.table === qualifier);
+        return rel ? { ...rel, column } : { table: qualifier, column };
+    }
+    const table = fields[fields.length - 2];
+    const schema = fields[fields.length - 3];
+    return { schema, table, column };
 }
 function paramNumber(node) {
     if (node?.ParamRef && typeof node.ParamRef.number === "number")
@@ -129,14 +228,56 @@ function relOf(relation) {
         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 insertTarget(rel, cols, index) {
+    const column = cols[index];
+    return column ? { ...rel, column } : { ...rel, columnIndex: index + 1 };
+}
+function scopeFromSelect(select) {
+    const scope = scopeFromRelations([], null);
+    addRangeVars(select?.fromClause ?? [], scope);
+    if (scope.relations.length === 1)
+        scope.defaultRel = scope.relations[0];
+    return scope;
+}
+function scopeFromRelations(relations, defaultRel) {
+    const scope = { aliases: new Map(), relations: [], defaultRel };
+    for (const rel of relations)
+        addRelation(scope, rel, rel.table);
+    return scope;
+}
+function scopeFromRelationNode(relation, rel) {
+    const scope = scopeFromRelations([rel], rel);
+    const alias = relation?.alias?.aliasname;
+    if (typeof alias === "string")
+        scope.aliases.set(alias, rel);
+    return scope;
+}
+function addRelation(scope, rel, alias) {
+    scope.relations.push(rel);
+    scope.aliases.set(alias, rel);
+}
+function addRangeVars(nodes, scope) {
+    for (const node of nodes) {
+        if (node?.RangeVar) {
+            const rel = relOf(node.RangeVar);
+            if (!rel)
+                continue;
+            const alias = node.RangeVar.alias?.aliasname ?? rel.table;
+            addRelation(scope, rel, alias);
+            continue;
+        }
+        if (node?.JoinExpr) {
+            addRangeVars([node.JoinExpr.larg, node.JoinExpr.rarg], scope);
+        }
+    }
+}
+function walkJoinQuals(nodes, scope, map, dmlBound) {
+    for (const node of nodes) {
+        if (!node?.JoinExpr)
+            continue;
+        walkExpr(node.JoinExpr.quals, scope, map, dmlBound);
+        walkJoinQuals([node.JoinExpr.larg, node.JoinExpr.rarg], scope, map, dmlBound);
+    }
 }
 function walkForceNullable(node, forceContext, out) {
     if (node === null || node === undefined)

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

@@ -74,4 +74,5 @@ export declare class SchemaCache {
     loadCustomTypes(typeOids: number[]): Promise<void>;
     private resolveBaseTs;
     customType(oid: number): CustomTypeInfo | undefined;
+    tsType(oid: number): string;
 }

package/dist/src/pg/schema.js

@@ -262,6 +262,9 @@ export class SchemaCache {
     customType(oid) {
         return this.customTypes.get(oid);
     }
+    tsType(oid) {
+        return this.resolveBaseTs(oid) ?? "unknown";
+    }
 }
 function key(oid, attno) {
     return `${oid}/${attno}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onreza/sqlx-js",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Compile-time-checked raw SQL for TypeScript + PostgreSQL. Inspired by sqlx.",
   "license": "MIT",
   "type": "module",