@kequtech/tenon-orm 0.2.2 → 0.3.0

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,5 +1,4 @@
-export type { JSONValue } from 'postgres';
-export type { Connection, ConnectionOptions, ConnectionUri, QueryResult } from './connection.js';
+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';

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/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/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

@@ -20,7 +20,7 @@ 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. */
@@ -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) {

package/dist/migrations/history.d.ts

@@ -1,4 +1,4 @@
-import type { SqlConnection } from '../connection.js';
+import type { PoolClient } from 'pg';
 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: 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 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 {};

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.unsafe('SELECT to_regclass($1)::text AS name', [qualified(namespace, migrationTable)]);
-    if (exists[0].name === null) {
+    const exists = await client.query('SELECT to_regclass($1)::text AS name', [qualified(namespace, migrationTable)]);
+    if (exists.rows[0].name === null) {
         return [];
     }
-    const applied = await client.unsafe(`SELECT id, name, checksum FROM ${qualified(namespace, migrationTable)} ORDER BY id::numeric`);
+    const { rows: applied } = await client.query(`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.unsafe(`CREATE TABLE IF NOT EXISTS ${qualified(namespace, migrationTable)} (
+    await client.query(`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.unsafe(`INSERT INTO ${qualified(namespace, migrationTable)} (id, name, checksum) VALUES ($1, $2, $3)`, [migration.id, migration.name, migration.checksum]);
+    await client.query(`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.unsafe(`CREATE SCHEMA IF NOT EXISTS ${quote(namespace)}`);
+        await client.query(`CREATE SCHEMA IF NOT EXISTS ${quote(namespace)}`);
         await createHistoryTable(client, namespace);
         const completed = [];
         for (const file of selected) {
             try {
-                await client.unsafe('BEGIN');
+                await client.query('BEGIN');
                 // Match the string-literal rules used by the authored migration scanner.
-                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);
+                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);
                 if (direction === 'up') {
                     await recordMigration(client, namespace, file);
                 }
                 else {
-                    await client.unsafe(`DELETE FROM ${qualified(namespace, migrationTable)} WHERE id = $1`, [
+                    await client.query(`DELETE FROM ${qualified(namespace, migrationTable)} WHERE id = $1`, [
                         file.id,
                     ]);
                 }
-                const result = await client.unsafe('COMMIT');
+                const result = await client.query('COMMIT');
                 if (result.command !== 'COMMIT') {
                     throw new Error('The migration transaction was rolled back.');
                 }

package/dist/query-options.js

@@ -27,9 +27,9 @@ export function queryOutput(options, result) {
     if (options.returns === 'native')
         return result;
     if (options.returns === 'many')
-        return [...result];
-    if (result.length > 1 || (options.returns === 'one' && result.length === 0)) {
-        throw new CardinalityError(options.returns === 'oneOrNone' ? 'oneOrNone' : 'one', result.length, options.label);
+        return result.rows;
+    if (result.rows.length > 1 || (options.returns === 'one' && result.rows.length === 0)) {
+        throw new CardinalityError(options.returns === 'oneOrNone' ? 'oneOrNone' : 'one', result.rows.length, options.label);
     }
-    return result[0];
+    return result.rows[0];
 }

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 > 65533)
-        throw new Error(`Postgres.js 3.4.9 supports at most 65533 bound parameters; received ${values.length}. Split large batches explicitly.`);
+    if (values.length > 65535)
+        throw new Error(`PostgreSQL supports at most 65535 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/transaction.d.ts

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