@kequtech/tenon-orm 0.1.3 → 0.2.0

package/dist/inspection/options.js

@@ -0,0 +1,49 @@
+import { plainObject } from '../validation.js';
+/** Validate and capture caller-owned settings before opening a connection. */
+export function inspectionOptions(options) {
+    if (typeof options.connection !== 'string' || !options.connection.trim()) {
+        throw new Error('Describe requires an explicit nonempty connection string.');
+    }
+    plainObject(options.session ?? {}, 'Inspection session');
+    const session = { ...options.session };
+    for (const [key, value] of Object.entries(session)) {
+        if (!['role', 'searchPath', 'timeZone'].includes(key)) {
+            throw new Error(`Unknown inspection session option: ${key}`);
+        }
+        if (typeof value !== 'string' || !value.trim() || value.includes('\0')) {
+            throw new Error(`Inspection session ${key} requires a nonempty string without NUL.`);
+        }
+    }
+    plainObject(options.timeouts ?? {}, 'Inspection timeouts');
+    const timeouts = { ...options.timeouts };
+    const defaults = { connectMs: 3000, statementMs: 5000, lockMs: 1000 };
+    for (const [key, value] of Object.entries(timeouts)) {
+        if (!Object.hasOwn(defaults, key))
+            throw new Error(`Unknown inspection timeout: ${key}`);
+        if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 2147483647) {
+            throw new Error(`Inspection timeout ${key} must be a positive integer in milliseconds.`);
+        }
+    }
+    const limits = { ...defaults, ...timeouts };
+    // URL startup options must not disable the inspection's server-side bounds.
+    let url;
+    try {
+        url = new URL(options.connection);
+    }
+    catch {
+        throw new Error('Describe requires a PostgreSQL connection URI.');
+    }
+    if (!['postgres:', 'postgresql:'].includes(url.protocol)) {
+        throw new Error('Describe requires a PostgreSQL connection URI.');
+    }
+    for (const [name, value] of [
+        ['statement_timeout', limits.statementMs],
+        ['lock_timeout', limits.lockMs],
+    ]) {
+        url.searchParams.set(name, String(value));
+    }
+    if (!url.searchParams.has('application_name')) {
+        url.searchParams.set('application_name', 'tenon-describe');
+    }
+    return { url, limits, session };
+}

package/dist/inspection/result.d.ts

@@ -0,0 +1,4 @@
+import type { StatementMetadata } from './catalog.js';
+import type { InspectionContext, QueryDescription } from './types.js';
+/** Convert database metadata to conservative Postgres.js types and diagnostics. */
+export declare function queryDescription({ statement, types, sources }: StatementMetadata, context: InspectionContext): QueryDescription;

package/dist/inspection/result.js

