@onreza/sqlx-js 0.6.0 → 0.7.0

package/dist/src/pg/schema.js

@@ -49,34 +49,38 @@ export class SchemaCache {
         }
     }
     async loadTableNames(names) {
-        const need = [];
+        const explicit = [];
+        const visible = [];
         for (const n of names) {
-            const schema = n.schema ?? "public";
-            const key = `${schema}.${n.name}`;
-            if (!this.nameToOid.has(key))
-                need.push({ schema, name: n.name });
+            if (n.schema) {
+                if (!this.nameToOid.has(`${n.schema}.${n.name}`))
+                    explicit.push({ schema: n.schema, name: n.name });
+            }
+            else if (!this.nameToOid.has(unqualifiedKey(n.name))) {
+                visible.push(n.name);
+            }
         }
-        if (need.length === 0)
-            return;
-        const where = need.map((n) => `(n.nspname = ${quote(n.schema)} AND c.relname = ${quote(n.name)})`).join(" OR ");
-        const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE ${where}`;
-        const r = await this.client.simpleQueryAll(sql);
-        for (const row of r.rows) {
-            const oid = Number(decodeText(row[0]));
-            const schema = decodeText(row[1]);
-            const name = decodeText(row[2]);
-            const k = `${schema}.${name}`;
-            const arr = this.nameToOid.get(k) ?? [];
-            arr.push(oid);
-            this.nameToOid.set(k, arr);
-            this.oidToName.set(oid, { schema, name });
+        if (explicit.length > 0) {
+            const where = explicit.map((n) => `(n.nspname = ${quote(n.schema)} AND c.relname = ${quote(n.name)})`).join(" OR ");
+            const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE ${where}`;
+            const result = await this.client.simpleQueryAll(sql);
+            for (const row of result.rows)
+                this.recordTable(row);
+        }
+        if (visible.length > 0) {
+            const requested = [...new Set(visible)].map(quote).join(",");
+            const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE c.relname IN (${requested}) AND pg_table_is_visible(c.oid)`;
+            const result = await this.client.simpleQueryAll(sql);
+            for (const row of result.rows) {
+                this.recordTable(row, true);
+            }
         }
     }
     isNotNull(tableOid, attno) {
         return this.byOidNum.get(key(tableOid, attno))?.notNull;
     }
     resolveTable(schema, name) {
-        const k = `${schema ?? "public"}.${name}`;
+        const k = schema ? `${schema}.${name}` : unqualifiedKey(name);
         const arr = this.nameToOid.get(k);
         return arr?.[0];
     }
@@ -89,17 +93,21 @@ export class SchemaCache {
             return;
         const sql = `SELECT c.oid::int8, n.nspname, c.relname FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace WHERE c.oid IN (${need.join(",")})`;
         const r = await this.client.simpleQueryAll(sql);
-        for (const row of r.rows) {
-            const oid = Number(decodeText(row[0]));
-            const schema = decodeText(row[1]);
-            const name = decodeText(row[2]);
-            const k = `${schema}.${name}`;
-            const arr = this.nameToOid.get(k) ?? [];
-            if (!arr.includes(oid))
-                arr.push(oid);
-            this.nameToOid.set(k, arr);
-            this.oidToName.set(oid, { schema, name });
-        }
+        for (const row of r.rows)
+            this.recordTable(row);
+    }
+    recordTable(row, visible = false) {
+        const oid = Number(decodeText(row[0]));
+        const schema = decodeText(row[1]);
+        const name = decodeText(row[2]);
+        const key = `${schema}.${name}`;
+        const arr = this.nameToOid.get(key) ?? [];
+        if (!arr.includes(oid))
+            arr.push(oid);
+        this.nameToOid.set(key, arr);
+        if (visible)
+            this.nameToOid.set(unqualifiedKey(name), [oid]);
+        this.oidToName.set(oid, { schema, name });
     }
     columnNameByAttno(tableOid, attno) {
         return this.byOidNum.get(key(tableOid, attno))?.name;
@@ -269,6 +277,9 @@ export class SchemaCache {
 function key(oid, attno) {
     return `${oid}/${attno}`;
 }
+function unqualifiedKey(name) {
+    return `\0${name}`;
+}
 function quote(s) {
     return `'${s.replace(/'/g, "''")}'`;
 }

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

