@onreza/sqlx-js 0.8.0 → 0.9.1

package/dist/src/commands/prepare.js

@@ -8,7 +8,7 @@ import { arrayElementOid, isBuiltinOid, oidToTs } from "../pg/oids.js";
 import { ScanError, scanProject } from "../scan/scanner.js";
 import { assertCacheManifest, Cache, fingerprint, effectiveNullable, portableCacheOid, writeCacheManifest, } from "../cache.js";
 import { emitDts } from "../codegen.js";
-import { loadConfig, lookupJsonbType, prepareConfigHash } from "../config.js";
+import { loadConfig, lookupColumnType, lookupJsonbType, prepareConfigHash } from "../config.js";
 import { functionCacheExists, readFunctionCache, writeFunctionCache } from "../function-cache.js";
 import { introspectFunctions } from "../pg/functions.js";
 import { buildParamMap } from "../pg/param-map.js";
@@ -18,7 +18,7 @@ import { containsUnknownType } from "../type-inspection.js";
 import { originalPosition, rewriteNamedParameters } from "../sql-params.js";
 const JSON_OIDS = new Set([114, 3802]);
 const JSON_ARRAY_OIDS = new Set([199, 3807]);
-const JSON_INPUT_VALUE = 'import("@onreza/sqlx-js").JsonInputValue';
+const JSON_INPUT_VALUE = "unknown";
 function jsonParameter(type) {
     return `import("@onreza/sqlx-js").JsonParameter<${type}>`;
 }
@@ -48,6 +48,12 @@ function resolveTs(oid, customLookup) {
     }
     return oidToTs(oid).ts;
 }
+function isScalarColumnType(oid, schema) {
+    if (JSON_OIDS.has(oid) || JSON_ARRAY_OIDS.has(oid) || arrayElementOid(oid) !== undefined)
+        return false;
+    const custom = schema.customType(oid);
+    return custom?.kind !== "enumArray" && custom?.kind !== "scalarArray" && custom?.kind !== "compositeArray";
+}
 function resolveColumnTs(f, schema, cfg) {
     if (f.tableOid !== 0 && f.columnAttr !== 0) {
         const tbl = schema.tableNameByOid(f.tableOid);
@@ -63,13 +69,25 @@ function resolveColumnTs(f, schema, cfg) {
                 if (decl)
                     return `(${decl})[]`;
             }
+            if (isScalarColumnType(f.typeOid, schema)) {
+                const decl = lookupColumnType(cfg, tbl.schema, tbl.name, colName);
+                if (decl)
+                    return decl;
+            }
         }
     }
     return resolveTs(f.typeOid, (oid) => schema.customType(oid));
 }
 function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
+    const target = paramMap.get(paramIndex);
+    if (isScalarColumnType(paramOid, schema) && target) {
+        const column = resolveTargetColumn(target, schema);
+        const table = resolvedTargetTable(target, schema);
+        const decl = column && table ? lookupColumnType(cfg, table.schema, table.name, column) : undefined;
+        if (decl)
+            return decl;
+    }
     if (JSON_OIDS.has(paramOid)) {
-        const target = paramMap.get(paramIndex);
         if (target) {
             const column = resolveTargetColumn(target, schema);
             const table = resolvedTargetTable(target, schema);
@@ -80,7 +98,6 @@ function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
         return jsonParameter(JSON_INPUT_VALUE);
     }
     if (JSON_ARRAY_OIDS.has(paramOid)) {
-        const target = paramMap.get(paramIndex);
         if (target) {
             const column = resolveTargetColumn(target, schema);
             const table = resolvedTargetTable(target, schema);
@@ -188,7 +205,17 @@ function fatal(phase, error) {
     return new PrepareFatalError(phase, message, location, { cause: error });
 }
 function formatSite(s) {
-    return `${s.file}:${s.line}:${s.column}`;
+    return `${s.file}:${s.line}:${s.column}${s.queryName ? ` [${s.queryName}]` : ""}`;
+}
+function siteDiagnostic(site) {
+    return {
+        file: site.file,
+        line: site.line,
+        column: site.column,
+        query: site.query,
+        queryId: fingerprint(site.query),
+        ...(site.queryName ? { queryName: site.queryName } : {}),
+    };
 }
 function snippet(query, max = 80) {
     const oneLine = query.replace(/\s+/g, " ").trim();
@@ -224,10 +251,7 @@ function inferenceDiagnostics(entry, site, strict) {
         severity: strict ? "error" : "warning",
         phase: "inference",
         message,
-        file: site.file,
-        line: site.line,
-        column: site.column,
-        query: site.query,
+        ...siteDiagnostic(site),
     }));
 }
 export async function openSession(opts) {
@@ -372,10 +396,7 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                     severity: "error",
                     phase: "result-shape",
                     message,
-                    file: site.file,
-                    line: site.line,
-                    column: site.column,
-                    query: site.query,
+                    ...siteDiagnostic(site),
                 });
                 err(`  ✗ ${formatSite(site)} — ${message}`);
                 err(`      query: ${snippet(site.query)}`);