@@ -0,0 +1,90 @@
+import { arrayTypes, scalarTypes, valueTypes } from '../driver/types.js';
+/** Convert database metadata to conservative Postgres.js types and diagnostics. */
+export function queryDescription({ statement, types, sources }, context) {
+    const catalog = new Map(types.map((t) => [t.oid, t]));
+    const issues = new Map();
+    function describeType(oid) {
+        const type = catalog.get(oid);
+        if (!type)
+            throw new Error(`PostgreSQL type OID ${oid} was not found.`);
+        let readType;
+        if (type.base) {
+            readType = describeType(type.base).readType;
+        }
+        else if (type.kind === 'e') {
+            readType = type.choices?.map((v) => JSON.stringify(v)).join(' | ') || 'never';
+        }
+        else if (Object.hasOwn(arrayTypes, String(oid))) {
+            readType = `PgArray<${valueTypes(arrayTypes[String(oid)]).read}>`;
+        }
+        else if (type.schema === 'pg_catalog' && Object.hasOwn(scalarTypes, type.name)) {
+            readType = valueTypes(scalarTypes[type.name]).read;
+        }
+        else {
+            readType = 'unknown';
+            issues.set(`type:${oid}`, {
+                code: 'unmapped-type',
+                oid,
+                postgres: `${type.schema}.${type.name}`,
+                message: `No verified Postgres.js mapping for ${type.schema}.${type.name} (OID ${oid}).`,
+            });
+        }
+        return { oid, postgres: `${type.schema}.${type.name}`, readType };
+    }
+    const sourceMap = new Map(sources.map((s) => [`${s.oid}:${s.number}`, s]));
+    const names = new Set();
+    const columns = statement.columns.map((column) => {
+        if (names.has(column.name)) {
+            issues.set(`column:${column.name}`, {
+                code: 'duplicate-column',
+                column: column.name,
+                message: `Duplicate result column ${JSON.stringify(column.name)}; object rows overwrite earlier values.`,
+            });
+        }
+        names.add(column.name);
+        const source = sourceMap.get(`${column.table}:${column.number}`);
+        return {
+            name: column.name,
+            ...describeType(column.type),
+            nullability: 'unknown',
+            source: source
+                ? {
+                    schema: source.schema,
+                    table: source.table,
+                    column: source.column,
+                    notNull: source.notNull,
+                }
+                : null,
+        };
+    });
+    const parameters = statement.types.map(describeType);
+    if (columns.length) {
+        issues.set('nullability', {
+            code: 'nullability-unknown',
+            message: 'Result nullability is not established by Describe.',
+        });
+    }
+    const unknown = columns
+        .filter((c) => c.readType === 'unknown' || c.readType === 'PgArray<unknown>')
+        .map((c) => c.name);
+    if (unknown.length) {
+        issues.set('shape', {
+            code: 'shape-unknown',
+            columns: unknown,
+            message: 'An unknown read type does not verify JSON structure or an application-specific result type.',
+        });
+    }
+    const members = columns.map((c) => `  ${JSON.stringify(c.name)}: ${c.readType}${c.readType === 'unknown' ? '' : ' | null'};`);
+    const array = columns.some((c) => c.readType.startsWith('PgArray<'))
+        ? 'type PgArray<T> = (T | null | PgArray<T>)[];\n'
+        : '';
+    return {
+        context,
+        parameters,
+        columns,
+        rowType: columns.length > 0 && names.size === columns.length
+            ? `${array}type DescribedRow = {\n${members.join('\n')}\n};`
+            : null,
+        issues: [...issues.values()],
+    };
+}

package/dist/inspection/types.d.ts

@@ -0,0 +1,74 @@
+import type { SqlQuery } from '../query.js';
+export interface InspectionSession {
+    readonly role?: string;
+    /** PostgreSQL's search_path setting, as used in the application's connection options. */
+    readonly searchPath?: string;
+    readonly timeZone?: string;
+}
+export interface InspectionTimeouts {
+    readonly connectMs?: number;
+    readonly statementMs?: number;
+    readonly lockMs?: number;
+}
+export interface InspectionContext {
+    readonly mode: 'separate-session';
+    readonly database: string;
+    readonly sessionUser: string;
+    readonly currentUser: string;
+    readonly searchPath: string;
+    readonly resolvedSearchPath: readonly string[];
+    readonly timeZone: string;
+    readonly statementTimeoutMs: number;
+    readonly lockTimeoutMs: number;
+    readonly readMappings: 'postgres';
+}
+export interface DescribeOptions {
+    /** PostgreSQL connection URI. Inspection owns a separate, short-lived connection. */
+    readonly connection: string;
+    /** Finished SQL; query values are neither bound nor executed. */
+    readonly query: string | Pick<SqlQuery, 'text'>;
+    readonly session?: InspectionSession;
+    readonly timeouts?: InspectionTimeouts;
+}
+export type DescriptionIssue = {
+    readonly code: 'nullability-unknown';
+    readonly message: string;
+} | {
+    readonly code: 'shape-unknown';
+    readonly message: string;
+    readonly columns: readonly string[];
+} | {
+    readonly code: 'unmapped-type';
+    readonly message: string;
+    readonly postgres: string;
+    readonly oid: number;
+} | {
+    readonly code: 'duplicate-column';
+    readonly message: string;
+    readonly column: string;
+};
+export interface DescribedType {
+    readonly oid: number;
+    readonly postgres: string;
+    /** Postgres.js read representation, before considering result nullability. */
+    readonly readType: string;
+}
+export interface DescribedColumn extends DescribedType {
+    readonly name: string;
+    readonly nullability: 'unknown';
+    /** Source constraint only: outer joins and grouping can still introduce NULL. */
+    readonly source: {
+        readonly schema: string;
+        readonly table: string;
+        readonly column: string;
+        readonly notNull: boolean;
+    } | null;
+}
+export interface QueryDescription {
+    readonly context: InspectionContext;
+    readonly parameters: readonly DescribedType[];
+    readonly columns: readonly DescribedColumn[];
+    /** Conservative result declaration. This does not verify an existing annotation. */
+    readonly rowType: string | null;
+    readonly issues: readonly DescriptionIssue[];
+}