@@ -8,6 +8,7 @@ export type ConnConfig = {
     database: string;
     sslmode?: SslMode;
     applicationName?: string;
+    startupOptions?: string;
     connectTimeoutMs?: number;
     statementTimeoutMs?: number;
     sslRootCert?: string;

package/dist/src/pg/wire.js

@@ -26,6 +26,9 @@ export function parseDatabaseUrl(url) {
     const appName = params.get("application_name");
     if (appName)
         cfg.applicationName = appName;
+    const startupOptions = params.get("options");
+    if (startupOptions)
+        cfg.startupOptions = startupOptions;
     const ct = params.get("connect_timeout");
     if (ct) {
         const n = Number(ct);
@@ -446,6 +449,9 @@ export class PgClient {
         if (this.cfg.applicationName) {
             pairs.push(cstr("application_name"), cstr(this.cfg.applicationName));
         }
+        if (this.cfg.startupOptions) {
+            pairs.push(cstr("options"), cstr(this.cfg.startupOptions));
+        }
         if (this.cfg.statementTimeoutMs !== undefined) {
             pairs.push(cstr("statement_timeout"), cstr(String(this.cfg.statementTimeoutMs)));
         }

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

@@ -1,21 +1,31 @@
 import postgres from "postgres";
-import { type OnQueryHook } from "./runtime.js";
+import { type OnQueryHook, type OnQueryHookError } from "./runtime.js";
 export type PostgresClient = postgres.Sql<{
     bigint: bigint;
 }>;
 export type PostgresOptions = postgres.Options<Record<string, postgres.PostgresType>>;
 export type CreateClientOptions = PostgresOptions & {
     onQuery?: OnQueryHook;
+    onQueryHookError?: OnQueryHookError;
     statementTimeoutMs?: number;
     fileRoot?: string;
+    reloadSqlFiles?: boolean;
 };
 export declare function createClient(url?: string | undefined, options?: CreateClientOptions): PostgresClient;
 export declare function getClient(): PostgresClient;
 export declare function setClient(client: PostgresClient, options?: {
     onQuery?: OnQueryHook;
+    onQueryHookError?: OnQueryHookError;
     prepare?: boolean;
     fileRoot?: string;
+    reloadSqlFiles?: boolean;
 }): void;
 export declare function close(): Promise<void>;
+export declare function createSqlClient(url?: string | undefined, options?: CreateClientOptions): {
+    client: PostgresClient;
+    close: () => Promise<void>;
+    sql: import("./runtime.js").SqlRoot;
+    unsafe: (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;
+};
 export declare const sql: import("./runtime.js").SqlRoot;
 export declare const unsafe: (query: string, ...params: unknown[]) => Promise<Record<string, unknown>[]>;

package/dist/src/postgres-runtime.js

@@ -9,13 +9,17 @@ function resolvedFileRoot(value) {
 class PostgresRuntimeClient {
     client;
     onQuery;
+    onQueryHookError;
     prepare;
     fileRoot;
-    constructor(client, onQuery, prepare = true, fileRoot = resolvedFileRoot()) {
+    reloadSqlFiles;
+    constructor(client, onQuery, onQueryHookError, prepare = true, fileRoot = resolvedFileRoot(), reloadSqlFiles = false) {
         this.client = client;
         this.onQuery = onQuery;
+        this.onQueryHookError = onQueryHookError;
         this.prepare = prepare;
         this.fileRoot = fileRoot;
+        this.reloadSqlFiles = reloadSqlFiles;
     }
     async query(query, params) {
         return await this.client.unsafe(query, params, { prepare: this.prepare });
@@ -39,7 +43,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.prepare, this.fileRoot));
+            return await fn(new PostgresRuntimeClient(tx, this.onQuery, this.onQueryHookError, this.prepare, this.fileRoot, this.reloadSqlFiles));
         });
     }
     async close() {
@@ -158,7 +162,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, statementTimeoutMs, fileRoot, ...pgOptions } = options;
+    const { onQuery, onQueryHookError, statementTimeoutMs, fileRoot, reloadSqlFiles, ...pgOptions } = options;
     const connection = statementTimeoutMs !== undefined
         ? { ...(pgOptions.connection ?? {}), statement_timeout: statementTimeoutMs }
         : pgOptions.connection;
@@ -169,15 +173,17 @@ export function createClient(url = process.env.DATABASE_URL, options = {}) {
     });
     client[HOOKS] = {
         onQuery,
+        onQueryHookError,
         prepare: pgOptions.prepare ?? true,
         fileRoot: resolvedFileRoot(fileRoot),
+        reloadSqlFiles: reloadSqlFiles ?? false,
     };
     return client;
 }
 function createDefaultClient() {
     const client = createClient();
     const attached = client[HOOKS];
-    return new PostgresRuntimeClient(client, attached.onQuery, attached.prepare, attached.fileRoot);
+    return new PostgresRuntimeClient(client, attached.onQuery, attached.onQueryHookError, attached.prepare, attached.fileRoot, attached.reloadSqlFiles);
 }
 function getRuntimeClient() {
     defaultClient ??= createDefaultClient();
@@ -189,7 +195,7 @@ export function getClient() {
 export function setClient(client, options) {
     installJsonArrayCodecs(client);
     const attached = client[HOOKS];
-    defaultClient = new PostgresRuntimeClient(client, options?.onQuery ?? attached?.onQuery, options?.prepare ?? attached?.prepare ?? client.options?.prepare ?? true, resolvedFileRoot(options?.fileRoot ?? attached?.fileRoot));
+    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);
 }
 export async function close() {
     if (defaultClient) {
@@ -197,6 +203,17 @@ export async function close() {
         defaultClient = null;
     }
 }
+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 runtime = createSqlRuntime(() => runtimeClient);
+    return {
+        ...runtime,
+        client,
+        close: async () => runtimeClient.close(),
+    };
+}
 const runtime = createSqlRuntime(getRuntimeClient);
 export const sql = runtime.sql;
 export const unsafe = runtime.unsafe;

package/dist/src/runtime.d.ts

@@ -6,7 +6,8 @@ export type OnQueryEvent = {
     rowCount?: number;
     error?: unknown;
 };
-export type OnQueryHook = (event: OnQueryEvent) => void;
+export type OnQueryHook = (event: OnQueryEvent) => void | Promise<void>;
+export type OnQueryHookError = (error: unknown, event: OnQueryEvent) => void | Promise<void>;
 export type RuntimeQueryResult = unknown[] & {
     count?: number | null;
     command?: string | null;
@@ -17,7 +18,9 @@ export type RuntimeClient = {
     transaction: <R>(fn: (client: RuntimeClient) => Promise<R>) => Promise<R>;
     close: () => Promise<void>;
     onQuery?: OnQueryHook;
+    onQueryHookError?: OnQueryHookError;
     fileRoot?: string;
+    reloadSqlFiles?: boolean;
 };
 type AnyFn = (...args: unknown[]) => Promise<unknown[]>;
 type AnyOneFn = (...args: unknown[]) => Promise<unknown>;
@@ -71,7 +74,7 @@ export declare const _internal: {
     parameterKind: typeof parameterKind;
     toPgError: typeof toPgError;
 };
-declare function loadSqlFile(path: string, fileRoot?: string): string;
+declare function loadSqlFile(path: string, fileRoot?: string, reload?: boolean): string;
 export declare function clearSqlFileCache(): void;
 declare function clearIdentifierCache(): void;
 export declare function id(...parts: string[]): string;

package/dist/src/runtime.js

@@ -257,7 +257,7 @@ async function runRawQuery(client, query, params) {
     const start = performance.now();
     try {
         const result = await client.query(query, encoded);
-        onQuery({
+        notifyQuery(client, {
             query,
             params,
             durationMs: performance.now() - start,
@@ -267,10 +267,29 @@ async function runRawQuery(client, query, params) {
     }
     catch (e) {
         const error = toPgError(e) ?? e;
-        onQuery({ query, params, durationMs: performance.now() - start, error });
+        notifyQuery(client, { query, params, durationMs: performance.now() - start, error });
         throw error;
     }
 }
+function notifyQuery(client, event) {
+    try {
+        const pending = client.onQuery?.(event);
+        if (pending)
+            void pending.catch((error) => notifyQueryHookError(client, error, event));
+    }
+    catch (error) {
+        notifyQueryHookError(client, error, event);
+    }
+}
+function notifyQueryHookError(client, error, event) {
+    try {
+        const pending = client.onQueryHookError?.(error, event);
+        if (pending)
+            void pending.catch(() => { });
+    }
+    catch {
+    }
+}
 async function runQuery(client, query, params) {
     return renameRows(await runRawQuery(client, query, params));
 }
@@ -298,7 +317,7 @@ async function runOptional(client, query, params) {
     throw new TooManyRowsError(rows.length, "0 or 1");
 }
 const sqlFileCache = new Map();
-function loadSqlFile(path, fileRoot = process.env.SQLX_JS_FILE_ROOT ?? process.cwd()) {
+function loadSqlFile(path, fileRoot = process.env.SQLX_JS_FILE_ROOT ?? process.cwd(), reload = false) {
     const root = resolve(fileRoot);
     if (isAbsolute(path)) {
         throw new Error(`sqlx-js.sql.file: path must be relative to fileRoot: ${path}`);
@@ -309,8 +328,10 @@ function loadSqlFile(path, fileRoot = process.env.SQLX_JS_FILE_ROOT ?? process.c
         throw new Error(`sqlx-js.sql.file: path escapes fileRoot: ${path}`);
     }
     try {
-        const st = statSync(full);
         const cached = sqlFileCache.get(full);
+        if (cached && !reload)
+            return cached.content;
+        const st = statSync(full);
         if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
             return cached.content;
         }
@@ -442,16 +463,16 @@ function makeBoundCallable(client) {
         return runQuery(client, query, params);
     });
     const file = (async (path, ...params) => {
-        return runQuery(client, loadSqlFile(path, client.fileRoot), params);
+        return runQuery(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
     });
     file.one = (async (path, ...params) => {
-        return runOne(client, loadSqlFile(path, client.fileRoot), params);
+        return runOne(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
     });
     file.optional = (async (path, ...params) => {
-        return runOptional(client, loadSqlFile(path, client.fileRoot), params);
+        return runOptional(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
     });
     file.execute = (async (path, ...params) => {
-        return runExecute(client, loadSqlFile(path, client.fileRoot), params);
+        return runExecute(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
     });
     fn.file = file;
     fn.one = (async (query, ...params) => {
@@ -486,19 +507,19 @@ export function createSqlRuntime(getClient) {
     });
     const rootFile = (async (path, ...params) => {
         const client = getClient();
-        return runQuery(client, loadSqlFile(path, client.fileRoot), params);
+        return runQuery(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
     });
     rootFile.one = (async (path, ...params) => {
         const client = getClient();
-        return runOne(client, loadSqlFile(path, client.fileRoot), params);
+        return runOne(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
     });
     rootFile.optional = (async (path, ...params) => {
         const client = getClient();
-        return runOptional(client, loadSqlFile(path, client.fileRoot), params);
+        return runOptional(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
     });
     rootFile.execute = (async (path, ...params) => {
         const client = getClient();
-        return runExecute(client, loadSqlFile(path, client.fileRoot), params);
+        return runExecute(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
     });
     root.file = rootFile;
     root.one = (async (query, ...params) => {

package/dist/src/scan/scanner.js

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import { existsSync, readFileSync } from "node:fs";
-import { isAbsolute, join, relative, resolve } from "node:path";
+import { extname, isAbsolute, join, relative, resolve } from "node:path";
 export class ScanError extends Error {
     file;
     line;
@@ -76,7 +76,7 @@ function classifyCallee(callee, scope) {
     const methodName = callee.name.text;
     if (ts.isIdentifier(callee.expression)) {
         const id = callee.expression.text;
-        if (scope.namespaces.has(id)) {
+        if (scope.namespaces.has(id) || scope.clients.has(id)) {
             if (methodName === "sql")
                 return { kind: "inline" };
             return null;
@@ -95,8 +95,9 @@ function classifyCallee(callee, scope) {
         const mid = callee.expression;
         if (!ts.isIdentifier(mid.name))
             return null;
-        // ns.sql.X(...) chains
-        if (ts.isIdentifier(mid.expression) && scope.namespaces.has(mid.expression.text)) {
+        // ns.sql.X(...) and client.sql.X(...) chains
+        if (ts.isIdentifier(mid.expression) &&
+            (scope.namespaces.has(mid.expression.text) || scope.clients.has(mid.expression.text))) {
             if (mid.name.text !== "sql")
                 return null;
             if (methodName === "one" || methodName === "optional" || methodName === "execute")
@@ -118,11 +119,11 @@ function classifyCallee(callee, scope) {
                 return { kind: "file" };
             return null;
         }
-        // ns.sql.file.X(...) chains
+        // ns.sql.file.X(...) and client.sql.file.X(...) chains
         if (ts.isPropertyAccessExpression(mid.expression) &&
             ts.isIdentifier(mid.expression.expression) &&
             ts.isIdentifier(mid.expression.name) &&
-            scope.namespaces.has(mid.expression.expression.text) &&
+            (scope.namespaces.has(mid.expression.expression.text) || scope.clients.has(mid.expression.expression.text)) &&
             mid.expression.name.text === "sql" &&
             mid.name.text === "file" &&
             (methodName === "one" || methodName === "optional" || methodName === "execute")) {
@@ -133,9 +134,18 @@ function classifyCallee(callee, scope) {
 }
 export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
     const text = readFileSync(absPath, "utf8");
-    const source = ts.createSourceFile(absPath, text, ts.ScriptTarget.ESNext, false, ts.ScriptKind.TSX);
+    const source = ts.createSourceFile(absPath, text, ts.ScriptTarget.ESNext, false, scriptKind(absPath));
+    const parseDiagnostics = source.parseDiagnostics ?? [];
+    const parseError = parseDiagnostics.find((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    if (parseError) {
+        const start = parseError.start ?? 0;
+        const { line, character } = source.getLineAndCharacterOfPosition(start);
+        const file = relative(root, absPath).replace(/\\/g, "/");
+        throw new ScanError(file, line + 1, character + 1, ts.flattenDiagnosticMessageText(parseError.messageText, "\n"));
+    }
     const importedAliases = new Set();
     const importedNamespaces = new Set();
+    const importedClientFactories = new Set();
     for (const stmt of source.statements) {
         if (!ts.isImportDeclaration(stmt))
             continue;
@@ -158,17 +168,19 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
                 const orig = (elem.propertyName ?? elem.name).text;
                 if (orig === "sql")
                     importedAliases.add(elem.name.text);
+                if (orig === "createSqlClient")
+                    importedClientFactories.add(elem.name.text);
             }
         }
     }
-    if (importedAliases.size === 0 && importedNamespaces.size === 0)
+    if (importedAliases.size === 0 && importedNamespaces.size === 0 && importedClientFactories.size === 0)
         return [];
     const out = [];
     const here = (node) => {
         const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
         return { line: line + 1, column: character + 1 };
     };
-    const fileRel = relative(root, absPath);
+    const fileRel = relative(root, absPath).replace(/\\/g, "/");
     const recordInline = (first, args) => {
         if (!ts.isStringLiteralLike(first)) {
             const pos = here(first);
@@ -233,6 +245,8 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
         let changed = false;
         const nextSql = new Set(scope.sqlAliases);
         const nextNs = new Set(scope.namespaces);
+        const nextFactories = new Set(scope.clientFactories);
+        const nextClients = new Set(scope.clients);
         for (const binding of bindings) {
             for (const a of scope.sqlAliases) {
                 if (bindingDeclares(binding, a)) {
@@ -246,8 +260,44 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
                     changed = true;
                 }
             }
+            for (const a of scope.clientFactories) {
+                if (bindingDeclares(binding, a)) {
+                    nextFactories.delete(a);
+                    changed = true;
+                }
+            }
+            for (const a of scope.clients) {
+                if (bindingDeclares(binding, a)) {
+                    nextClients.delete(a);
+                    changed = true;
+                }
+            }
+        }
+        return changed
+            ? { sqlAliases: nextSql, namespaces: nextNs, clientFactories: nextFactories, clients: nextClients }
+            : scope;
+    };
+    const isClientFactoryCall = (initializer, scope) => {
+        if (!initializer || !ts.isCallExpression(initializer))
+            return false;
+        const callee = initializer.expression;
+        if (ts.isIdentifier(callee))
+            return scope.clientFactories.has(callee.text);
+        return ts.isPropertyAccessExpression(callee) &&
+            ts.isIdentifier(callee.expression) &&
+            scope.namespaces.has(callee.expression.text) &&
+            callee.name.text === "createSqlClient";
+    };
+    const scopeWithClientDeclarations = (scope, declarations) => {
+        const nextClients = new Set(scope.clients);
+        let changed = false;
+        for (const declaration of declarations) {
+            if (!ts.isIdentifier(declaration.name) || !isClientFactoryCall(declaration.initializer, scope))
+                continue;
+            nextClients.add(declaration.name.text);
+            changed = true;
         }
-        return changed ? { sqlAliases: nextSql, namespaces: nextNs } : scope;
+        return changed ? { ...scope, clients: nextClients } : scope;
     };
     const visit = (node, scope) => {
         if (ts.isCallExpression(node)) {
@@ -262,7 +312,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
                         if (param && ts.isIdentifier(param.name)) {
                             innerSql.add(param.name.text);
                         }
-                        visit(fn.body, { sqlAliases: innerSql, namespaces: shadowed.namespaces });
+                        visit(fn.body, { ...shadowed, sqlAliases: innerSql });
                         return;
                     }
                 }
@@ -283,7 +333,11 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
             const stmts = node.statements;
             for (const stmt of stmts) {
                 if (ts.isVariableStatement(stmt)) {
-                    current = scopeWithoutBindingShadows(current, stmt.declarationList.declarations.map((d) => d.name));
+                    const declarations = stmt.declarationList.declarations;
+                    current = scopeWithoutBindingShadows(current, declarations.map((d) => d.name));
+                    visit(stmt, current);
+                    current = scopeWithClientDeclarations(current, declarations);
+                    continue;
                 }
                 else if (ts.isFunctionDeclaration(stmt) && stmt.name) {
                     current = scopeWithoutBindingShadows(current, [stmt.name]);
@@ -320,9 +374,22 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
         }
         ts.forEachChild(node, (child) => visit(child, scope));
     };
-    visit(source, { sqlAliases: importedAliases, namespaces: importedNamespaces });
+    visit(source, {
+        sqlAliases: importedAliases,
+        namespaces: importedNamespaces,
+        clientFactories: importedClientFactories,
+        clients: new Set(),
+    });
     return out;
 }
+function scriptKind(path) {
+    switch (extname(path).toLowerCase()) {
+        case ".tsx": return ts.ScriptKind.TSX;
+        case ".mts":
+        case ".cts":
+        default: return ts.ScriptKind.TS;
+    }
+}
 export function scanProject(root, scan = {}) {
     const files = findSourceFiles(root, scan);
     const out = [];

package/package.json

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