@@ -392,10 +413,7 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 severity: "error",
                 phase: "describe",
                 message: e.message,
-                file: site.file,
-                line: site.line,
-                column: site.column,
-                query: site.query,
+                ...siteDiagnostic(site),
                 ...(e.code ? { code: e.code } : {}),
                 ...(position ? { position } : {}),
                 ...(e.hint ? { hint: e.hint } : {}),
@@ -416,10 +434,7 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 severity: "error",
                 phase: "describe",
                 message: e.message,
-                file: site.file,
-                line: site.line,
-                column: site.column,
-                query: site.query,
+                ...siteDiagnostic(site),
             });
             err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}`);
             err(`      query: ${snippet(site.query)}`);
@@ -457,10 +472,7 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 severity: "error",
                 phase: "analyze",
                 message: e.message,
-                file: site.file,
-                line: site.line,
-                column: site.column,
-                query: site.query,
+                ...siteDiagnostic(site),
             });
             err(`  ✗ ${formatSite(site)} — analyze failed: ${e.message}`);
             err(`      query: ${snippet(site.query)}`);
@@ -476,10 +488,7 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 severity: "error",
                 phase: "param-map",
                 message: e.message,
-                file: site.file,
-                line: site.line,
-                column: site.column,
-                query: site.query,
+                ...siteDiagnostic(site),
             });
             err(`  ✗ ${formatSite(site)} — paramMap failed: ${e.message}`);
             err(`      query: ${snippet(site.query)}`);
@@ -580,12 +589,17 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
         return { sites: sites.length, entries: entries.length, failures, pruned: 0, functions: 0, diagnostics };
     }
     let functions;
-    if (input.reuseFunctions && functionCacheExists(opts.cacheDir)) {
+    if (userCfg.functionCatalog === false) {
+        functions = [];
+    }
+    else if (input.reuseFunctions && functionCacheExists(opts.cacheDir)) {
         functions = readFunctionCache(opts.cacheDir);
     }
     else {
         try {
-            functions = await introspectFunctions(client, schema);
+            functions = await introspectFunctions(client, schema, {
+                includeExtensionOwned: userCfg.functionCatalog?.includeExtensionOwned === true,
+            });
         }
         catch (error) {
             throw fatal("introspect", error);
@@ -663,10 +677,7 @@ export async function runPrepare(opts) {
                     severity: "error",
                     phase: "cache",
                     message: "query is not in the offline cache",
-                    file: site.file,
-                    line: site.line,
-                    column: site.column,
-                    query,
+                    ...siteDiagnostic(site),
                 });
                 if (!opts.json) {
                     console.error(`stale: ${formatSite(site)} — query not in cache`);

package/dist/src/commands/queries.d.ts

@@ -0,0 +1,38 @@
+import type { QueryExecutionMode } from "../query.js";
+export type QueriesPhase = "config" | "scan" | "cache" | "embed";
+export declare class QueriesError extends Error {
+    readonly phase: QueriesPhase;
+    readonly file?: string | undefined;
+    readonly line?: number | undefined;
+    readonly column?: number | undefined;
+    constructor(phase: QueriesPhase, message: string, file?: string | undefined, line?: number | undefined, column?: number | undefined, options?: {
+        cause?: unknown;
+    });
+}
+export type QueryInventoryItem = {
+    queryId: string;
+    queryNames: string[];
+    query: string;
+    cardinalities: QueryExecutionMode[];
+    sqlFilePaths: string[];
+    callSites: {
+        file: string;
+        line: number;
+        column: number;
+    }[];
+    cacheStatus: "current" | "stale" | "missing";
+};
+export type QueryInventory = {
+    formatVersion: 1;
+    ok: true;
+    queries: QueryInventoryItem[];
+    orphanedCacheIds: string[];
+};
+export declare function buildQueryInventory(root: string, cacheDir: string): Promise<QueryInventory>;
+export declare function emitEmbeddedSqlModule(path: string, inventory: QueryInventory): void;
+export declare function runQueries(options: {
+    root: string;
+    cacheDir: string;
+    json?: boolean;
+    embedPath?: string;
+}): Promise<void>;

package/dist/src/commands/queries.js

@@ -0,0 +1,143 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, relative } from "node:path";
+import { Cache, CacheManifestStaleError, readCacheManifest } from "../cache.js";
+import { loadConfig, prepareConfigHash } from "../config.js";
+import { queryId } from "../query-id.js";
+import { ScanError, scanProject } from "../scan/scanner.js";
+export class QueriesError extends Error {
+    phase;
+    file;
+    line;
+    column;
+    constructor(phase, message, file, line, column, options) {
+        super(message, options);
+        this.phase = phase;
+        this.file = file;
+        this.line = line;
+        this.column = column;
+        this.name = "QueriesError";
+    }
+}
+function queriesError(phase, error) {
+    if (error instanceof QueriesError)
+        return error;
+    if (error instanceof ScanError) {
+        return new QueriesError(phase, error.message, error.file, error.line, error.column, { cause: error });
+    }
+    return new QueriesError(phase, error instanceof Error ? error.message : String(error), undefined, undefined, undefined, { cause: error });
+}
+export async function buildQueryInventory(root, cacheDir) {
+    let config;
+    try {
+        config = await loadConfig(root);
+    }
+    catch (error) {
+        throw queriesError("config", error);
+    }
+    let sites;
+    try {
+        sites = scanProject(root, config.scan);
+    }
+    catch (error) {
+        throw queriesError("scan", error);
+    }
+    const cache = new Cache(cacheDir);
+    let manifestCurrent = false;
+    try {
+        const manifest = readCacheManifest(cacheDir);
+        manifestCurrent = manifest?.configHash === prepareConfigHash(config);
+    }
+    catch (error) {
+        if (!(error instanceof CacheManifestStaleError)) {
+            throw queriesError("cache", error);
+        }
+        manifestCurrent = false;
+    }
+    let cacheIds;
+    try {
+        cacheIds = cache.list().map(({ fp }) => fp);
+    }
+    catch (error) {
+        throw queriesError("cache", error);
+    }
+    const cached = new Set(cacheIds);
+    const grouped = new Map();
+    for (const site of sites) {
+        const id = queryId(site.query);
+        const group = grouped.get(id) ?? [];
+        group.push(site);
+        grouped.set(id, group);
+    }
+    const queries = [...grouped.entries()].map(([id, group]) => {
+        return {
+            queryId: id,
+            queryNames: [...new Set(group.flatMap((site) => site.queryName ? [site.queryName] : []))].sort(),
+            query: group[0].query,
+            cardinalities: [...new Set(group.map((site) => site.cardinality ?? "many"))].sort(),
+            sqlFilePaths: [...new Set(group.flatMap((site) => site.sqlFilePath ? [site.sqlFilePath] : []))].sort(),
+            callSites: group
+                .map(({ file, line, column }) => ({ file, line, column }))
+                .sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column),
+            cacheStatus: !cached.has(id) ? "missing" : manifestCurrent ? "current" : "stale",
+        };
+    }).sort((a, b) => a.queryId.localeCompare(b.queryId));
+    const active = new Set(queries.map((query) => query.queryId));
+    const orphanedCacheIds = cacheIds.filter((fp) => !active.has(fp)).sort();
+    return { formatVersion: 1, ok: true, queries, orphanedCacheIds };
+}
+export function emitEmbeddedSqlModule(path, inventory) {
+    const sqlFiles = Object.fromEntries(inventory.queries
+        .flatMap((query) => query.sqlFilePaths.map((file) => [file, query.query]))
+        .sort(([a], [b]) => a.localeCompare(b)));
+    const content = [
+        "// AUTO-GENERATED by sqlx-js. Do not edit.",
+        "// Run `sqlx-js queries --embed <path>` to regenerate.",
+        "",
+        `export const sqlxJsEmbeddedSql = ${JSON.stringify(sqlFiles, null, 2)} as const;`,
+        "",
+    ].join("\n");
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${randomBytes(4).toString("hex")}`;
+    writeFileSync(tmp, content);
+    try {
+        renameSync(tmp, path);
+    }
+    catch (error) {
+        try {
+            unlinkSync(tmp);
+        }
+        catch { }
+        throw error;
+    }
+}
+export async function runQueries(options) {
+    const inventory = await buildQueryInventory(options.root, options.cacheDir);
+    if (options.embedPath) {
+        try {
+            emitEmbeddedSqlModule(options.embedPath, inventory);
+        }
+        catch (error) {
+            throw queriesError("embed", error);
+        }
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            ...inventory,
+            ...(options.embedPath ? { embeddedModule: relative(options.root, options.embedPath).replace(/\\/g, "/") } : {}),
+        }, null, 2));
+        return;
+    }
+    for (const query of inventory.queries) {
+        const names = query.queryNames.length > 0 ? ` ${query.queryNames.join(",")}` : "";
+        console.log(`${query.queryId}${names} ${query.cardinalities.join(",")} ${query.cacheStatus}`);
+        for (const site of query.callSites)
+            console.log(`  ${site.file}:${site.line}:${site.column}`);
+    }
+    if (inventory.queries.length === 0)
+        console.log("no sqlx-js queries found");
+    if (inventory.orphanedCacheIds.length > 0)
+        console.log(`orphaned cache: ${inventory.orphanedCacheIds.join(", ")}`);
+    if (options.embedPath)
+        console.log(`embedded SQL module: ${relative(options.root, options.embedPath).replace(/\\/g, "/")}`);
+}

