@onreza/sqlx-js 0.4.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/index.d.ts

@@ -18,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>;
@@ -34,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/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) {

package/dist/src/runtime.d.ts

@@ -7,19 +7,47 @@ export type OnQueryEvent = {
     error?: unknown;
 };
 export type OnQueryHook = (event: OnQueryEvent) => void;
+export type RuntimeQueryResult = unknown[] & {
+    count?: number | null;
+    command?: string | null;
+};
 export type RuntimeClient = {
-    query: (query: string, params: unknown[]) => Promise<unknown[]>;
+    query: (query: string, params: unknown[]) => Promise<RuntimeQueryResult>;
     transformParam?: (param: unknown) => unknown;
     transaction: <R>(fn: (client: RuntimeClient) => Promise<R>) => Promise<R>;
     close: () => Promise<void>;
     onQuery?: OnQueryHook;
+    fileRoot?: string;
 };
 type AnyFn = (...args: unknown[]) => Promise<unknown[]>;
 type AnyOneFn = (...args: unknown[]) => Promise<unknown>;
 type AnyOptionalFn = (...args: unknown[]) => Promise<unknown | null>;
+type AnyExecuteFn = (...args: unknown[]) => Promise<ExecuteResult>;
 type IdentifierFn = (...parts: string[]) => string;
+declare const PARAMETER_KIND: unique symbol;
+export type JsonParameter<T = JsonInputValue> = {
+    readonly [PARAMETER_KIND]: "json";
+    readonly value: T;
+};
+export type PgArrayParameter<T = unknown> = {
+    readonly [PARAMETER_KIND]: "array";
+    readonly value: readonly (T | null)[];
+};
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonInputValue = JsonPrimitive | JsonInputObject | JsonInputArray;
+export type JsonInputObject = {
+    readonly [key: string]: JsonInputValue | undefined;
+};
+export type JsonInputArray = readonly JsonInputValue[];
+export type ExecuteResult = {
+    rowCount: number;
+    command: string;
+};
+export declare function json<T extends JsonInputValue>(value: T): JsonParameter<T>;
+export declare function array<T>(value: readonly (T | null)[]): PgArrayParameter<T>;
+export declare function parameterKind(value: unknown): "json" | "array" | undefined;
 declare function renameRows(rows: unknown[]): unknown[];
-declare function isPrimitiveArrayElement(v: unknown): boolean;
+export declare function isPrimitiveArrayElement(v: unknown): boolean;
 export declare function encodePgArrayLiteral(arr: unknown[]): string;
 type PgArrayValue<T> = T | null | PgArrayValue<T>[];
 export declare function parsePgArrayLiteral<T = string>(input: string, parseElement?: (value: string) => T): PgArrayValue<T>[];
@@ -40,21 +68,26 @@ export declare const _internal: {
     loadSqlFile: typeof loadSqlFile;
     buildSetTransaction: typeof buildSetTransaction;
     clearIdentifierCache: typeof clearIdentifierCache;
+    parameterKind: typeof parameterKind;
     toPgError: typeof toPgError;
 };
-declare function loadSqlFile(path: string): string;
+declare function loadSqlFile(path: string, fileRoot?: string): string;
 export declare function clearSqlFileCache(): void;
 declare function clearIdentifierCache(): void;
 export declare function id(...parts: string[]): string;
 type FileCallable = AnyFn & {
     one: AnyOneFn;
     optional: AnyOptionalFn;
+    execute: AnyExecuteFn;
 };
 type SqlCallable = AnyFn & {
     file: FileCallable;
     one: AnyOneFn;
     optional: AnyOptionalFn;
+    execute: AnyExecuteFn;
     id: IdentifierFn;
+    json: typeof json;
+    array: typeof array;
 };
 export type TransactionOptions = {
     isolation?: "read uncommitted" | "read committed" | "repeatable read" | "serializable";

package/dist/src/runtime.js

@@ -1,7 +1,19 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { resolve } from "node:path";
+import { isAbsolute, relative, resolve } from "node:path";
 import { PgClient, parseDatabaseUrl, PgError } from "./pg/wire.js";
 import { applyPending, acquireMigrateLock, releaseMigrateLock, DEFAULT_MIGRATE_LOCK_KEY } from "./commands/migrate.js";
+const PARAMETER_KIND = Symbol("sqlx-js.parameter");
+export function json(value) {
+    return { [PARAMETER_KIND]: "json", value };
+}
+export function array(value) {
+    return { [PARAMETER_KIND]: "array", value };
+}
+export function parameterKind(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    return value[PARAMETER_KIND];
+}
 const SUFFIX = /[!?]$/;
 function renameRows(rows) {
     if (rows.length === 0)
@@ -28,9 +40,11 @@ function renameRows(rows) {
     }
     return out;
 }
-function isPrimitiveArrayElement(v) {
+export function isPrimitiveArrayElement(v) {
     if (v === null || v === undefined)
         return true;
+    if (v instanceof Date || v instanceof Uint8Array)
+        return true;
     const t = typeof v;
     return t === "string" || t === "number" || t === "bigint" || t === "boolean";
 }
@@ -44,6 +58,18 @@ export function encodePgArrayLiteral(arr) {
             parts.push("NULL");
             continue;
         }
+        if (parameterKind(v) === "json") {
+            parts.push(quoteArrayElement(JSON.stringify(v.value)));
+            continue;
+        }
+        if (v instanceof Date) {
+            parts.push(quoteArrayElement(v.toISOString()));
+            continue;
+        }
+        if (v instanceof Uint8Array) {
+            parts.push(quoteArrayElement(`\\x${Buffer.from(v).toString("hex")}`));
+            continue;
+        }
         if (typeof v === "bigint") {
             parts.push(v.toString());
             continue;
@@ -126,13 +152,12 @@ export function parsePgArrayLiteral(input, parseElement = (value) => value) {
     return parsed;
 }
 export function encodeParam(p) {
-    if (!Array.isArray(p))
-        return p;
-    if (p.length === 0)
-        return p;
-    if (!p.every(isPrimitiveArrayElement))
-        return p;
-    return encodePgArrayLiteral(p);
+    const kind = parameterKind(p);
+    if (kind === "json")
+        return JSON.stringify(p.value);
+    if (kind === "array")
+        return encodePgArrayLiteral([...p.value]);
+    return p;
 }
 export class NoRowsError extends Error {
     constructor(message = "expected exactly 1 row, got 0") {
@@ -213,16 +238,17 @@ export const _internal = {
     loadSqlFile,
     buildSetTransaction,
     clearIdentifierCache,
+    parameterKind,
     toPgError,
 };
-async function runQuery(client, query, params) {
+async function runRawQuery(client, query, params) {
     const encoded = params.length === 0
         ? params
         : params.map((p) => client.transformParam ? client.transformParam(p) : encodeParam(p));
     const onQuery = client.onQuery;
     if (!onQuery) {
         try {
-            return renameRows(await client.query(query, encoded));
+            return await client.query(query, encoded);
         }
         catch (e) {
             throw toPgError(e) ?? e;
@@ -230,9 +256,14 @@ async function runQuery(client, query, params) {
     }
     const start = performance.now();
     try {
-        const rows = await client.query(query, encoded);
-        onQuery({ query, params, durationMs: performance.now() - start, rowCount: rows.length });
-        return renameRows(rows);
+        const result = await client.query(query, encoded);
+        onQuery({
+            query,
+            params,
+            durationMs: performance.now() - start,
+            rowCount: result.count ?? result.length,
+        });
+        return result;
     }
     catch (e) {
         const error = toPgError(e) ?? e;
@@ -240,6 +271,16 @@ async function runQuery(client, query, params) {
         throw error;
     }
 }
+async function runQuery(client, query, params) {
+    return renameRows(await runRawQuery(client, query, params));
+}
+async function runExecute(client, query, params) {
+    const result = await runRawQuery(client, query, params);
+    return {
+        rowCount: result.count ?? result.length,
+        command: result.command ?? "",
+    };
+}
 async function runOne(client, query, params) {
     const rows = await runQuery(client, query, params);
     if (rows.length === 1)
@@ -257,8 +298,16 @@ async function runOptional(client, query, params) {
     throw new TooManyRowsError(rows.length, "0 or 1");
 }
 const sqlFileCache = new Map();
-function loadSqlFile(path) {
-    const full = resolve(process.cwd(), path);
+function loadSqlFile(path, fileRoot = process.env.SQLX_JS_FILE_ROOT ?? process.cwd()) {
+    const root = resolve(fileRoot);
+    if (isAbsolute(path)) {
+        throw new Error(`sqlx-js.sql.file: path must be relative to fileRoot: ${path}`);
+    }
+    const full = resolve(root, path);
+    const rel = relative(root, full);
+    if (rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rel)) {
+        throw new Error(`sqlx-js.sql.file: path escapes fileRoot: ${path}`);
+    }
     try {
         const st = statSync(full);
         const cached = sqlFileCache.get(full);
@@ -393,13 +442,16 @@ function makeBoundCallable(client) {
         return runQuery(client, query, params);
     });
     const file = (async (path, ...params) => {
-        return runQuery(client, loadSqlFile(path), params);
+        return runQuery(client, loadSqlFile(path, client.fileRoot), params);
     });
     file.one = (async (path, ...params) => {
-        return runOne(client, loadSqlFile(path), params);
+        return runOne(client, loadSqlFile(path, client.fileRoot), params);
     });
     file.optional = (async (path, ...params) => {
-        return runOptional(client, loadSqlFile(path), params);
+        return runOptional(client, loadSqlFile(path, client.fileRoot), params);
+    });
+    file.execute = (async (path, ...params) => {
+        return runExecute(client, loadSqlFile(path, client.fileRoot), params);
     });
     fn.file = file;
     fn.one = (async (query, ...params) => {
@@ -408,7 +460,12 @@ function makeBoundCallable(client) {
     fn.optional = (async (query, ...params) => {
         return runOptional(client, query, params);
     });
+    fn.execute = (async (query, ...params) => {
+        return runExecute(client, query, params);
+    });
     fn.id = id;
+    fn.json = json;
+    fn.array = array;
     return fn;
 }
 function buildSetTransaction(opts) {
@@ -428,13 +485,20 @@ export function createSqlRuntime(getClient) {
         return runQuery(getClient(), query, params);
     });
     const rootFile = (async (path, ...params) => {
-        return runQuery(getClient(), loadSqlFile(path), params);
+        const client = getClient();
+        return runQuery(client, loadSqlFile(path, client.fileRoot), params);
     });
     rootFile.one = (async (path, ...params) => {
-        return runOne(getClient(), loadSqlFile(path), params);
+        const client = getClient();
+        return runOne(client, loadSqlFile(path, client.fileRoot), params);
     });
     rootFile.optional = (async (path, ...params) => {
-        return runOptional(getClient(), loadSqlFile(path), params);
+        const client = getClient();
+        return runOptional(client, loadSqlFile(path, client.fileRoot), params);
+    });
+    rootFile.execute = (async (path, ...params) => {
+        const client = getClient();
+        return runExecute(client, loadSqlFile(path, client.fileRoot), params);
     });
     root.file = rootFile;
     root.one = (async (query, ...params) => {
@@ -443,7 +507,12 @@ export function createSqlRuntime(getClient) {
     root.optional = (async (query, ...params) => {
         return runOptional(getClient(), query, params);
     });
+    root.execute = (async (query, ...params) => {
+        return runExecute(getClient(), query, params);
+    });
     root.id = id;
+    root.json = json;
+    root.array = array;
     root.transaction = (async (fnOrOpts, maybeFn) => {
         const c = getClient();
         let opts = {};