package/dist/inspection/types.js

@@ -0,0 +1 @@
+export {};

package/dist/migrations/baseline-sql.d.ts

@@ -1,3 +1,3 @@
 export declare const baselineHeader = "-- Tenon baseline captured by pg_dump.\n";
-/** Bridge pg_dump's plain-text script to pg's transactional SQL execution. */
+/** Bridge pg_dump's plain-text script to transactional SQL execution. */
 export declare function prepareBaselineSql(dump: string, namespace: string): string;

package/dist/migrations/baseline-sql.js

@@ -1,6 +1,6 @@
 import { quote } from '../sql.js';
 export const baselineHeader = '-- Tenon baseline captured by pg_dump.\n';
-/** Bridge pg_dump's plain-text script to pg's transactional SQL execution. */
+/** Bridge pg_dump's plain-text script to transactional SQL execution. */
 export function prepareBaselineSql(dump, namespace) {
     // Recent pg_dump versions bracket psql scripts with a random restrict key.
     // Remove only the outer pair; SQL bodies containing similar text stay intact.

package/dist/migrations/connection.d.ts

@@ -1,9 +1,8 @@
-import type { PoolClient } from 'pg';
-import type { Connection } from '../connection.js';
+import type { Connection, SqlConnection } from '../connection.js';
 export interface DatabaseToolOptions {
     readonly connection: Connection;
     readonly namespace?: string;
     readonly directory?: string;
 }
 /** Coordinate tools independently of application sessions; PostgreSQL owns the wait. */
-export declare function withMigrationLock<T>(options: DatabaseToolOptions, mode: 'shared' | 'exclusive', work: (client: PoolClient, namespace: string) => Promise<T>): Promise<T>;
+export declare function withMigrationLock<T>(options: DatabaseToolOptions, mode: 'shared' | 'exclusive', work: (client: SqlConnection, namespace: string) => Promise<T>): Promise<T>;

package/dist/migrations/connection.js

@@ -1,21 +1,21 @@
-import { createPool, watchClient } from '../connection.js';
+import { reserveConnection } from '../driver/session.js';
+import { createConnection } from '../connection.js';
 import { validateName } from '../sql.js';
 /** Coordinate tools independently of application sessions; PostgreSQL owns the wait. */
 export async function withMigrationLock(options, mode, work) {
     const namespace = options.namespace ?? 'public';
     validateName(namespace);
-    const { pool, owned } = createPool(options.connection);
+    const { sql: pool, owned } = createConnection(options.connection);
     const suffix = mode === 'shared' ? '_shared' : '';
     const lockKey = `tenon:migrations:${namespace}`;
     const errors = [];
-    let client;
     let connection;
     let locked = false;
     let result;
     try {
-        client = await pool.connect();
-        connection = watchClient(client);
-        await client.query(`SELECT pg_advisory_lock${suffix}(hashtextextended($1, 0))`, [lockKey]);
+        connection = await reserveConnection(pool);
+        const client = connection.sql;
+        await client.unsafe(`SELECT pg_advisory_lock${suffix}(hashtextextended($1, 0))`, [lockKey]);
         locked = true;
         result = await work(client, namespace);
         connection.check();
@@ -24,23 +24,25 @@ export async function withMigrationLock(options, mode, work) {
         errors.push(error);
     }
     finally {
-        if (client) {
-            let releaseError;
+        if (connection) {
+            const client = connection.sql;
+            let discard = false;
             try {
-                await client.query('ROLLBACK');
+                connection.check();
+                if (errors.length)
+                    await client.unsafe('ROLLBACK');
                 if (locked) {
-                    await client.query(`SELECT pg_advisory_unlock${suffix}(hashtextextended($1, 0))`, [
+                    await client.unsafe(`SELECT pg_advisory_unlock${suffix}(hashtextextended($1, 0))`, [
                         lockKey,
                     ]);
                 }
             }
             catch (error) {
                 errors.push(error);
-                releaseError =
-                    error instanceof Error ? error : new Error('Tool connection cleanup failed.');
+                discard = true;
             }
             try {
-                connection.release(releaseError);
+                await connection.release(discard);
             }
             catch (error) {
                 errors.push(error);

package/dist/migrations/history.d.ts

@@ -1,4 +1,4 @@
-import type { PoolClient } from 'pg';
+import type { SqlConnection } from '../connection.js';
 import type { SqlMigration } from './files.js';
 export declare const migrationTable = "__tenon_migrations";
 interface AppliedMigration {
@@ -6,7 +6,7 @@ interface AppliedMigration {
     name: string;
     checksum: string;
 }
-export declare function migrationState(client: PoolClient, namespace: string, migrations: readonly SqlMigration[]): Promise<readonly AppliedMigration[]>;
-export declare function createHistoryTable(client: PoolClient, namespace: string): Promise<void>;
-export declare function recordMigration(client: PoolClient, namespace: string, migration: SqlMigration): Promise<void>;
+export declare function migrationState(client: SqlConnection, namespace: string, migrations: readonly SqlMigration[]): Promise<readonly AppliedMigration[]>;
+export declare function createHistoryTable(client: SqlConnection, namespace: string): Promise<void>;
+export declare function recordMigration(client: SqlConnection, namespace: string, migration: SqlMigration): Promise<void>;
 export {};

package/dist/migrations/history.js

@@ -1,11 +1,11 @@
 import { qualified } from '../sql.js';
 export const migrationTable = '__tenon_migrations';
 export async function migrationState(client, namespace, migrations) {
-    const exists = await client.query('SELECT to_regclass($1)::text AS name', [qualified(namespace, migrationTable)]);
-    if (exists.rows[0].name === null) {
+    const exists = await client.unsafe('SELECT to_regclass($1)::text AS name', [qualified(namespace, migrationTable)]);
+    if (exists[0].name === null) {
         return [];
     }
-    const { rows: applied } = await client.query(`SELECT id, name, checksum FROM ${qualified(namespace, migrationTable)} ORDER BY id::numeric`);
+    const applied = await client.unsafe(`SELECT id, name, checksum FROM ${qualified(namespace, migrationTable)} ORDER BY id::numeric`);
     for (const [i, record] of applied.entries()) {
         const file = migrations[i];
         if (!file ||
@@ -18,7 +18,7 @@ export async function migrationState(client, namespace, migrations) {
     return applied;
 }
 export async function createHistoryTable(client, namespace) {
-    await client.query(`CREATE TABLE IF NOT EXISTS ${qualified(namespace, migrationTable)} (
+    await client.unsafe(`CREATE TABLE IF NOT EXISTS ${qualified(namespace, migrationTable)} (
       id TEXT PRIMARY KEY CHECK (id ~ '^[0-9]+$'),
       name TEXT NOT NULL,
       checksum TEXT NOT NULL,
@@ -26,5 +26,5 @@ export async function createHistoryTable(client, namespace) {
     )`);
 }
 export async function recordMigration(client, namespace, migration) {
-    await client.query(`INSERT INTO ${qualified(namespace, migrationTable)} (id, name, checksum) VALUES ($1, $2, $3)`, [migration.id, migration.name, migration.checksum]);
+    await client.unsafe(`INSERT INTO ${qualified(namespace, migrationTable)} (id, name, checksum) VALUES ($1, $2, $3)`, [migration.id, migration.name, migration.checksum]);
 }

package/dist/migrations.js

@@ -28,25 +28,25 @@ async function execute(options, direction, steps) {
         if (!selected.length) {
             return [];
         }
-        await client.query(`CREATE SCHEMA IF NOT EXISTS ${quote(namespace)}`);
+        await client.unsafe(`CREATE SCHEMA IF NOT EXISTS ${quote(namespace)}`);
         await createHistoryTable(client, namespace);
         const completed = [];
         for (const file of selected) {
             try {
-                await client.query('BEGIN');
+                await client.unsafe('BEGIN');
                 // Match the string-literal rules used by the authored migration scanner.
-                await client.query('SET LOCAL standard_conforming_strings TO on');
-                await client.query(`SET LOCAL search_path TO ${quote(namespace)}, pg_catalog`);
-                await client.query(direction === 'up' ? file.up : file.down);
+                await client.unsafe('SET LOCAL standard_conforming_strings TO on');
+                await client.unsafe(`SET LOCAL search_path TO ${quote(namespace)}, pg_catalog`);
+                await client.unsafe(direction === 'up' ? file.up : file.down);
                 if (direction === 'up') {
                     await recordMigration(client, namespace, file);
                 }
                 else {
-                    await client.query(`DELETE FROM ${qualified(namespace, migrationTable)} WHERE id = $1`, [
+                    await client.unsafe(`DELETE FROM ${qualified(namespace, migrationTable)} WHERE id = $1`, [
                         file.id,
                     ]);
                 }
-                const result = await client.query('COMMIT');
+                const result = await client.unsafe('COMMIT');
                 if (result.command !== 'COMMIT') {
                     throw new Error('The migration transaction was rolled back.');
                 }

package/dist/mutations.d.ts

@@ -2,10 +2,5 @@ export type MutationPart = string | Readonly<{
     value: unknown;
 }>;
 export type MutationColumns<Input> = Input extends object ? Extract<keyof Input, string> : never;
-/** Validate and quote one explicit column list, shared by runtime and SQL checking. */
-export declare function mutationColumns(columns: readonly string[]): string[];
-/** SQL structure depends only on these columns and cells, never on JavaScript source. */
-export declare function insertLayout(columns: readonly string[], rows: readonly (readonly unknown[])[]): MutationPart[];
-export declare function assignmentLayout(columns: readonly string[], values: readonly unknown[]): MutationPart[];
 export declare function insertParts(input: object | readonly object[], selected?: readonly string[]): MutationPart[];
 export declare function assignmentParts(input: object, selected?: readonly string[]): MutationPart[];

package/dist/mutations.js

@@ -1,7 +1,7 @@
 import { quote } from './sql.js';
 import { plainObject } from './validation.js';
-/** Validate and quote one explicit column list, shared by runtime and SQL checking. */
-export function mutationColumns(columns) {
+/** Validate and quote one explicit column list for mutation fragments. */
+function mutationColumns(columns) {
     if (!Array.isArray(columns) || !columns.length)
         throw new Error('Mutation columns must be a nonempty array.');
     const seen = new Set();
@@ -15,43 +15,6 @@ export function mutationColumns(columns) {
         return column;
     });
 }
-/** SQL structure depends only on these columns and cells, never on JavaScript source. */
-export function insertLayout(columns, rows) {
-    if (!rows.length)
-        throw new Error('sql.insertValues requires at least one row.');
-    if (!columns.length) {
-        if (rows.length !== 1)
-            throw new Error('Default-only inserts require exactly one row.');
-        return ['DEFAULT VALUES'];
-    }
-    const parts = [`(${columns.map(quote).join(', ')}) VALUES `];
-    for (const [index, row] of rows.entries()) {
-        if (index)
-            parts.push(', ');
-        parts.push('(');
-        for (const [column, value] of row.entries()) {
-            if (column)
-                parts.push(', ');
-            parts.push(value === undefined ? 'DEFAULT' : Object.freeze({ value }));
-        }
-        parts.push(')');
-    }
-    return parts;
-}
-export function assignmentLayout(columns, values) {
-    const parts = [];
-    for (const [index, column] of columns.entries()) {
-        const value = values[index];
-        if (value === undefined)
-            continue;
-        if (parts.length)
-            parts.push(', ');
-        parts.push(`${quote(column)} = `, Object.freeze({ value }));
-    }
-    if (!parts.length)
-        throw new Error('sql.assignments requires at least one defined field.');
-    return parts;
-}
 function record(value, helper, index) {
     return plainObject(value, `${helper} row ${index + 1}`);
 }
@@ -78,10 +41,39 @@ export function insertParts(input, selected) {
             ...new Set(rows.flatMap((row, index) => Object.keys(row).filter((column) => cell(row, column, 'sql.insertValues', index) !== undefined))),
         ]
         : mutationColumns(selected);
-    return insertLayout(columns, rows.map((row, index) => columns.map((column) => cell(row, column, 'sql.insertValues', index))));
+    if (!columns.length) {
+        if (rows.length !== 1)
+            throw new Error('Default-only inserts require exactly one row.');
+        return ['DEFAULT VALUES'];
+    }
+    const parts = [`(${columns.map(quote).join(', ')}) VALUES `];
+    for (const [index, row] of rows.entries()) {
+        if (index)
+            parts.push(', ');
+        parts.push('(');
+        for (const [position, column] of columns.entries()) {
+            if (position)
+                parts.push(', ');
+            const value = cell(row, column, 'sql.insertValues', index);
+            parts.push(value === undefined ? 'DEFAULT' : Object.freeze({ value }));
+        }
+        parts.push(')');
+    }
+    return parts;
 }
 export function assignmentParts(input, selected) {
     const row = record(input, 'sql.assignments', 0);
     const columns = selected === undefined ? Object.keys(row) : mutationColumns(selected);
-    return assignmentLayout(columns, columns.map((column) => cell(row, column, 'sql.assignments', 0)));
+    const parts = [];
+    for (const column of columns) {
+        const value = cell(row, column, 'sql.assignments', 0);
+        if (value === undefined)
+            continue;
+        if (parts.length)
+            parts.push(', ');
+        parts.push(`${quote(column)} = `, Object.freeze({ value }));
+    }
+    if (!parts.length)
+        throw new Error('sql.assignments requires at least one defined field.');
+    return parts;
 }

package/dist/query-options.d.ts

@@ -1,4 +1,4 @@
-import type { QueryResult, QueryResultRow } from 'pg';
+import type { QueryResult } from './connection.js';
 import type { AffectedRowsConstraint } from './affected-rows.js';
 import type { UnknownRow } from './query.js';
 export type QueryReturnMode = 'native' | 'many' | 'oneOrNone' | 'one';
@@ -8,7 +8,7 @@ export interface QueryOptions {
     /** Optional diagnostic label. No SQL or input values are sent to observers. */
     readonly label?: string;
 }
-export type QueryOutput<Row extends QueryResultRow, Mode extends QueryReturnMode> = Mode extends 'native' ? QueryResult<Row> : Mode extends 'many' ? Row[] : Mode extends 'oneOrNone' ? Row | undefined : Row;
+export type QueryOutput<Row extends object, Mode extends QueryReturnMode> = Mode extends 'native' ? QueryResult<Row> : Mode extends 'many' ? Row[] : Mode extends 'oneOrNone' ? Row | undefined : Row;
 export declare function validateOptions(options?: QueryOptions): Readonly<QueryOptions & {
     returns: QueryReturnMode;
 }>;

package/dist/query-options.js

@@ -26,10 +26,10 @@ export function queryOutput(options, result) {
     if (options.returns === 'native')
         return result;
     if (options.returns === 'many')
-        return result.rows;
+        return [...result];
     const expected = options.returns === 'oneOrNone' ? 'at most one row' : 'exactly one row';
-    if (result.rows.length > 1 || (options.returns === 'one' && result.rows.length === 0)) {
-        throw new Error(`${options.label ?? 'Query'} expected ${expected}, but returned ${result.rows.length} rows.`);
+    if (result.length > 1 || (options.returns === 'one' && result.length === 0)) {
+        throw new Error(`${options.label ?? 'Query'} expected ${expected}, but returned ${result.length} rows.`);
     }
-    return result.rows[0];
+    return result[0];
 }

package/dist/query.d.ts

@@ -1,8 +1,7 @@
-import type { QueryResultRow } from 'pg';
 import { type MutationColumns } from './mutations.js';
 export type UnknownRow = Record<string, unknown>;
 /** A parameterized statement. The row type describes one returned record. */
-export interface SqlQuery<Row extends QueryResultRow = UnknownRow> {
+export interface SqlQuery<Row extends object = UnknownRow> {
     readonly text: string;
     readonly values: readonly unknown[];
     /** Type-only field; a stable key preserves row inference across package copies. */
@@ -24,7 +23,7 @@ declare function join(fragments: readonly SqlFragment[], separator: 'AND' | 'OR'
 declare function insertValues<Input extends object>(input: Input | readonly Input[], columns?: readonly NoInfer<MutationColumns<Input>>[]): SqlFragment;
 /** Omit undefined fields; null remains a value. Empty assignments reject. */
 declare function assignments<Input extends object>(input: Input, columns?: readonly NoInfer<MutationColumns<Input>>[]): SqlFragment;
-declare function createQuery<Row extends QueryResultRow = UnknownRow>(strings: TemplateStringsArray, ...values: readonly unknown[]): NoInfer<SqlQuery<Row>>;
+declare function createQuery<Row extends object = UnknownRow>(strings: TemplateStringsArray, ...values: readonly unknown[]): NoInfer<SqlQuery<Row>>;
 /** Values bind parameters; identifiers quote names; fragments compose authored SQL. */
 export declare const sql: typeof createQuery & {
     fragment: typeof fragment;
@@ -33,6 +32,6 @@ export declare const sql: typeof createQuery & {
     assignments: typeof assignments;
 };
 /** Escape hatch for externally authored SQL. Never concatenate application input into text. */
-export declare function unsafeSql<Row extends QueryResultRow = UnknownRow>(text: string, values: readonly unknown[]): NoInfer<SqlQuery<Row>>;
+export declare function unsafeSql<Row extends object = UnknownRow>(text: string, values: readonly unknown[]): NoInfer<SqlQuery<Row>>;
 export declare function assertQuery(value: unknown): asserts value is SqlQuery;
 export {};

package/dist/query.js

@@ -110,8 +110,8 @@ export function unsafeSql(text, values) {
         throw new Error('SQL must be a nonempty string.');
     if (!Array.isArray(values))
         throw new Error('SQL input must be an explicit array.');
-    if (values.length > 65535)
-        throw new Error(`A PostgreSQL query supports at most 65535 bound parameters; received ${values.length}. Split large batches explicitly.`);
+    if (values.length > 65533)
+        throw new Error(`Postgres.js 3.4.9 supports at most 65533 bound parameters; received ${values.length}. Split large batches explicitly.`);
     return Object.freeze({ [queryTag]: true, text, values: Object.freeze([...values]) });
 }
 export function assertQuery(value) {

package/dist/sql.d.ts

@@ -1,5 +1,5 @@
 export declare function validateName(value: string): void;
 export declare function quote(name: string): string;
 export declare function qualified(namespace: string, table: string): string;
-/** Shared by query assembly and static checking so separators produce identical SQL. */
+/** Assemble query parts with a validated SQL separator. */
 export declare function joinSeparator(value: unknown): string;

package/dist/sql.js

@@ -13,7 +13,7 @@ export function quote(name) {
 export function qualified(namespace, table) {
     return `${quote(namespace)}.${quote(table)}`;
 }
-/** Shared by query assembly and static checking so separators produce identical SQL. */
+/** Assemble query parts with a validated SQL separator. */
 export function joinSeparator(value) {
     switch (value) {
         case 'AND':

package/dist/transaction-sql.js

@@ -1,4 +1,4 @@
-/** Read only the command prefix, leaving strings, bodies and SQL syntax to pg. */
+/** Read only the command prefix, leaving strings, bodies and SQL syntax to PostgreSQL. */
 function commandPrefix(sql) {
     const words = [];
     let i = 0;

package/dist/transaction.d.ts

@@ -1,4 +1,4 @@
-import type { Pool } from 'pg';
+import type postgres from 'postgres';
 import type { QueryExecutor } from './connection.js';
 /** The callback owns one connection and expires before commit or rollback begins. */
-export declare function withTransaction<T>(pool: Pool, work: (query: QueryExecutor) => Promise<T>): Promise<T>;
+export declare function withTransaction<T>(pool: postgres.Sql, work: (query: QueryExecutor) => Promise<T>): Promise<T>;