package/dist/src/config.d.ts

@@ -5,7 +5,11 @@ export type ScanConfig = {
 };
 export type SqlxJsConfig = {
     jsonbTypes?: Record<string, string>;
+    columnTypes?: Record<string, string>;
     customTypes?: Record<string, string>;
+    functionCatalog?: false | {
+        includeExtensionOwned?: boolean;
+    };
     scan?: ScanConfig;
     schema?: {
         provider?: "builtin" | "pgschema";
@@ -32,3 +36,4 @@ export declare function runtimeVersion(): {
 export declare function nativeTypeScriptEnabled(): boolean | string;
 export declare function envFilePath(root: string): string;
 export declare function lookupJsonbType(cfg: SqlxJsConfig, schema: string, table: string, column: string): string | undefined;
+export declare function lookupColumnType(cfg: SqlxJsConfig, schema: string, table: string, column: string): string | undefined;

package/dist/src/config.js

@@ -65,8 +65,27 @@ function validateConfig(value, path) {
     const config = value;
     if (config.jsonbTypes !== undefined)
         validateStringRecord(config.jsonbTypes, "jsonbTypes", path);
+    if (config.columnTypes !== undefined)
+        validateStringRecord(config.columnTypes, "columnTypes", path);
     if (config.customTypes !== undefined)
         validateStringRecord(config.customTypes, "customTypes", path);
+    if (config.jsonbTypes && config.columnTypes) {
+        const jsonKeys = Object.keys(config.jsonbTypes);
+        const columnKeys = Object.keys(config.columnTypes);
+        const conflicts = jsonKeys.filter((jsonKey) => columnKeys.some((columnKey) => jsonKey === columnKey || jsonKey.endsWith(`.${columnKey}`) || columnKey.endsWith(`.${jsonKey}`)));
+        if (conflicts.length > 0) {
+            throw new Error(`sqlx-js: ${path} maps the same column in jsonbTypes and columnTypes: ${conflicts.join(", ")}`);
+        }
+    }
+    if (config.functionCatalog !== undefined && config.functionCatalog !== false) {
+        if (!config.functionCatalog || typeof config.functionCatalog !== "object" || Array.isArray(config.functionCatalog)) {
+            throw new Error(`sqlx-js: ${path} functionCatalog must be false or an object`);
+        }
+        const functionCatalog = config.functionCatalog;
+        if (functionCatalog.includeExtensionOwned !== undefined && typeof functionCatalog.includeExtensionOwned !== "boolean") {
+            throw new Error(`sqlx-js: ${path} functionCatalog.includeExtensionOwned must be a boolean`);
+        }
+    }
     if (config.scan !== undefined) {
         if (!config.scan || typeof config.scan !== "object" || Array.isArray(config.scan)) {
             throw new Error(`sqlx-js: ${path} scan must be an object`);
@@ -100,7 +119,11 @@ function validateConfig(value, path) {
 export function prepareConfigHash(cfg) {
     const value = stableValue({
         jsonbTypes: cfg.jsonbTypes ?? {},
+        columnTypes: cfg.columnTypes ?? {},
         customTypes: cfg.customTypes ?? {},
+        functionCatalog: cfg.functionCatalog === false
+            ? false
+            : { includeExtensionOwned: cfg.functionCatalog?.includeExtensionOwned === true },
     });
     return createHash("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16);
 }
@@ -159,3 +182,9 @@ export function lookupJsonbType(cfg, schema, table, column) {
     return (types[`${schema}.${table}.${column}`] ??
         types[`${table}.${column}`]);
 }
+export function lookupColumnType(cfg, schema, table, column) {
+    const types = cfg.columnTypes;
+    if (!types)
+        return undefined;
+    return types[`${schema}.${table}.${column}`] ?? types[`${table}.${column}`];
+}

package/dist/src/index.d.ts

@@ -1,5 +1,6 @@
 import * as rt from "./postgres-runtime.js";
-import type { Typed as TypedFor, TypedFile as TypedFileFor, TypedSql as TypedSqlFor } from "./typed.js";
+import type { TypedFile as TypedFileFor, TypedForRegistry, TypedSqlForRegistry } from "./typed.js";
+import type { QueryParamsFor, QueryResultFor, QueryRowFor } from "./query.js";
 export interface KnownQueries {
 }
 export interface KnownFileQueries {
@@ -22,13 +23,13 @@ export { defineConfig } from "./config.js";
 export type { ScanConfig, SqlxJsConfig } from "./config.js";
 export type { SslMode, ConnConfig } from "./pg/wire.js";
 export { PgError, ConnectionLostError } from "./pg/wire.js";
-export { NoRowsError, TooManyRowsError } from "./runtime.js";
+export { NoRowsError, TooManyRowsError, SQLSTATE, isPgError } from "./runtime.js";
 export type { TransactionOptions, MigrateOptions, OnQueryEvent, OnQueryHook, OnQueryHookError } from "./runtime.js";
-export type { ExecuteResult, JsonParameter, PgArrayParameter } from "./runtime.js";
+export type { ExecuteResult, JsonParameter, PgArrayParameter, JsonCompatible, KnownSqlState } from "./runtime.js";
 export type { PostgresClient, PostgresOptions, CreateClientOptions } from "./postgres-runtime.js";
 export type TypedFile = TypedFileFor<KnownFileQueries>;
-export type TypedSql = TypedSqlFor<KnownQueries, KnownFileQueries>;
-export type Typed = TypedFor<KnownQueries, KnownFileQueries, import("./runtime.js").TransactionOptions>;
+export type TypedSql = TypedSqlForRegistry<DefaultQueryRegistry>;
+export type Typed = TypedForRegistry<DefaultQueryRegistry, import("./runtime.js").TransactionOptions>;
 export type QueryRegistry = {
     queries: object;
     fileQueries: object;
@@ -39,11 +40,18 @@ export interface DefaultQueryRegistry {
     functions: KnownFunctions;
 }
 export type SqlClient<Registry extends QueryRegistry = DefaultQueryRegistry> = {
-    sql: TypedFor<Registry["queries"], Registry["fileQueries"], import("./runtime.js").TransactionOptions>;
+    sql: TypedForRegistry<Registry, import("./runtime.js").TransactionOptions>;
     unsafe: Unsafe;
     client: import("./postgres-runtime.js").PostgresClient;
     close: () => Promise<void>;
 };
+export type SqlExecutor<Registry extends QueryRegistry = DefaultQueryRegistry> = TypedSqlForRegistry<Registry>;
+export type QueryParams<Definition, Registry extends QueryRegistry = DefaultQueryRegistry> = QueryParamsFor<Definition, Registry>;
+export type QueryRow<Definition, Registry extends QueryRegistry = DefaultQueryRegistry> = QueryRowFor<Definition, Registry>;
+export type QueryResult<Definition, Registry extends QueryRegistry = DefaultQueryRegistry> = QueryResultFor<Definition, Registry>;
+export type { QueryDefinition, QueryExecutionMode } from "./query.js";
+export { defineQuery } from "./query.js";
+export { queryId } from "./query-id.js";
 export declare const sql: Typed;
 export type Unsafe = (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;
 export declare const unsafe: Unsafe;

package/dist/src/index.js

@@ -1,7 +1,9 @@
 import * as rt from "./postgres-runtime.js";
 export { defineConfig } from "./config.js";
 export { PgError, ConnectionLostError } from "./pg/wire.js";
-export { NoRowsError, TooManyRowsError } from "./runtime.js";
+export { NoRowsError, TooManyRowsError, SQLSTATE, isPgError } from "./runtime.js";
+export { defineQuery } from "./query.js";
+export { queryId } from "./query-id.js";
 export const sql = rt.sql;
 export const unsafe = rt.unsafe;
 export const getClient = rt.getClient;

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

@@ -1,4 +1,6 @@
 import type { FunctionEntry } from "../function-cache.js";
 import { type PgClient } from "./wire.js";
 import { SchemaCache } from "./schema.js";
-export declare function introspectFunctions(client: PgClient, schema: SchemaCache): Promise<FunctionEntry[]>;
+export declare function introspectFunctions(client: PgClient, schema: SchemaCache, options?: {
+    includeExtensionOwned?: boolean;
+}): Promise<FunctionEntry[]>;

package/dist/src/pg/functions.js

@@ -2,8 +2,8 @@ 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);
+export async function introspectFunctions(client, schema, options = {}) {
+    const rows = await loadFunctionRows(client, options.includeExtensionOwned === true);
     const typeOids = new Set();
     for (const row of rows) {
         typeOids.add(row.returnOid);
@@ -15,7 +15,7 @@ export async function introspectFunctions(client, schema) {
     await schema.loadCustomTypes([...typeOids]);
     return rows.map((row) => toEntry(row, schema)).sort((a, b) => a.signature.localeCompare(b.signature));
 }
-async function loadFunctionRows(client) {
+async function loadFunctionRows(client, includeExtensionOwned) {
     const result = await client.simpleQueryAll(`
     SELECT
       n.nspname,
@@ -36,6 +36,14 @@ async function loadFunctionRows(client) {
     FROM pg_proc p
     JOIN pg_namespace n ON n.oid = p.pronamespace
     WHERE ${userSchemaFilter("n")}
+      ${includeExtensionOwned ? "" : `AND NOT EXISTS (
+        SELECT 1
+        FROM pg_depend d
+        WHERE d.classid = 'pg_proc'::regclass
+          AND d.objid = p.oid
+          AND d.refclassid = 'pg_extension'::regclass
+          AND d.deptype = 'e'
+      )`}
     ORDER BY n.nspname, p.proname, pg_get_function_identity_arguments(p.oid)
   `);
     return result.rows.map((row) => ({

package/dist/src/postgres-runtime.d.ts

@@ -10,6 +10,7 @@ export type CreateClientOptions = PostgresOptions & {
     statementTimeoutMs?: number;
     fileRoot?: string;
     reloadSqlFiles?: boolean;
+    sqlFiles?: Readonly<Record<string, string>>;
 };
 export declare function createClient(url?: string | undefined, options?: CreateClientOptions): PostgresClient;
 export declare function getClient(): PostgresClient;
@@ -19,6 +20,7 @@ export declare function setClient(client: PostgresClient, options?: {
     prepare?: boolean;
     fileRoot?: string;
     reloadSqlFiles?: boolean;
+    sqlFiles?: Readonly<Record<string, string>>;
 }): void;
 export declare function close(): Promise<void>;
 export declare function createSqlClient(url?: string | undefined, options?: CreateClientOptions): {

package/dist/src/postgres-runtime.js

@@ -13,13 +13,15 @@ class PostgresRuntimeClient {
     prepare;
     fileRoot;
     reloadSqlFiles;
-    constructor(client, onQuery, onQueryHookError, prepare = true, fileRoot = resolvedFileRoot(), reloadSqlFiles = false) {
+    sqlFiles;
+    constructor(client, onQuery, onQueryHookError, prepare = true, fileRoot = resolvedFileRoot(), reloadSqlFiles = false, sqlFiles) {
         this.client = client;
         this.onQuery = onQuery;
         this.onQueryHookError = onQueryHookError;
         this.prepare = prepare;
         this.fileRoot = fileRoot;
         this.reloadSqlFiles = reloadSqlFiles;
+        this.sqlFiles = sqlFiles;
     }
     async query(query, params) {
         return await this.client.unsafe(query, params, { prepare: this.prepare });
@@ -43,7 +45,7 @@ class PostgresRuntimeClient {
         if (!("begin" in this.client))
             throw new Error("sqlx-js.transaction: nested transactions are not supported");
         return await this.client.begin(async (tx) => {
-            return await fn(new PostgresRuntimeClient(tx, this.onQuery, this.onQueryHookError, this.prepare, this.fileRoot, this.reloadSqlFiles));
+            return await fn(new PostgresRuntimeClient(tx, this.onQuery, this.onQueryHookError, this.prepare, this.fileRoot, this.reloadSqlFiles, this.sqlFiles));
         });
     }
     async close() {
@@ -162,7 +164,7 @@ function installJsonArrayCodecs(client) {
 export function createClient(url = process.env.DATABASE_URL, options = {}) {
     if (!url)
         throw new Error("sqlx-js: DATABASE_URL is not set");
-    const { onQuery, onQueryHookError, statementTimeoutMs, fileRoot, reloadSqlFiles, ...pgOptions } = options;
+    const { onQuery, onQueryHookError, statementTimeoutMs, fileRoot, reloadSqlFiles, sqlFiles, ...pgOptions } = options;
     const connection = statementTimeoutMs !== undefined
         ? { ...(pgOptions.connection ?? {}), statement_timeout: statementTimeoutMs }
         : pgOptions.connection;
@@ -177,13 +179,14 @@ export function createClient(url = process.env.DATABASE_URL, options = {}) {
         prepare: pgOptions.prepare ?? true,
         fileRoot: resolvedFileRoot(fileRoot),
         reloadSqlFiles: reloadSqlFiles ?? false,
+        sqlFiles,
     };
     return client;
 }
 function createDefaultClient() {
     const client = createClient();
     const attached = client[HOOKS];
-    return new PostgresRuntimeClient(client, attached.onQuery, attached.onQueryHookError, attached.prepare, attached.fileRoot, attached.reloadSqlFiles);
+    return new PostgresRuntimeClient(client, attached.onQuery, attached.onQueryHookError, attached.prepare, attached.fileRoot, attached.reloadSqlFiles, attached.sqlFiles);
 }
 function getRuntimeClient() {
     defaultClient ??= createDefaultClient();
@@ -195,7 +198,7 @@ export function getClient() {
 export function setClient(client, options) {
     installJsonArrayCodecs(client);
     const attached = client[HOOKS];
-    defaultClient = new PostgresRuntimeClient(client, options?.onQuery ?? attached?.onQuery, options?.onQueryHookError ?? attached?.onQueryHookError, options?.prepare ?? attached?.prepare ?? client.options?.prepare ?? true, resolvedFileRoot(options?.fileRoot ?? attached?.fileRoot), options?.reloadSqlFiles ?? attached?.reloadSqlFiles ?? false);
+    defaultClient = new PostgresRuntimeClient(client, options?.onQuery ?? attached?.onQuery, options?.onQueryHookError ?? attached?.onQueryHookError, options?.prepare ?? attached?.prepare ?? client.options?.prepare ?? true, resolvedFileRoot(options?.fileRoot ?? attached?.fileRoot), options?.reloadSqlFiles ?? attached?.reloadSqlFiles ?? false, options?.sqlFiles ?? attached?.sqlFiles);
 }
 export async function close() {
     if (defaultClient) {
@@ -206,7 +209,7 @@ export async function close() {
 export function createSqlClient(url = process.env.DATABASE_URL, options = {}) {
     const client = createClient(url, options);
     const attached = client[HOOKS];
-    const runtimeClient = new PostgresRuntimeClient(client, attached.onQuery, attached.onQueryHookError, attached.prepare, attached.fileRoot, attached.reloadSqlFiles);
+    const runtimeClient = new PostgresRuntimeClient(client, attached.onQuery, attached.onQueryHookError, attached.prepare, attached.fileRoot, attached.reloadSqlFiles, attached.sqlFiles);
     const runtime = createSqlRuntime(() => runtimeClient);
     return {
         ...runtime,

package/dist/src/query-id.d.ts

@@ -0,0 +1 @@
+export declare function queryId(query: string): string;