@onreza/sqlx-js 0.7.0 → 0.9.0

package/dist/src/runtime.js

@@ -2,6 +2,9 @@ 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 "./migration-core.js";
+import { bindNamedParameters, rewriteNamedParameters } from "./sql-params.js";
+import { queryId } from "./query-id.js";
+import { QUERY_EXECUTOR, } from "./query.js";
 const PARAMETER_KIND = Symbol("sqlx-js.parameter");
 export function json(value) {
     return { [PARAMETER_KIND]: "json", value };
@@ -175,7 +178,7 @@ export class TooManyRowsError extends Error {
 }
 // SQLSTATE is exactly five characters from [0-9A-Z]; lowercase or other shapes
 // are never valid, so transport codes like "EPIPE" must not match on shape alone.
-const SQLSTATE = /^[0-9A-Z]{5}$/;
+const SQLSTATE_PATTERN = /^[0-9A-Z]{5}$/;
 function firstString(...candidates) {
     for (const value of candidates) {
         if (typeof value === "string" && value.length > 0)
@@ -199,7 +202,7 @@ export function toPgError(e) {
     // and system errors (EPIPE, ECONNREFUSED, CONNECTION_ENDED) carry neither, so
     // they pass through untouched instead of masquerading as a PgError.
     const isDatabaseError = o.name === "PostgresError" ||
-        (code !== undefined && SQLSTATE.test(code) && severity !== undefined);
+        (code !== undefined && SQLSTATE_PATTERN.test(code) && severity !== undefined);
     if (!isDatabaseError)
         return null;
     const fields = {};
@@ -230,6 +233,17 @@ export function toPgError(e) {
         fields.s = schema;
     return new PgError(fields, { cause: e });
 }
+export const SQLSTATE = {
+    notNullViolation: "23502",
+    foreignKeyViolation: "23503",
+    uniqueViolation: "23505",
+    checkViolation: "23514",
+    serializationFailure: "40001",
+    deadlockDetected: "40P01",
+};
+export function isPgError(error, code) {
+    return error instanceof PgError && (code === undefined || error.code === code);
+}
 export const _internal = {
     renameRows,
     encodeParam,
@@ -241,7 +255,26 @@ export const _internal = {
     parameterKind,
     toPgError,
 };
-async function runRawQuery(client, query, params) {
+const runtimeQueryIds = new Map();
+const MAX_RUNTIME_QUERY_IDS = 1024;
+function observedMetadata(query, metadata) {
+    if (metadata)
+        return metadata;
+    let id = runtimeQueryIds.get(query);
+    if (!id) {
+        id = queryId(query);
+        if (runtimeQueryIds.size >= MAX_RUNTIME_QUERY_IDS)
+            runtimeQueryIds.clear();
+        runtimeQueryIds.set(query, id);
+    }
+    return { queryId: id };
+}
+async function runRawQuery(client, query, params, metadata) {
+    const observedQuery = query;
+    const observedParams = params;
+    const bound = bindNamedParameters(rewriteNamedParameters(query), params);
+    query = bound.query;
+    params = bound.params;
     const encoded = params.length === 0
         ? params
         : params.map((p) => client.transformParam ? client.transformParam(p) : encodeParam(p));
@@ -254,12 +287,14 @@ async function runRawQuery(client, query, params) {
             throw toPgError(e) ?? e;
         }
     }
+    const observed = observedMetadata(observedQuery, metadata);
     const start = performance.now();
     try {
         const result = await client.query(query, encoded);
         notifyQuery(client, {
-            query,
-            params,
+            ...observed,
+            query: observedQuery,
+            params: observedParams,
             durationMs: performance.now() - start,
             rowCount: result.count ?? result.length,
         });
@@ -267,7 +302,7 @@ async function runRawQuery(client, query, params) {
     }
     catch (e) {
         const error = toPgError(e) ?? e;
-        notifyQuery(client, { query, params, durationMs: performance.now() - start, error });
+        notifyQuery(client, { ...observed, query: observedQuery, params: observedParams, durationMs: performance.now() - start, error });
         throw error;
     }
 }
@@ -290,26 +325,26 @@ function notifyQueryHookError(client, error, event) {
     catch {
     }
 }
-async function runQuery(client, query, params) {
-    return renameRows(await runRawQuery(client, query, params));
+async function runQuery(client, query, params, metadata) {
+    return renameRows(await runRawQuery(client, query, params, metadata));
 }
-async function runExecute(client, query, params) {
-    const result = await runRawQuery(client, query, params);
+async function runExecute(client, query, params, metadata) {
+    const result = await runRawQuery(client, query, params, metadata);
     return {
         rowCount: result.count ?? result.length,
         command: result.command ?? "",
     };
 }
-async function runOne(client, query, params) {
-    const rows = await runQuery(client, query, params);
+async function runOne(client, query, params, metadata) {
+    const rows = await runQuery(client, query, params, metadata);
     if (rows.length === 1)
         return rows[0];
     if (rows.length === 0)
         throw new NoRowsError();
     throw new TooManyRowsError(rows.length, "1");
 }
-async function runOptional(client, query, params) {
-    const rows = await runQuery(client, query, params);
+async function runOptional(client, query, params, metadata) {
+    const rows = await runQuery(client, query, params, metadata);
     if (rows.length === 0)
         return null;
     if (rows.length === 1)
@@ -317,7 +352,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(), reload = false) {
+function loadSqlFile(path, fileRoot = process.env.SQLX_JS_FILE_ROOT ?? process.cwd(), reload = false, embedded) {
     const root = resolve(fileRoot);
     if (isAbsolute(path)) {
         throw new Error(`sqlx-js.sql.file: path must be relative to fileRoot: ${path}`);
@@ -327,6 +362,8 @@ function loadSqlFile(path, fileRoot = process.env.SQLX_JS_FILE_ROOT ?? process.c
     if (rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rel)) {
         throw new Error(`sqlx-js.sql.file: path escapes fileRoot: ${path}`);
     }
+    if (embedded && Object.hasOwn(embedded, path))
+        return embedded[path];
     try {
         const cached = sqlFileCache.get(full);
         if (cached && !reload)
@@ -458,21 +495,30 @@ export function id(...parts) {
     }
     return parts.map(quoteIdentifier).join(".");
 }
+function executeDefinedQuery(client, mode, query, params, metadata) {
+    if (mode === "one")
+        return runOne(client, query, params, metadata);
+    if (mode === "optional")
+        return runOptional(client, query, params, metadata);
+    if (mode === "execute")
+        return runExecute(client, query, params, metadata);
+    return runQuery(client, query, params, metadata);
+}
 function makeBoundCallable(client) {
     const fn = (async (query, ...params) => {
         return runQuery(client, query, params);
     });
     const file = (async (path, ...params) => {
-        return runQuery(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
+        return runQuery(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles, client.sqlFiles), params);
     });
     file.one = (async (path, ...params) => {
-        return runOne(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
+        return runOne(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles, client.sqlFiles), params);
     });
     file.optional = (async (path, ...params) => {
-        return runOptional(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
+        return runOptional(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles, client.sqlFiles), params);
     });
     file.execute = (async (path, ...params) => {
-        return runExecute(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
+        return runExecute(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles, client.sqlFiles), params);
     });
     fn.file = file;
     fn.one = (async (query, ...params) => {
@@ -487,6 +533,9 @@ function makeBoundCallable(client) {
     fn.id = id;
     fn.json = json;
     fn.array = array;
+    fn[QUERY_EXECUTOR] = (mode, query, params, metadata) => {
+        return executeDefinedQuery(client, mode, query, params, metadata);
+    };
     return fn;
 }
 function buildSetTransaction(opts) {
@@ -507,19 +556,19 @@ export function createSqlRuntime(getClient) {
     });
     const rootFile = (async (path, ...params) => {
         const client = getClient();
-        return runQuery(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
+        return runQuery(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles, client.sqlFiles), params);
     });
     rootFile.one = (async (path, ...params) => {
         const client = getClient();
-        return runOne(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
+        return runOne(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles, client.sqlFiles), params);
     });
     rootFile.optional = (async (path, ...params) => {
         const client = getClient();
-        return runOptional(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
+        return runOptional(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles, client.sqlFiles), params);
     });
     rootFile.execute = (async (path, ...params) => {
         const client = getClient();
-        return runExecute(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles), params);
+        return runExecute(client, loadSqlFile(path, client.fileRoot, client.reloadSqlFiles, client.sqlFiles), params);
     });
     root.file = rootFile;
     root.one = (async (query, ...params) => {
@@ -534,6 +583,9 @@ export function createSqlRuntime(getClient) {
     root.id = id;
     root.json = json;
     root.array = array;
+    root[QUERY_EXECUTOR] = (mode, query, params, metadata) => {
+        return executeDefinedQuery(getClient(), mode, query, params, metadata);
+    };
     root.transaction = (async (fnOrOpts, maybeFn) => {
         const c = getClient();
         let opts = {};

package/dist/src/scan/scanner.d.ts

@@ -6,6 +6,8 @@ export type QueryCallSite = {
     query: string;
     paramCount: number;
     kind: "inline" | "file";
+    cardinality?: "many" | "one" | "optional" | "execute";
+    queryName?: string;
     sqlFilePath?: string;
 };
 export declare class ScanError extends Error {

package/dist/src/scan/scanner.js

@@ -1,6 +1,7 @@
 import ts from "typescript";
 import { existsSync, readFileSync } from "node:fs";
 import { extname, isAbsolute, join, relative, resolve } from "node:path";
+import { rewriteNamedParameters } from "../sql-params.js";
 export class ScanError extends Error {
     file;
     line;
@@ -67,7 +68,7 @@ function classifyCallee(callee, scope) {
     if (ts.isIdentifier(callee)) {
         if (!scope.sqlAliases.has(callee.text))
             return null;
-        return { kind: "inline" };
+        return { kind: "inline", cardinality: "many" };
     }
     if (!ts.isPropertyAccessExpression(callee))
         return null;
@@ -78,7 +79,7 @@ function classifyCallee(callee, scope) {
         const id = callee.expression.text;
         if (scope.namespaces.has(id) || scope.clients.has(id)) {
             if (methodName === "sql")
-                return { kind: "inline" };
+                return { kind: "inline", cardinality: "many" };
             return null;
         }
         if (!scope.sqlAliases.has(id))
@@ -86,9 +87,10 @@ function classifyCallee(callee, scope) {
         if (methodName === "transaction")
             return { kind: "transaction" };
         if (methodName === "file")
-            return { kind: "file" };
-        if (methodName === "one" || methodName === "optional" || methodName === "execute")
-            return { kind: "inline" };
+            return { kind: "file", cardinality: "many" };
+        if (methodName === "one" || methodName === "optional" || methodName === "execute") {
+            return { kind: "inline", cardinality: methodName };
+        }
         return null;
     }
     if (ts.isPropertyAccessExpression(callee.expression)) {
@@ -100,10 +102,11 @@ function classifyCallee(callee, scope) {
             (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")
-                return { kind: "inline" };
+            if (methodName === "one" || methodName === "optional" || methodName === "execute") {
+                return { kind: "inline", cardinality: methodName };
+            }
             if (methodName === "file")
-                return { kind: "file" };
+                return { kind: "file", cardinality: "many" };
             if (methodName === "transaction")
                 return { kind: "transaction" };
             return null;
@@ -115,8 +118,9 @@ function classifyCallee(callee, scope) {
                 return null;
             if (mid.name.text !== "file")
                 return null;
-            if (methodName === "one" || methodName === "optional" || methodName === "execute")
-                return { kind: "file" };
+            if (methodName === "one" || methodName === "optional" || methodName === "execute") {
+                return { kind: "file", cardinality: methodName };
+            }
             return null;
         }
         // ns.sql.file.X(...) and client.sql.file.X(...) chains
@@ -127,11 +131,32 @@ function classifyCallee(callee, scope) {
             mid.expression.name.text === "sql" &&
             mid.name.text === "file" &&
             (methodName === "one" || methodName === "optional" || methodName === "execute")) {
-            return { kind: "file" };
+            return { kind: "file", cardinality: methodName };
         }
     }
     return null;
 }
+function classifyDefinitionCallee(callee, scope) {
+    if (ts.isIdentifier(callee))
+        return scope.queryFactories.has(callee.text) ? "many" : null;
+    if (!ts.isPropertyAccessExpression(callee) || !ts.isIdentifier(callee.name))
+        return null;
+    const method = callee.name.text;
+    if (ts.isIdentifier(callee.expression) && scope.queryFactories.has(callee.expression.text)) {
+        return method === "one" || method === "optional" || method === "execute" ? method : null;
+    }
+    if (method === "defineQuery" &&
+        ts.isIdentifier(callee.expression) &&
+        scope.namespaces.has(callee.expression.text))
+        return "many";
+    if ((method === "one" || method === "optional" || method === "execute") &&
+        ts.isPropertyAccessExpression(callee.expression) &&
+        ts.isIdentifier(callee.expression.expression) &&
+        scope.namespaces.has(callee.expression.expression.text) &&
+        callee.expression.name.text === "defineQuery")
+        return method;
+    return null;
+}
 export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
     const text = readFileSync(absPath, "utf8");
     const source = ts.createSourceFile(absPath, text, ts.ScriptTarget.ESNext, false, scriptKind(absPath));
@@ -146,6 +171,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
     const importedAliases = new Set();
     const importedNamespaces = new Set();
     const importedClientFactories = new Set();
+    const importedQueryFactories = new Set();
     for (const stmt of source.statements) {
         if (!ts.isImportDeclaration(stmt))
             continue;
@@ -170,10 +196,15 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
                     importedAliases.add(elem.name.text);
                 if (orig === "createSqlClient")
                     importedClientFactories.add(elem.name.text);
+                if (orig === "defineQuery")
+                    importedQueryFactories.add(elem.name.text);
             }
         }
     }
-    if (importedAliases.size === 0 && importedNamespaces.size === 0 && importedClientFactories.size === 0)
+    if (importedAliases.size === 0 &&
+        importedNamespaces.size === 0 &&
+        importedClientFactories.size === 0 &&
+        importedQueryFactories.size === 0)
         return [];
     const out = [];
     const here = (node) => {
@@ -181,12 +212,22 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
         return { line: line + 1, column: character + 1 };
     };
     const fileRel = relative(root, absPath).replace(/\\/g, "/");
-    const recordInline = (first, args) => {
+    const recordInline = (first, args, cardinality) => {
         if (!ts.isStringLiteralLike(first)) {
             const pos = here(first);
             throw new ScanError(fileRel, pos.line, pos.column, "sql() requires a string literal as first argument");
         }
         const pos = here(first);
+        let named;
+        try {
+            named = rewriteNamedParameters(first.text).names;
+        }
+        catch (error) {
+            throw new ScanError(fileRel, pos.line, pos.column, error.message.replace(/^sqlx-js: /, ""));
+        }
+        if (named.length > 0 && args.length !== 2) {
+            throw new ScanError(fileRel, pos.line, pos.column, "a query with named parameters requires exactly one parameter object");
+        }
         out.push({
             file: fileRel,
             line: pos.line,
@@ -194,10 +235,46 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
             query: first.text,
             paramCount: args.length - 1,
             kind: "inline",
+            cardinality,
+        });
+        return true;
+    };
+    const recordDefinition = (args, callee, cardinality) => {
+        if (args.length < 1 || args.length > 2) {
+            const pos = here(callee);
+            throw new ScanError(fileRel, pos.line, pos.column, "defineQuery() requires a SQL literal and optional name");
+        }
+        const queryNode = args.length === 2 ? args[1] : args[0];
+        const nameNode = args.length === 2 ? args[0] : undefined;
+        if (!ts.isStringLiteralLike(queryNode) || (nameNode && !ts.isStringLiteralLike(nameNode))) {
+            const pos = here(queryNode);
+            throw new ScanError(fileRel, pos.line, pos.column, "defineQuery() requires string literals for its name and SQL");
+        }
+        if (nameNode && nameNode.text.trim() === "") {
+            const pos = here(nameNode);
+            throw new ScanError(fileRel, pos.line, pos.column, "defineQuery() name must not be empty");
+        }
+        const pos = here(queryNode);
+        let paramNames;
+        try {
+            paramNames = rewriteNamedParameters(queryNode.text).names;
+        }
+        catch (error) {
+            throw new ScanError(fileRel, pos.line, pos.column, error.message.replace(/^sqlx-js: /, ""));
+        }
+        out.push({
+            file: fileRel,
+            line: pos.line,
+            column: pos.column,
+            query: queryNode.text,
+            paramCount: paramNames.length,
+            kind: "inline",
+            cardinality,
+            ...(nameNode ? { queryName: nameNode.text } : {}),
         });
         return true;
     };
-    const recordFile = (first, args, callee) => {
+    const recordFile = (first, args, callee, cardinality) => {
         if (!ts.isStringLiteralLike(first)) {
             const pos = first ? here(first) : here(callee);
             throw new ScanError(fileRel, pos.line, pos.column, "sql.file() requires a string literal path");
@@ -219,6 +296,16 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
         }
         const query = readFileSync(abs, "utf8");
         const pos = here(first);
+        let named;
+        try {
+            named = rewriteNamedParameters(query).names;
+        }
+        catch (error) {
+            throw new ScanError(fileRel, pos.line, pos.column, error.message.replace(/^sqlx-js: /, ""));
+        }
+        if (named.length > 0 && args.length !== 2) {
+            throw new ScanError(fileRel, pos.line, pos.column, "a SQL file with named parameters requires exactly one parameter object");
+        }
         out.push({
             file: fileRel,
             line: pos.line,
@@ -226,6 +313,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
             query,
             paramCount: args.length - 1,
             kind: "file",
+            cardinality,
             sqlFilePath: sqlPath,
         });
         return true;
@@ -246,6 +334,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
         const nextSql = new Set(scope.sqlAliases);
         const nextNs = new Set(scope.namespaces);
         const nextFactories = new Set(scope.clientFactories);
+        const nextQueryFactories = new Set(scope.queryFactories);
         const nextClients = new Set(scope.clients);
         for (const binding of bindings) {
             for (const a of scope.sqlAliases) {
@@ -266,6 +355,12 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
                     changed = true;
                 }
             }
+            for (const a of scope.queryFactories) {
+                if (bindingDeclares(binding, a)) {
+                    nextQueryFactories.delete(a);
+                    changed = true;
+                }
+            }
             for (const a of scope.clients) {
                 if (bindingDeclares(binding, a)) {
                     nextClients.delete(a);
@@ -274,7 +369,13 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
             }
         }
         return changed
-            ? { sqlAliases: nextSql, namespaces: nextNs, clientFactories: nextFactories, clients: nextClients }
+            ? {
+                sqlAliases: nextSql,
+                namespaces: nextNs,
+                clientFactories: nextFactories,
+                queryFactories: nextQueryFactories,
+                clients: nextClients,
+            }
             : scope;
     };
     const isClientFactoryCall = (initializer, scope) => {
@@ -301,6 +402,10 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
     };
     const visit = (node, scope) => {
         if (ts.isCallExpression(node)) {
+            const definitionCardinality = classifyDefinitionCallee(node.expression, scope);
+            if (definitionCardinality) {
+                recordDefinition(node.arguments, node.expression, definitionCardinality);
+            }
             const classified = classifyCallee(node.expression, scope);
             if (classified) {
                 if (classified.kind === "transaction") {
@@ -319,12 +424,12 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
                 else if (classified.kind === "file") {
                     const first = node.arguments[0];
                     if (first)
-                        recordFile(first, node.arguments, node.expression);
+                        recordFile(first, node.arguments, node.expression, classified.cardinality ?? "many");
                 }
                 else if (classified.kind === "inline") {
                     const first = node.arguments[0];
                     if (first)
-                        recordInline(first, node.arguments);
+                        recordInline(first, node.arguments, classified.cardinality ?? "many");
                 }
             }
         }
@@ -378,6 +483,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
         sqlAliases: importedAliases,
         namespaces: importedNamespaces,
         clientFactories: importedClientFactories,
+        queryFactories: importedQueryFactories,
         clients: new Set(),
     });
     return out;

package/dist/src/sql-lex.d.ts

@@ -0,0 +1,7 @@
+export declare function isIdentifierContinuation(value: string): boolean;
+export declare function isEscapeStringPrefix(query: string, quote: number): boolean;
+export declare function readSingleQuoted(query: string, start: number, escapeBackslash: boolean): number;
+export declare function readQuotedIdentifier(query: string, start: number): number;
+export declare function readDollarQuoted(query: string, start: number): number | null;
+export declare function readLineComment(query: string, start: number): number;
+export declare function readBlockComment(query: string, start: number): number;

package/dist/src/sql-lex.js

@@ -0,0 +1,76 @@
+export function isIdentifierContinuation(value) {
+    return /[A-Za-z0-9_$\u0080-\uFFFF]/.test(value);
+}
+export function isEscapeStringPrefix(query, quote) {
+    const prefix = query[quote - 1];
+    if (prefix !== "e" && prefix !== "E")
+        return false;
+    const before = query[quote - 2];
+    return before === undefined || !isIdentifierContinuation(before);
+}
+export function readSingleQuoted(query, start, escapeBackslash) {
+    let i = start + 1;
+    while (i < query.length) {
+        if (escapeBackslash && query[i] === "\\") {
+            i += 2;
+            continue;
+        }
+        if (query[i] === "'") {
+            if (query[i + 1] === "'") {
+                i += 2;
+                continue;
+            }
+            return i + 1;
+        }
+        i++;
+    }
+    return query.length;
+}
+export function readQuotedIdentifier(query, start) {
+    let i = start + 1;
+    while (i < query.length) {
+        if (query[i] === '"') {
+            if (query[i + 1] === '"') {
+                i += 2;
+                continue;
+            }
+            return i + 1;
+        }
+        i++;
+    }
+    return query.length;
+}
+export function readDollarQuoted(query, start) {
+    let end = start + 1;
+    if (query[end] !== "$" && !/[A-Za-z_\u0080-\uFFFF]/.test(query[end]))
+        return null;
+    while (end < query.length && /[A-Za-z0-9_\u0080-\uFFFF]/.test(query[end]))
+        end++;
+    if (query[end] !== "$")
+        return null;
+    const tag = query.slice(start, end + 1);
+    const close = query.indexOf(tag, end + 1);
+    return close === -1 ? query.length : close + tag.length;
+}
+export function readLineComment(query, start) {
+    const end = query.indexOf("\n", start + 2);
+    return end === -1 ? query.length : end + 1;
+}
+export function readBlockComment(query, start) {
+    let depth = 1;
+    let i = start + 2;
+    while (i < query.length && depth > 0) {
+        if (query[i] === "/" && query[i + 1] === "*") {
+            depth++;
+            i += 2;
+            continue;
+        }
+        if (query[i] === "*" && query[i + 1] === "/") {
+            depth--;
+            i += 2;
+            continue;
+        }
+        i++;
+    }
+    return i;
+}

package/dist/src/sql-params.d.ts

@@ -0,0 +1,11 @@
+export type RewrittenSql = {
+    query: string;
+    names: string[];
+    positionMap: number[];
+};
+export declare function rewriteNamedParameters(query: string): RewrittenSql;
+export declare function bindNamedParameters(rewritten: RewrittenSql, args: readonly unknown[]): {
+    query: string;
+    params: unknown[];
+};
+export declare function originalPosition(rewritten: RewrittenSql, oneBasedPosition: number): number;