@onreza/sqlx-js 0.3.0 → 0.5.0

package/dist/src/config.js

@@ -1,18 +1,148 @@
-import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
-export async function loadConfig(root) {
-    for (const name of ["sqlx-js.config.ts", "sqlx-js.config.js", "sqlx-js.config.mjs"]) {
+import { pathToFileURL } from "node:url";
+import { parseEnv } from "node:util";
+export function defineConfig(config) {
+    return config;
+}
+export function loadRootEnv(root) {
+    const path = join(root, ".env");
+    if (!existsSync(path))
+        return undefined;
+    const parsed = parseEnv(readFileSync(path, "utf8"));
+    for (const [key, value] of Object.entries(parsed)) {
+        if (process.env[key] === undefined)
+            process.env[key] = value;
+    }
+    return path;
+}
+export function configPath(root) {
+    for (const name of ["sqlx-js.config.mts", "sqlx-js.config.ts", "sqlx-js.config.mjs", "sqlx-js.config.js"]) {
         const p = join(root, name);
-        if (!existsSync(p))
-            continue;
-        const mod = await import(p);
-        const cfg = (mod.default ?? mod);
-        if (typeof cfg !== "object" || cfg === null) {
-            throw new Error(`sqlx-js: ${name} must default-export a config object`);
+        if (existsSync(p))
+            return p;
+    }
+    return undefined;
+}
+export async function loadConfig(root) {
+    const path = configPath(root);
+    if (!path)
+        return {};
+    const url = pathToFileURL(path);
+    url.searchParams.set("mtime", String(statSync(path).mtimeMs));
+    const mod = await import(url.href);
+    if (!("default" in mod)) {
+        throw new Error(`sqlx-js: ${path} must default-export a config object`);
+    }
+    return validateConfig(mod.default, path);
+}
+function validateStringRecord(value, name, path) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`sqlx-js: ${path} ${name} must be an object of string values`);
+    }
+    for (const [key, item] of Object.entries(value)) {
+        if (typeof item !== "string") {
+            throw new Error(`sqlx-js: ${path} ${name}.${key} must be a string`);
+        }
+    }
+}
+function validateStringArray(value, name, path) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new Error(`sqlx-js: ${path} ${name} must be an array of strings`);
+    }
+}
+function validateConfig(value, path) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`sqlx-js: ${path} must default-export a config object`);
+    }
+    const config = value;
+    if (config.jsonbTypes !== undefined)
+        validateStringRecord(config.jsonbTypes, "jsonbTypes", path);
+    if (config.customTypes !== undefined)
+        validateStringRecord(config.customTypes, "customTypes", path);
+    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`);
         }
-        return cfg;
+        const scan = config.scan;
+        if (scan.include !== undefined)
+            validateStringArray(scan.include, "scan.include", path);
+        if (scan.exclude !== undefined)
+            validateStringArray(scan.exclude, "scan.exclude", path);
     }
-    return {};
+    if (config.schema !== undefined) {
+        if (!config.schema || typeof config.schema !== "object" || Array.isArray(config.schema)) {
+            throw new Error(`sqlx-js: ${path} schema must be an object`);
+        }
+        const schema = config.schema;
+        if (schema.provider !== undefined && schema.provider !== "builtin" && schema.provider !== "pgschema") {
+            throw new Error(`sqlx-js: ${path} schema.provider must be builtin or pgschema`);
+        }
+        for (const key of ["file", "command"]) {
+            if (schema[key] !== undefined && typeof schema[key] !== "string") {
+                throw new Error(`sqlx-js: ${path} schema.${key} must be a string`);
+            }
+        }
+        if (schema.schemas !== undefined)
+            validateStringArray(schema.schemas, "schema.schemas", path);
+    }
+    return value;
+}
+export function prepareConfigHash(cfg) {
+    const value = stableValue({
+        jsonbTypes: cfg.jsonbTypes ?? {},
+        customTypes: cfg.customTypes ?? {},
+    });
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16);
+}
+export function configHash(cfg) {
+    return createHash("sha256").update(JSON.stringify(stableValue(cfg))).digest("hex").slice(0, 16);
+}
+function stableValue(value) {
+    if (Array.isArray(value))
+        return value.map(stableValue);
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, item]) => [key, stableValue(item)]));
+}
+export async function loadConfigInfo(root) {
+    const path = configPath(root);
+    if (!path)
+        return { config: {} };
+    return { config: await loadConfig(root), path };
+}
+export function assertSupportedRuntime() {
+    const bun = process.versions.bun;
+    if (bun) {
+        if (majorMinorLessThan(bun, 1, 3)) {
+            throw new Error(`sqlx-js requires Bun >=1.3, current ${bun}`);
+        }
+        return;
+    }
+    const node = process.versions.node;
+    if (majorMinorLessThan(node, 24, 0)) {
+        throw new Error(`sqlx-js requires Node.js >=24, current ${node}`);
+    }
+}
+function majorMinorLessThan(version, minMajor, minMinor) {
+    const [major = 0, minor = 0] = version.split(".").map(Number);
+    return major < minMajor || (major === minMajor && minor < minMinor);
+}
+export function runtimeVersion() {
+    if (process.versions.bun)
+        return { runtime: "bun", version: process.versions.bun };
+    return { runtime: "node", version: process.versions.node };
+}
+export function nativeTypeScriptEnabled() {
+    if (process.versions.bun)
+        return true;
+    return process.features.typescript;
+}
+export function envFilePath(root) {
+    return join(root, ".env");
 }
 export function lookupJsonbType(cfg, schema, table, column) {
     const types = cfg.jsonbTypes;

package/dist/src/function-cache.d.ts

@@ -0,0 +1,18 @@
+export type FunctionKind = "function" | "procedure" | "aggregate" | "window";
+export type FunctionParamMode = "in" | "out" | "inout" | "variadic" | "table";
+export type FunctionParamEntry = {
+    mode: FunctionParamMode;
+    tsType: string;
+    name?: string;
+};
+export type FunctionEntry = {
+    schema: string;
+    name: string;
+    signature: string;
+    kind: FunctionKind;
+    params: FunctionParamEntry[];
+    returns: string;
+    returnsSet: boolean;
+};
+export declare function readFunctionCache(cacheDir: string): FunctionEntry[];
+export declare function writeFunctionCache(cacheDir: string, functions: FunctionEntry[]): void;

package/dist/src/function-cache.js

@@ -0,0 +1,38 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+function cachePath(cacheDir) {
+    return join(cacheDir, "functions", "functions.json");
+}
+function parseFunctionCache(raw) {
+    if (!raw || typeof raw !== "object")
+        return [];
+    const obj = raw;
+    if (obj.version !== 1 || !Array.isArray(obj.functions))
+        return [];
+    return obj.functions;
+}
+export function readFunctionCache(cacheDir) {
+    const path = cachePath(cacheDir);
+    if (!existsSync(path))
+        return [];
+    const text = readFileSync(path, "utf8");
+    return parseFunctionCache(JSON.parse(text));
+}
+export function writeFunctionCache(cacheDir, functions) {
+    const path = cachePath(cacheDir);
+    mkdirSync(dirname(path), { recursive: true });
+    const payload = { version: 1, functions };
+    const tmp = `${path}.tmp-${randomBytes(4).toString("hex")}`;
+    writeFileSync(tmp, JSON.stringify(payload, null, 2));
+    try {
+        renameSync(tmp, path);
+    }
+    catch (err) {
+        try {
+            unlinkSync(tmp);
+        }
+        catch { }
+        throw err;
+    }
+}

package/dist/src/index.d.ts

@@ -4,6 +4,8 @@ export interface KnownQueries {
 }
 export interface KnownFileQueries {
 }
+export interface KnownFunctions {
+}
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 export type JsonObject = {
@@ -16,11 +18,13 @@ export type JsonInputObject = {
     readonly [key: string]: JsonInputValue | undefined;
 };
 export type JsonInputArray = readonly JsonInputValue[];
-export type { SqlxJsConfig } from "./config.js";
+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 type { TransactionOptions, MigrateOptions, OnQueryEvent, OnQueryHook } from "./runtime.js";
+export type { ExecuteResult, JsonParameter, PgArrayParameter } from "./runtime.js";
 export type { PostgresClient, PostgresOptions, CreateClientOptions } from "./postgres-runtime.js";
 export type TypedFile = TypedFileFor<KnownFileQueries>;
 export type TypedSql = TypedSqlFor<KnownQueries, KnownFileQueries>;
@@ -32,4 +36,4 @@ export declare const getClient: typeof rt.getClient;
 export declare const setClient: typeof rt.setClient;
 export declare const createClient: typeof rt.createClient;
 export declare const close: typeof rt.close;
-export { migrate, clearSqlFileCache, encodePgArrayLiteral, id } from "./runtime.js";
+export { migrate, clearSqlFileCache, encodePgArrayLiteral, id, json, array } from "./runtime.js";

package/dist/src/index.js

@@ -1,4 +1,5 @@
 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 const sql = rt.sql;
@@ -7,4 +8,4 @@ export const getClient = rt.getClient;
 export const setClient = rt.setClient;
 export const createClient = rt.createClient;
 export const close = rt.close;
-export { migrate, clearSqlFileCache, encodePgArrayLiteral, id } from "./runtime.js";
+export { migrate, clearSqlFileCache, encodePgArrayLiteral, id, json, array } from "./runtime.js";

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

@@ -0,0 +1,4 @@
+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[]>;

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

@@ -42,6 +42,8 @@ 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" },

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/dist/src/postgres-runtime.d.ts

@@ -7,11 +7,14 @@ export type PostgresOptions = postgres.Options<Record<string, postgres.PostgresT
 export type CreateClientOptions = PostgresOptions & {
     onQuery?: OnQueryHook;
     statementTimeoutMs?: number;
+    fileRoot?: string;
 };
 export declare function createClient(url?: string | undefined, options?: CreateClientOptions): PostgresClient;
 export declare function getClient(): PostgresClient;
 export declare function setClient(client: PostgresClient, options?: {
     onQuery?: OnQueryHook;
+    prepare?: boolean;
+    fileRoot?: string;
 }): void;
 export declare function close(): Promise<void>;
 export declare const sql: import("./runtime.js").SqlRoot;

package/dist/src/postgres-runtime.js

@@ -1,28 +1,45 @@
 import postgres from "postgres";
-import { createSqlRuntime, encodeParam, encodePgArrayLiteral, parsePgArrayLiteral } from "./runtime.js";
+import { resolve } from "node:path";
+import { createSqlRuntime, encodePgArrayLiteral, isPrimitiveArrayElement, parameterKind, parsePgArrayLiteral, } from "./runtime.js";
 import { arrayElementOid, builtinArrayOids } from "./pg/oids.js";
 const HOOKS = Symbol.for("sqlx-js.hooks");
+function resolvedFileRoot(value) {
+    return resolve(value ?? process.env.SQLX_JS_FILE_ROOT ?? process.cwd());
+}
 class PostgresRuntimeClient {
     client;
     onQuery;
-    constructor(client, onQuery) {
+    prepare;
+    fileRoot;
+    constructor(client, onQuery, prepare = true, fileRoot = resolvedFileRoot()) {
         this.client = client;
         this.onQuery = onQuery;
+        this.prepare = prepare;
+        this.fileRoot = fileRoot;
     }
     async query(query, params) {
-        return await this.client.unsafe(query, params, { prepare: true });
+        return await this.client.unsafe(query, params, { prepare: this.prepare });
     }
     transformParam(param) {
-        const elementOid = postgresNativeArrayElementOid(param);
-        if (elementOid !== undefined)
-            return this.client.array(param, elementOid);
-        return encodeParam(param);
+        const kind = parameterKind(param);
+        if (kind === "json")
+            return this.client.json(param.value);
+        if (kind === "array") {
+            const value = [...param.value];
+            if (value.every(isPrimitiveArrayElement))
+                return encodePgArrayLiteral(value);
+            if (value.every((item) => item === null || parameterKind(item) === "json")) {
+                return this.client.array(value, 3807);
+            }
+            return this.client.array(value);
+        }
+        return param;
     }
     async transaction(fn) {
         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));
+            return await fn(new PostgresRuntimeClient(tx, this.onQuery, this.prepare, this.fileRoot));
         });
     }
     async close() {
@@ -74,6 +91,7 @@ const STRING_ARRAY_ELEMENT_OIDS = new Set([
     4451,
     4536,
 ]);
+const JSON_ELEMENT_OIDS = new Set([114, 3802]);
 function parseSimpleArrayElement(oid) {
     switch (oid) {
         case 16:
@@ -90,28 +108,21 @@ function parseSimpleArrayElement(oid) {
             return STRING_ARRAY_ELEMENT_OIDS.has(oid) ? (value) => value : undefined;
     }
 }
-function postgresNativeArrayElementOid(value) {
-    if (!Array.isArray(value) || value.length === 0)
-        return undefined;
-    let oid;
-    for (const item of value) {
-        if (item === null)
-            continue;
-        const itemOid = item instanceof Uint8Array ? 17 : undefined;
-        if (itemOid === undefined)
-            return undefined;
-        if (oid !== undefined && oid !== itemOid)
-            return undefined;
-        oid = itemOid;
-    }
-    return oid;
-}
 function postgresTypes() {
     const types = { bigint: postgres.BigInt };
     for (const oid of builtinArrayOids()) {
         const elementOid = arrayElementOid(oid);
         if (elementOid === undefined)
             continue;
+        if (JSON_ELEMENT_OIDS.has(elementOid)) {
+            types[`array_${oid}`] = {
+                to: oid,
+                from: [oid],
+                serialize: (value) => Array.isArray(value) ? encodePgArrayLiteral(value) : String(value),
+                parse: (value) => parsePgArrayLiteral(value, JSON.parse),
+            };
+            continue;
+        }
         const parseElement = parseSimpleArrayElement(elementOid);
         if (!parseElement)
             continue;
@@ -124,10 +135,30 @@ function postgresTypes() {
     }
     return types;
 }
+function typeOids(value) {
+    if (value === null || value === undefined)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function installJsonArrayCodecs(client) {
+    const options = client.options;
+    options.parsers ??= {};
+    options.serializers ??= {};
+    const configured = Object.values(options.types ?? {});
+    for (const oid of [199, 3807]) {
+        const hasParser = configured.some((type) => typeOids(type.from).includes(oid));
+        const hasSerializer = configured.some((type) => type.to === oid);
+        if (!hasParser)
+            options.parsers[oid] = (value) => parsePgArrayLiteral(value, JSON.parse);
+        if (!hasSerializer) {
+            options.serializers[oid] = (value) => Array.isArray(value) ? encodePgArrayLiteral(value) : String(value);
+        }
+    }
+}
 export function createClient(url = process.env.DATABASE_URL, options = {}) {
     if (!url)
         throw new Error("sqlx-js: DATABASE_URL is not set");
-    const { onQuery, statementTimeoutMs, ...pgOptions } = options;
+    const { onQuery, statementTimeoutMs, fileRoot, ...pgOptions } = options;
     const connection = statementTimeoutMs !== undefined
         ? { ...(pgOptions.connection ?? {}), statement_timeout: statementTimeoutMs }
         : pgOptions.connection;
@@ -136,12 +167,17 @@ export function createClient(url = process.env.DATABASE_URL, options = {}) {
         ...(connection ? { connection } : {}),
         types: { ...postgresTypes(), ...(pgOptions.types ?? {}) },
     });
-    if (onQuery)
-        client[HOOKS] = { onQuery };
+    client[HOOKS] = {
+        onQuery,
+        prepare: pgOptions.prepare ?? true,
+        fileRoot: resolvedFileRoot(fileRoot),
+    };
     return client;
 }
 function createDefaultClient() {
-    return new PostgresRuntimeClient(createClient());
+    const client = createClient();
+    const attached = client[HOOKS];
+    return new PostgresRuntimeClient(client, attached.onQuery, attached.prepare, attached.fileRoot);
 }
 function getRuntimeClient() {
     defaultClient ??= createDefaultClient();
@@ -151,8 +187,9 @@ export function getClient() {
     return getRuntimeClient().client;
 }
 export function setClient(client, options) {
+    installJsonArrayCodecs(client);
     const attached = client[HOOKS];
-    defaultClient = new PostgresRuntimeClient(client, options?.onQuery ?? attached?.onQuery);
+    defaultClient = new PostgresRuntimeClient(client, options?.onQuery ?? attached?.onQuery, options?.prepare ?? attached?.prepare ?? client.options?.prepare ?? true, resolvedFileRoot(options?.fileRoot ?? attached?.fileRoot));
 }
 export async function close() {
     if (defaultClient) {