@onreza/sqlx-js 0.5.0 → 0.7.0

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

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 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";
+import { applyPending, acquireMigrateLock, releaseMigrateLock, DEFAULT_MIGRATE_LOCK_KEY } from "./migration-core.js";
 const PARAMETER_KIND = Symbol("sqlx-js.parameter");
 export function json(value) {
     return { [PARAMETER_KIND]: "json", value };
@@ -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.d.ts

@@ -15,5 +15,5 @@ export declare class ScanError extends Error {
     constructor(file: string, line: number, column: number, message: string);
 }
 export declare function findSourceFiles(root: string, scan?: ScanConfig): string[];
-export declare function scanFile(absPath: string, root: string): QueryCallSite[];
+export declare function scanFile(absPath: string, root: string, modules?: readonly string[]): QueryCallSite[];
 export declare function scanProject(root: string, scan?: ScanConfig): QueryCallSite[];

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;
@@ -21,7 +21,7 @@ const DEFAULT_EXCLUDES = [
     "**/build/**",
     "**/.next/**",
 ];
-const SQLX_MODULES = new Set(["@onreza/sqlx-js"]);
+const DEFAULT_SQLX_MODULES = ["@onreza/sqlx-js"];
 const EXT = /\.(ts|tsx|mts|cts)$/;
 const TS_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
 function formatConfigError(error) {
@@ -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")) {
@@ -131,18 +132,27 @@ function classifyCallee(callee, scope) {
     }
     return null;
 }
-export function scanFile(absPath, root) {
+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;
         const mod = stmt.moduleSpecifier;
         if (!ts.isStringLiteral(mod))
             continue;
-        if (!SQLX_MODULES.has(mod.text))
+        if (!modules.includes(mod.text))
             continue;
         const ic = stmt.importClause;
         if (!ic)
@@ -158,17 +168,19 @@ export function scanFile(absPath, root) {
                 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) {
         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) {
                     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) {
                         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) {
             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,14 +374,27 @@ export function scanFile(absPath, root) {
         }
         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 = [];
     for (const f of files) {
-        for (const site of scanFile(f, root))
+        for (const site of scanFile(f, root, scan.modules ?? DEFAULT_SQLX_MODULES))
             out.push(site);
     }
     return out;

package/dist/src/type-inspection.d.ts

@@ -0,0 +1 @@
+export declare function containsUnknownType(type: string): boolean;

package/dist/src/type-inspection.js

@@ -0,0 +1,20 @@
+import ts from "typescript";
+const unknownTypeCache = new Map();
+export function containsUnknownType(type) {
+    const cached = unknownTypeCache.get(type);
+    if (cached !== undefined)
+        return cached;
+    const source = ts.createSourceFile("sqlx-js-type.ts", `type SqlxJsType = ${type};`, ts.ScriptTarget.Latest, true);
+    let found = false;
+    const visit = (node) => {
+        if (node.kind === ts.SyntaxKind.UnknownKeyword) {
+            found = true;
+            return;
+        }
+        if (!found)
+            ts.forEachChild(node, visit);
+    };
+    visit(source);
+    unknownTypeCache.set(type, found);
+    return found;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onreza/sqlx-js",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Compile-time-checked raw SQL for TypeScript + PostgreSQL. Inspired by sqlx.",
   "license": "MIT",
   "type": "module",
@@ -19,7 +19,8 @@
     }
   },
   "bin": {
-    "sqlx-js": "dist/bin/sqlx-js.js"
+    "sqlx-js": "dist/bin/sqlx-js.js",
+    "sqlx-js-diagnostics": "dist/bin/sqlx-js-diagnostics.js"
   },
   "files": [
     "dist",
@@ -54,6 +55,9 @@
     "test": "bun test tests --timeout 120000",
     "test:typecheck": "tsc --noEmit",
     "test:example": "bunx tsc -p example --noEmit",
+    "test:runtime-boundary": "bun run build && node scripts/check-runtime-boundary.mjs",
+    "test:node-package": "node scripts/node-package-smoke.mjs",
+    "test:corpus": "bun scripts/check-production-corpus.ts",
     "sqlx:prepare": "bun bin/sqlx-js.ts prepare",
     "sqlx:migrate": "bun bin/sqlx-js.ts migrate",
     "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json && bun scripts/fix-dist-imports.ts",