@kequtech/tenon-orm 0.2.2 → 0.3.0

package/dist/driver/listener.js

@@ -1,63 +0,0 @@
-import { createConnection } from 'node:net';
-function closedError() {
-    return Object.assign(new Error('The owned PostgreSQL listener is closed.'), {
-        code: 'CONNECTION_ENDED',
-    });
-}
-/** Prevent an owned LISTEN client's queued reconnect from reopening it after shutdown. */
-export function guardListenerShutdown(sql) {
-    const options = sql.options;
-    const listen = sql.listen;
-    const sockets = new Set();
-    let closed = false;
-    let hostIndex = 0;
-    function track(socket) {
-        // TLS adoption removes raw socket listeners; prune those closed transports on reconnect.
-        for (const previous of sockets)
-            if (previous.destroyed)
-                sockets.delete(previous);
-        sockets.add(socket);
-        socket.once('close', () => sockets.delete(socket));
-        if (closed) {
-            socket.destroy();
-            throw closedError();
-        }
-        return socket;
-    }
-    sql.listen = (...args) => {
-        if (closed)
-            return Promise.reject(closedError());
-        const previous = options.socket;
-        // Postgres.js synchronously clones these options for its dedicated max:1 listener.
-        // Restore immediately so ordinary queries retain their native transport configuration.
-        options.socket = (settings) => {
-            if (closed)
-                throw closedError();
-            if (previous)
-                return Promise.resolve(previous(settings)).then(track);
-            const host = settings.host[hostIndex];
-            const port = settings.port[hostIndex];
-            const socket = createConnection(settings.path ? { path: settings.path } : { host, port });
-            if (!settings.path) {
-                hostIndex = (hostIndex + 1) % settings.port.length;
-                // The driver's TLS negotiation uses this metadata for SNI and verification.
-                Object.assign(socket, { host, port });
-            }
-            // Node buffers startup writes while connecting; the driver retains its connect timeout,
-            // authentication, TLS negotiation and reconnect handling.
-            return track(socket);
-        };
-        try {
-            return listen(...args);
-        }
-        finally {
-            options.socket = previous;
-        }
-    };
-    return () => {
-        closed = true;
-        for (const socket of sockets)
-            socket.destroy();
-        sockets.clear();
-    };
-}

package/dist/driver/session.d.ts

@@ -1,8 +0,0 @@
-import type postgres from 'postgres';
-import type { SqlConnection } from '../connection.js';
-/** Pin a healthy session for transactions and advisory locks, with explicit failure cleanup. */
-export declare function reserveConnection(sql: postgres.Sql, initial?: 'SELECT 1' | 'BEGIN'): Promise<{
-    sql: SqlConnection;
-    check: () => void;
-    release(discard?: boolean): Promise<void>;
-}>;

package/dist/driver/session.js

@@ -1,92 +0,0 @@
-import { prepareArrays } from './array.js';
-import { observeConnections } from './lifecycle.js';
-let nextLease = 0;
-/** Pin a healthy session for transactions and advisory locks, with explicit failure cleanup. */
-export async function reserveConnection(sql, initial = 'SELECT 1') {
-    await prepareArrays(sql);
-    const state = observeConnections(sql);
-    // Warm a connection before reserve(): 3.4.9 can strand a cold reserve after reconnect.
-    await sql `SELECT 1`;
-    let abandoned = false;
-    let rejectAcquisition;
-    const closed = new Promise((_, reject) => {
-        rejectAcquisition = reject;
-    });
-    state.acquiring.add(rejectAcquisition);
-    const pending = sql.reserve();
-    void pending.then((client) => {
-        if (abandoned)
-            client.release();
-    }, () => { });
-    let client;
-    try {
-        client = await Promise.race([pending, closed]);
-    }
-    catch (error) {
-        abandoned = true;
-        throw error;
-    }
-    finally {
-        state.acquiring.delete(rejectAcquisition);
-    }
-    let rejectClosed;
-    const closedSession = new Promise((_, reject) => {
-        rejectClosed = reject;
-    });
-    void closedSession.catch(() => { });
-    const watch = {
-        closed: closedSession,
-        reject: rejectClosed,
-        check() {
-            if (watch.failure)
-                throw watch.failure;
-        },
-    };
-    const safe = {
-        async unsafe(text, input = [], options) {
-            watch.check();
-            // Driver dispatch runs in the next microtask, before another socket event.
-            const query = client.unsafe(text, input, options).execute();
-            return Promise.race([query, watch.closed]);
-        },
-        array: client.array,
-        typed: client.typed,
-    };
-    const connection = {
-        sql: safe,
-        check: watch.check,
-        async release(discard = false) {
-            for (const [id, active] of state.active)
-                if (active === watch)
-                    state.active.delete(id);
-            if (watch.failure)
-                return; // The driver already removed the closed session.
-            if (discard) {
-                // Failed recovery must not return an unknown transaction/lock state to the pool.
-                try {
-                    await client.unsafe('SELECT pg_terminate_backend(pg_backend_pid())').execute();
-                }
-                catch {
-                    /* The backend closes itself. */
-                }
-                return;
-            }
-            client.release();
-        },
-    };
-    // Capture the connection on BEGIN itself when opening a transaction.
-    const marker = `${initial} /* tenon_session_${++nextLease} */`;
-    const stopCapture = state.capture(marker, watch);
-    try {
-        await safe.unsafe(marker, [], { simple: false, prepare: false });
-        watch.check();
-        return connection;
-    }
-    catch (error) {
-        await connection.release(true);
-        throw error;
-    }
-    finally {
-        stopCapture();
-    }
-}