@kequtech/tenon-orm 0.2.1 → 0.3.0

package/dist/generate.js

@@ -7,17 +7,17 @@ import { quote } from './sql.js';
 export async function generateDefinitions(options) {
     const onWarning = options.onWarning ?? ((message) => console.warn(`Warning: ${message}`));
     return withMigrationLock(options, 'shared', async (client, namespace) => {
-        await client.unsafe('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY');
-        const schema = await client.unsafe('SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = $1', [
+        await client.query('BEGIN ISOLATION LEVEL REPEATABLE READ READ ONLY');
+        const schema = await client.query('SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = $1', [
             namespace,
         ]);
-        if (!schema.length)
+        if (!schema.rows.length)
             throw new Error(`Schema ${quote(namespace)} does not exist.`);
         // Keep catalog deparsing stable across connection settings and replay schemas.
         // Transaction-local settings are restored before returning a borrowed client.
-        await client.unsafe(`SET LOCAL search_path TO pg_catalog, ${quote(namespace)}`);
-        await client.unsafe('SET LOCAL quote_all_identifiers TO off');
-        await client.unsafe('SET LOCAL standard_conforming_strings TO on');
+        await client.query(`SET LOCAL search_path TO pg_catalog, ${quote(namespace)}`);
+        await client.query('SET LOCAL quote_all_identifiers TO off');
+        await client.query('SET LOCAL standard_conforming_strings TO on');
         const definitions = await readTables(client, namespace);
         const summaries = [];
         for (const table of definitions) {
@@ -25,7 +25,7 @@ export async function generateDefinitions(options) {
         }
         const domains = await domainSummaries(client, definitions.flatMap((table) => table.columns.map((column) => column.declaredOid)));
         const types = renderTableTypes(definitions, namespace, onWarning);
-        await client.unsafe('COMMIT');
+        await client.query('COMMIT');
         return `// Generated by Tenon from the PostgreSQL schema. Do not edit.
 // Commit this file and regenerate it after changing the schema.
 

package/dist/generation/catalog.d.ts

@@ -1,4 +1,4 @@
-import type { SqlConnection } from '../connection.js';
+import type { PoolClient } from 'pg';
 export interface ColumnRow {
     name: string;
     oid: string;
@@ -19,4 +19,4 @@ export interface TableRow {
     name: string;
     columns: ColumnRow[];
 }
-export declare function readTables(client: SqlConnection, namespace: string): Promise<TableRow[]>;
+export declare function readTables(client: PoolClient, namespace: string): Promise<TableRow[]>;

package/dist/generation/catalog.js

@@ -1,15 +1,15 @@
 import { migrationTable } from '../migrations/history.js';
 export async function readTables(client, namespace) {
-    const tables = await client.unsafe(`
+    const tables = await client.query(`
       SELECT c.oid::text AS oid, c.relname AS name
       FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
       WHERE n.nspname = $1 AND c.relname <> $2 AND c.relkind IN ('r', 'p')
         AND NOT c.relispartition
       ORDER BY c.relname COLLATE "C"`, [namespace, migrationTable]);
     const definitions = [];
-    for (const table of tables) {
+    for (const table of tables.rows) {
         // Attached descendants are storage details, not separate generated models.
-        const columns = await client.unsafe(`
+        const columns = await client.query(`
         WITH RECURSIVE resolved AS (
           SELECT a.attnum, t.oid, t.typbasetype, t.typnotnull AS domain_not_null
           FROM pg_catalog.pg_attribute a JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
@@ -32,7 +32,7 @@ export async function readTables(client, namespace) {
           JOIN pg_catalog.pg_type declared ON declared.oid = a.atttypid
           JOIN pg_catalog.pg_namespace dn ON dn.oid = declared.typnamespace
         WHERE a.attrelid = $1::oid AND a.attnum > 0 AND NOT a.attisdropped ORDER BY a.attnum`, [table.oid]);
-        definitions.push({ ...table, columns: columns });
+        definitions.push({ ...table, columns: columns.rows });
     }
     return definitions;
 }

package/dist/generation/schema-summary.d.ts

@@ -1,6 +1,6 @@
-import type { SqlConnection } from '../connection.js';
+import type { PoolClient } from 'pg';
 /** Include only domains reached through selected columns, base domains or arrays. */
-export declare function domainSummaries(client: SqlConnection, typeOids: readonly string[]): Promise<string[]>;
+export declare function domainSummaries(client: PoolClient, typeOids: readonly string[]): Promise<string[]>;
 /** Called inside generation's read-only snapshot, with a fixed local search_path. */
-export declare function tableSummary(client: SqlConnection, oid: string, name: string): Promise<string>;
+export declare function tableSummary(client: PoolClient, oid: string, name: string): Promise<string>;
 export declare function schemaSummary(summaries: readonly string[]): string;

package/dist/generation/schema-summary.js

@@ -1,7 +1,7 @@
 import { quote } from '../sql.js';
 /** Include only domains reached through selected columns, base domains or arrays. */
 export async function domainSummaries(client, typeOids) {
-    const domains = await client.unsafe(`
+    const domains = await client.query(`
     WITH RECURSIVE referenced(oid) AS (
       SELECT unnest($1::oid[])
       UNION
@@ -16,10 +16,10 @@ export async function domainSummaries(client, typeOids) {
     FROM referenced r JOIN pg_catalog.pg_type t ON t.oid = r.oid
       JOIN pg_catalog.pg_type base ON base.oid = t.typbasetype
     WHERE t.typtype = 'd'
-    ORDER BY pg_catalog.format_type(t.oid, NULL) COLLATE "C"`, [client.array([...typeOids])]);
+    ORDER BY pg_catalog.format_type(t.oid, NULL) COLLATE "C"`, [typeOids]);
     const summaries = [];
-    for (const domain of domains) {
-        const constraints = await client.unsafe(`
+    for (const domain of domains.rows) {
+        const constraints = await client.query(`
       SELECT conname AS name, pg_catalog.pg_get_constraintdef(oid, false) AS definition
       FROM pg_catalog.pg_constraint WHERE contypid = $1::oid
       ORDER BY conname COLLATE "C"`, [domain.oid]);
@@ -28,14 +28,14 @@ export async function domainSummaries(client, typeOids) {
                 (domain.collation === null ? '' : ` COLLATE ${domain.collation}`) +
                 (domain.expression === null ? '' : ` DEFAULT ${domain.expression}`) +
                 (domain.nullable ? '' : ' NOT NULL'),
-            ...constraints.map((constraint) => `  CONSTRAINT ${quote(constraint.name)} ${constraint.definition}`),
+            ...constraints.rows.map((constraint) => `  CONSTRAINT ${quote(constraint.name)} ${constraint.definition}`),
         ].join('\n'));
     }
     return summaries;
 }
 /** Called inside generation's read-only snapshot, with a fixed local search_path. */
 export async function tableSummary(client, oid, name) {
-    const columns = await client.unsafe(`
+    const columns = await client.query(`
     SELECT a.attname AS name,
       pg_catalog.format_type(a.atttypid, a.atttypmod)
       || CASE WHEN a.attnotnull THEN ' NOT NULL' ELSE '' END
@@ -63,12 +63,12 @@ export async function tableSummary(client, oid, name) {
     ORDER BY a.attnum`, [oid]);
     // Column definitions already describe NOT NULL; PostgreSQL 18 also stores it
     // as a table constraint, which would duplicate every required column here.
-    const constraints = await client.unsafe(`
+    const constraints = await client.query(`
     SELECT conname AS name, pg_catalog.pg_get_constraintdef(oid, false) AS definition
     FROM pg_catalog.pg_constraint
     WHERE conrelid = $1::oid AND conparentid = 0 AND contype IN ('p', 'u', 'f', 'c', 'x')
     ORDER BY conname COLLATE "C"`, [oid]);
-    const indexes = await client.unsafe(`
+    const indexes = await client.query(`
     SELECT pg_catalog.pg_get_indexdef(i.indexrelid, 0, false) AS definition,
       pg_catalog.format('CREATE %sINDEX %I ON %s',
         CASE WHEN i.indisunique THEN 'UNIQUE ' ELSE '' END, ic.relname,
@@ -83,9 +83,9 @@ export async function tableSummary(client, oid, name) {
     ORDER BY ic.relname COLLATE "C"`, [oid]);
     const lines = [
         `TABLE ${quote(name)}`,
-        ...columns.map((column) => `  ${quote(column.name)} ${column.definition}`),
-        ...constraints.map((constraint) => `  CONSTRAINT ${quote(constraint.name)} ${constraint.definition}`),
-        ...indexes.map((index) => {
+        ...columns.rows.map((column) => `  ${quote(column.name)} ${column.definition}`),
+        ...constraints.rows.map((constraint) => `  CONSTRAINT ${quote(constraint.name)} ${constraint.definition}`),
+        ...indexes.rows.map((index) => {
             // pg_get_indexdef always qualifies its target table. Remove only that
             // known prefix, never matching/replacing namespace text inside SQL literals.
             const qualifiedPrefix = index.prefix + index.qualification;

package/dist/generation/table-types.js

@@ -37,7 +37,7 @@ function columnTypes(value, column, onWarning) {
             const underlying = value.declaredOid === value.oid
                 ? ''
                 : ` with underlying type ${JSON.stringify(value.typeSchema)}.${JSON.stringify(value.type)} (OID ${value.oid})`;
-            onWarning(`Column ${column} uses PostgreSQL type ${JSON.stringify(value.declaredSchema)}.${JSON.stringify(value.declaredType)} (OID ${value.declaredOid})${underlying} without a verified Postgres.js mapping; generated as unknown for reads and never for non-null writes.`);
+            onWarning(`Column ${column} uses PostgreSQL type ${JSON.stringify(value.declaredSchema)}.${JSON.stringify(value.declaredType)} (OID ${value.declaredOid})${underlying} without a verified pg mapping; generated as unknown for reads and never for non-null writes.`);
             types = { read: 'unknown', write: 'never' };
         }
     }

package/dist/index.d.ts

@@ -1,13 +1,12 @@
-export type { JSONValue } from 'postgres';
 export type { Connection, ConnectionOptions, QueryResult } from './connection.js';
 export type { AffectedRowsConstraint } from './affected-rows.js';
 export { createTenon } from './database.js';
 export type { TenonOptions } from './database.js';
-export { AffectedRowsError } from './errors.js';
+export { AffectedRowsError, CardinalityError } from './errors.js';
 export type { QueryOptions, QueryOutput, QueryReturnMode } from './query-options.js';
 export { identifier, sql, unsafeSql } from './query.js';
 export type { SqlFragment, SqlQuery, UnknownRow } from './query.js';
-export type { Database, QueryClient, QueryEvent, Transaction } from './types.js';
+export type { CloseOptions, Database, QueryClient, QueryEvent, Transaction } from './types.js';
 export { describeQuery } from './describe.js';
 export type { DescribeOptions, DescribedColumn, DescribedType, DescriptionIssue, InspectionContext, InspectionSession, InspectionTimeouts, QueryDescription, } from './inspection/types.js';
 export { adoptBaseline, captureBaseline } from './baseline.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { createTenon } from './database.js';
-export { AffectedRowsError } from './errors.js';
+export { AffectedRowsError, CardinalityError } from './errors.js';
 export { identifier, sql, unsafeSql } from './query.js';
 export { describeQuery } from './describe.js';
 export { adoptBaseline, captureBaseline } from './baseline.js';

package/dist/inspection/catalog.d.ts

@@ -1,4 +1,5 @@
-import type postgres from 'postgres';
+import type { Client } from 'pg';
+import { type Description } from './protocol.js';
 interface CatalogType {
     oid: number;
     schema: string;
@@ -16,10 +17,10 @@ interface ColumnSource {
     notNull: boolean;
 }
 export interface StatementMetadata {
-    statement: postgres.Statement;
+    statement: Description;
     types: readonly CatalogType[];
     sources: readonly ColumnSource[];
 }
 /** Describe the statement and read its type and source-column catalog records. */
-export declare function readStatementMetadata(client: postgres.Sql, text: string): Promise<StatementMetadata>;
+export declare function readStatementMetadata(client: Client, text: string): Promise<StatementMetadata>;
 export {};

package/dist/inspection/catalog.js

@@ -1,29 +1,32 @@
+import { describe } from './protocol.js';
 /** Describe the statement and read its type and source-column catalog records. */
 export async function readStatementMetadata(client, text) {
-    const statement = await client.unsafe(text, [], { prepare: true }).describe();
-    const oids = [...new Set([...statement.types, ...statement.columns.map((c) => c.type)])];
-    const types = await client `
+    const statement = await describe(client, text);
+    const oids = [
+        ...new Set([...statement.parameters, ...statement.fields.map((c) => c.dataTypeID)]),
+    ];
+    const types = (await client.query(`
     WITH RECURSIVE wanted(oid) AS (
-      SELECT unnest(string_to_array(${oids.join(',')}, ',')::oid[])
+      SELECT pg_catalog.unnest(pg_catalog.string_to_array($1, ',')::pg_catalog.oid[])
       UNION
       SELECT t.typbasetype FROM pg_catalog.pg_type t JOIN wanted w ON w.oid = t.oid
         WHERE t.typbasetype <> 0
     )
     SELECT t.oid, n.nspname AS schema, t.typname AS name,
       t.typtype AS kind, t.typbasetype AS base,
-      (SELECT to_json(array_agg(e.enumlabel::text ORDER BY e.enumsortorder))
+      (SELECT pg_catalog.to_json(pg_catalog.array_agg(e.enumlabel::text ORDER BY e.enumsortorder))
         FROM pg_catalog.pg_enum e WHERE e.enumtypid = t.oid) AS choices
     FROM wanted w JOIN pg_catalog.pg_type t ON t.oid = w.oid
       JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-  `;
-    const tables = [...new Set(statement.columns.map((c) => c.table).filter(Boolean))];
-    const sources = await client `
+  `, [oids.join(',')])).rows;
+    const tables = [...new Set(statement.fields.map((c) => c.tableID).filter(Boolean))];
+    const sources = (await client.query(`
     SELECT c.oid, a.attnum AS number, n.nspname AS schema,
       c.relname AS table, a.attname AS column, a.attnotnull AS "notNull"
     FROM pg_catalog.pg_attribute a JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
       JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-    WHERE c.oid = ANY(string_to_array(${tables.join(',')}, ',')::oid[])
+    WHERE c.oid = ANY(pg_catalog.string_to_array($1, ',')::pg_catalog.oid[])
       AND a.attnum > 0 AND NOT a.attisdropped
-  `;
+  `, [tables.join(',')])).rows;
     return { statement, types, sources };
 }

package/dist/inspection/cli.js

@@ -14,9 +14,9 @@ export async function runDescribe(filename, connection, values) {
         connection,
         query: await readFile(filename, 'utf8'),
         session: {
-            ...(values.role !== undefined ? { role: values.role } : {}),
-            ...(values['search-path'] !== undefined ? { searchPath: values['search-path'] } : {}),
-            ...(values['time-zone'] !== undefined ? { timeZone: values['time-zone'] } : {}),
+            role: values.role,
+            searchPath: values['search-path'],
+            timeZone: values['time-zone'],
         },
         timeouts: {
             ...(values['connect-timeout-ms'] !== undefined

package/dist/inspection/connection.d.ts

@@ -1,4 +1,4 @@
-import postgres from 'postgres';
+import { Client } from 'pg';
 import type { DescribeOptions, InspectionContext } from './types.js';
 /** Bound every database statement, including bootstrap and metadata queries. */
-export declare function withInspectionConnection<T>(options: Pick<DescribeOptions, 'connection' | 'session' | 'timeouts'>, work: (client: postgres.Sql, context: InspectionContext) => Promise<T>): Promise<T>;
+export declare function withInspectionConnection<T>(options: Pick<DescribeOptions, 'connection' | 'session' | 'timeouts'>, work: (client: Client, context: InspectionContext) => Promise<T>): Promise<T>;

package/dist/inspection/connection.js

@@ -1,21 +1,22 @@
-import postgres from 'postgres';
-import { prepareArrays } from '../driver/array.js';
+import { Client } from 'pg';
 import { inspectionOptions } from './options.js';
 /** Bound every database statement, including bootstrap and metadata queries. */
 export async function withInspectionConnection(options, work) {
     const { url, limits, session } = inspectionOptions(options);
-    const client = postgres(url.toString(), {
-        max: 1,
-        connect_timeout: limits.connectMs / 1000,
-        // The inspector reads its own metadata; avoid an implicit array-catalog fetch.
-        fetch_types: false,
-        onnotice() { },
+    const client = new Client({
+        connectionString: url.toString(),
+        connectionTimeoutMillis: limits.connectMs,
+        statement_timeout: limits.statementMs,
+        lock_timeout: limits.lockMs,
+        pipeline: false,
     });
+    // Disconnection errors outside an active query must still have a listener.
+    client.on('error', () => { });
     try {
-        await client `SELECT
-      set_config('statement_timeout', ${String(limits.statementMs)}, false),
-      set_config('lock_timeout', ${String(limits.lockMs)}, false)`;
-        await prepareArrays(client);
+        await client.connect();
+        await client.query(`SELECT
+      pg_catalog.set_config('statement_timeout', $1, false),
+      pg_catalog.set_config('lock_timeout', $2, false)`, [String(limits.statementMs), String(limits.lockMs)]);
         for (const [key, name] of [
             ['role', 'role'],
             ['searchPath', 'search_path'],
@@ -23,22 +24,21 @@ export async function withInspectionConnection(options, work) {
         ]) {
             const value = session[key];
             if (value !== undefined)
-                await client `SELECT set_config(${name}, ${value}, false)`;
+                await client.query('SELECT pg_catalog.set_config($1, $2, false)', [name, value]);
         }
-        const [context] = await client `
-      SELECT current_database() AS database, session_user AS "sessionUser",
-        current_user AS "currentUser", current_setting('search_path') AS "searchPath",
-        to_json(current_schemas(true)) AS "resolvedSearchPath",
-        current_setting('TimeZone') AS "timeZone",
+        const { rows: [context], } = await client.query(`
+      SELECT pg_catalog.current_database() AS database, session_user AS "sessionUser",
+        current_user AS "currentUser", pg_catalog.current_setting('search_path') AS "searchPath",
+        pg_catalog.to_json(pg_catalog.current_schemas(true)) AS "resolvedSearchPath",
+        pg_catalog.current_setting('TimeZone') AS "timeZone",
         (SELECT setting::integer FROM pg_catalog.pg_settings WHERE name='statement_timeout') AS "statementTimeoutMs",
         (SELECT setting::integer FROM pg_catalog.pg_settings WHERE name='lock_timeout') AS "lockTimeoutMs"
-    `;
+    `);
         if (!context)
             throw new Error('Inspection context was not returned.');
-        return await work(client, { mode: 'separate-session', readMappings: 'postgres', ...context });
+        return await work(client, { mode: 'separate-session', readMappings: 'pg', ...context });
     }
     finally {
-        // Bound cleanup as well; never leave an unbounded end() after a server/network failure.
-        await client.end({ timeout: 1 });
+        await client.end();
     }
 }

package/dist/inspection/options.d.ts

@@ -8,8 +8,8 @@ export declare function inspectionOptions(options: Pick<DescribeOptions, 'connec
         lockMs: number;
     };
     session: {
-        role?: string;
-        searchPath?: string;
-        timeZone?: string;
+        role?: string | undefined;
+        searchPath?: string | undefined;
+        timeZone?: string | undefined;
     };
 };

package/dist/inspection/options.js

@@ -10,6 +10,8 @@ export function inspectionOptions(options) {
         if (!['role', 'searchPath', 'timeZone'].includes(key)) {
             throw new Error(`Unknown inspection session option: ${key}`);
         }
+        if (value === undefined)
+            continue;
         if (typeof value !== 'string' || !value.trim() || value.includes('\0')) {
             throw new Error(`Inspection session ${key} requires a nonempty string without NUL.`);
         }
@@ -20,11 +22,17 @@ export function inspectionOptions(options) {
     for (const [key, value] of Object.entries(timeouts)) {
         if (!Object.hasOwn(defaults, key))
             throw new Error(`Unknown inspection timeout: ${key}`);
+        if (value === undefined)
+            continue;
         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 };
+    const limits = {
+        connectMs: timeouts.connectMs ?? defaults.connectMs,
+        statementMs: timeouts.statementMs ?? defaults.statementMs,
+        lockMs: timeouts.lockMs ?? defaults.lockMs,
+    };
     // URL startup options must not disable the inspection's server-side bounds.
     let url;
     try {

package/dist/inspection/protocol.d.ts

@@ -0,0 +1,7 @@
+import type { Client, FieldDef } from 'pg';
+export interface Description {
+    parameters: number[];
+    fields: FieldDef[];
+}
+/** Describe through pg custom query dispatch; send no Bind or Execute messages. */
+export declare function describe(client: Client, text: string): Promise<Description>;

package/dist/inspection/protocol.js

@@ -0,0 +1,45 @@
+/** Describe through pg custom query dispatch; send no Bind or Execute messages. */
+export function describe(client, text) {
+    return new Promise((resolve, reject) => {
+        let connection;
+        const description = { parameters: [], fields: [] };
+        const parameters = (message) => {
+            description.parameters = message.dataTypeIDs;
+        };
+        const cleanup = () => connection?.removeListener('parameterDescription', parameters);
+        const query = {
+            // pg wraps callback to manage query_timeout, including clearing its timer.
+            callback(error) {
+                cleanup();
+                if (error)
+                    reject(error);
+                else
+                    resolve(description);
+            },
+            submit(wire) {
+                connection = wire;
+                wire.once('parameterDescription', parameters);
+                try {
+                    wire.parse({ name: '', text, types: [] }, false);
+                    wire.describe({ type: 'S', name: '' }, false);
+                    wire.sync();
+                }
+                catch (error) {
+                    return error instanceof Error
+                        ? error
+                        : new Error('Describe dispatch failed', { cause: error });
+                }
+            },
+            handleRowDescription(message) {
+                description.fields = message.fields;
+            },
+            handleReadyForQuery() {
+                query.callback(null);
+            },
+            handleError(error) {
+                query.callback(error);
+            },
+        };
+        client.query(query);
+    });
+}

package/dist/inspection/result.d.ts

@@ -1,4 +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. */
+/** Convert database metadata to conservative pg types and diagnostics. */
 export declare function queryDescription({ statement, types, sources }: StatementMetadata, context: InspectionContext): QueryDescription;

package/dist/inspection/result.js

@@ -1,5 +1,5 @@
 import { arrayTypes, scalarTypes, valueTypes } from '../driver/types.js';
-/** Convert database metadata to conservative Postgres.js types and diagnostics. */
+/** Convert database metadata to conservative pg types and diagnostics. */
 export function queryDescription({ statement, types, sources }, context) {
     const catalog = new Map(types.map((t) => [t.oid, t]));
     const issues = new Map();
@@ -26,14 +26,14 @@ export function queryDescription({ statement, types, sources }, context) {
                 code: 'unmapped-type',
                 oid,
                 postgres: `${type.schema}.${type.name}`,
-                message: `No verified Postgres.js mapping for ${type.schema}.${type.name} (OID ${oid}).`,
+                message: `No verified pg 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) => {
+    const columns = statement.fields.map((column) => {
         if (names.has(column.name)) {
             issues.set(`column:${column.name}`, {
                 code: 'duplicate-column',
@@ -42,10 +42,10 @@ export function queryDescription({ statement, types, sources }, context) {
             });
         }
         names.add(column.name);
-        const source = sourceMap.get(`${column.table}:${column.number}`);
+        const source = sourceMap.get(`${column.tableID}:${column.columnID}`);
         return {
             name: column.name,
-            ...describeType(column.type),
+            ...describeType(column.dataTypeID),
             nullability: 'unknown',
             source: source
                 ? {
@@ -57,7 +57,7 @@ export function queryDescription({ statement, types, sources }, context) {
                 : null,
         };
     });
-    const parameters = statement.types.map(describeType);
+    const parameters = statement.parameters.map(describeType);
     if (columns.length) {
         issues.set('nullability', {
             code: 'nullability-unknown',

package/dist/inspection/types.d.ts

@@ -1,14 +1,14 @@
 import type { SqlQuery } from '../query.js';
 export interface InspectionSession {
-    readonly role?: string;
+    readonly role?: string | undefined;
     /** PostgreSQL's search_path setting, as used in the application's connection options. */
-    readonly searchPath?: string;
-    readonly timeZone?: string;
+    readonly searchPath?: string | undefined;
+    readonly timeZone?: string | undefined;
 }
 export interface InspectionTimeouts {
-    readonly connectMs?: number;
-    readonly statementMs?: number;
-    readonly lockMs?: number;
+    readonly connectMs?: number | undefined;
+    readonly statementMs?: number | undefined;
+    readonly lockMs?: number | undefined;
 }
 export interface InspectionContext {
     readonly mode: 'separate-session';
@@ -20,15 +20,15 @@ export interface InspectionContext {
     readonly timeZone: string;
     readonly statementTimeoutMs: number;
     readonly lockTimeoutMs: number;
-    readonly readMappings: 'postgres';
+    readonly readMappings: 'pg';
 }
 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;
+    readonly session?: InspectionSession | undefined;
+    readonly timeouts?: InspectionTimeouts | undefined;
 }
 export type DescriptionIssue = {
     readonly code: 'nullability-unknown';
@@ -50,7 +50,7 @@ export type DescriptionIssue = {
 export interface DescribedType {
     readonly oid: number;
     readonly postgres: string;
-    /** Postgres.js read representation, before considering result nullability. */
+    /** pg read representation, before considering result nullability. */
     readonly readType: string;
 }
 export interface DescribedColumn extends DescribedType {

package/dist/migrations/connection.d.ts

@@ -1,8 +1,9 @@
-import type { Connection, SqlConnection } from '../connection.js';
+import type { PoolClient } from 'pg';
+import type { Connection } 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: SqlConnection, namespace: string) => Promise<T>): Promise<T>;
+export declare function withMigrationLock<T>(options: DatabaseToolOptions, mode: 'shared' | 'exclusive', work: (client: PoolClient, namespace: string) => Promise<T>): Promise<T>;

package/dist/migrations/connection.js

@@ -1,21 +1,21 @@
-import { reserveConnection } from '../driver/session.js';
-import { createConnection } from '../connection.js';
+import { createConnection, watchClient } 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 { sql: pool, owned } = createConnection(options.connection);
+    const { pool, close } = 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 {
-        connection = await reserveConnection(pool);
-        const client = connection.sql;
-        await client.unsafe(`SELECT pg_advisory_lock${suffix}(hashtextextended($1, 0))`, [lockKey]);
+        client = await pool.connect();
+        connection = watchClient(client);
+        await client.query(`SELECT pg_advisory_lock${suffix}(hashtextextended($1, 0))`, [lockKey]);
         locked = true;
         result = await work(client, namespace);
         connection.check();
@@ -24,37 +24,35 @@ export async function withMigrationLock(options, mode, work) {
         errors.push(error);
     }
     finally {
-        if (connection) {
-            const client = connection.sql;
-            let discard = false;
+        if (client) {
+            let releaseError;
             try {
                 connection.check();
                 if (errors.length)
-                    await client.unsafe('ROLLBACK');
+                    await client.query('ROLLBACK');
                 if (locked) {
-                    await client.unsafe(`SELECT pg_advisory_unlock${suffix}(hashtextextended($1, 0))`, [
+                    await client.query(`SELECT pg_advisory_unlock${suffix}(hashtextextended($1, 0))`, [
                         lockKey,
                     ]);
                 }
             }
             catch (error) {
                 errors.push(error);
-                discard = true;
+                releaseError =
+                    error instanceof Error ? error : new Error('Tool connection cleanup failed.');
             }
             try {
-                await connection.release(discard);
+                connection.release(releaseError);
             }
             catch (error) {
                 errors.push(error);
             }
         }
-        if (owned) {
-            try {
-                await pool.end();
-            }
-            catch (error) {
-                errors.push(error);
-            }
+        try {
+            await close(1000);
+        }
+        catch (error) {
+            errors.push(error);
         }
     }
     if (errors.length === 1) {