@kequtech/tenon-orm 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kequtech/tenon-orm",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "license": "ISC",
   "type": "module",
   "description": "A PostgreSQL ORM designed for coding agents, with explicit SQL, typed queries, and migrations",
@@ -51,11 +51,11 @@
     "prepublishOnly": "npm run check",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "benchmark": "npm run build && node scripts/benchmark.mjs",
-    "test:pilots": "npm run build && node test/pilots/run.mjs"
+    "benchmark": "npm run build && node scripts/benchmark.mjs"
   },
   "dependencies": {
-    "postgres": "3.4.9"
+    "pg": "8.23.1",
+    "@types/pg": "8.23.1"
   },
   "devDependencies": {
     "@types/node": "^24.19.2",

package/dist/driver/array.d.ts

@@ -1,5 +0,0 @@
-import type postgres from 'postgres';
-/** Preserve driver scalar parsers and serializers; replace only lossy array parsing. */
-export declare function prepareArrays(sql: postgres.Sql): Promise<void>;
-/** PostgreSQL text arrays: only unquoted NULL is null; quoted values use the scalar parser. */
-export declare function parseArray(text: string, parse: (value: string) => unknown, delimiter?: string): unknown[];

package/dist/driver/array.js

@@ -1,70 +0,0 @@
-const initialization = new WeakMap();
-/** Preserve driver scalar parsers and serializers; replace only lossy array parsing. */
-export function prepareArrays(sql) {
-    const existing = initialization.get(sql);
-    if (existing)
-        return existing;
-    const ready = (async () => {
-        const customArrays = new Set(Object.values(sql.options.types).flatMap((type) => type.from));
-        const arrays = await sql `
-      SELECT t.typarray AS oid, t.oid AS element, t.typdelim AS delimiter
-      FROM pg_catalog.pg_type t WHERE t.typarray <> 0`;
-        for (const type of arrays) {
-            if (customArrays.has(type.oid))
-                continue;
-            const scalar = sql.options.parsers[type.element] ?? ((value) => value);
-            sql.options.parsers[type.oid] = (value) => parseArray(value, scalar, type.delimiter);
-        }
-    })();
-    initialization.set(sql, ready);
-    void ready.catch(() => initialization.delete(sql));
-    return ready;
-}
-/** PostgreSQL text arrays: only unquoted NULL is null; quoted values use the scalar parser. */
-export function parseArray(text, parse, delimiter = ',') {
-    let position = text.startsWith('[') ? text.indexOf('=') + 1 : 0;
-    function array() {
-        if (text[position++] !== '{')
-            throw new Error('Invalid PostgreSQL array.');
-        const values = [];
-        while (position < text.length && text[position] !== '}') {
-            if (text[position] === '{')
-                values.push(array());
-            else {
-                let value = '';
-                const quoted = text[position] === '"';
-                if (quoted)
-                    position++;
-                while (position < text.length) {
-                    const char = text[position];
-                    if (char === '\\') {
-                        position++;
-                        value += text[position++] ?? '';
-                    }
-                    else if (quoted && char === '"') {
-                        position++;
-                        break;
-                    }
-                    else if (!quoted && (char === delimiter || char === '}'))
-                        break;
-                    else {
-                        value += char;
-                        position++;
-                    }
-                }
-                values.push(!quoted && value === 'NULL' ? null : parse(value));
-            }
-            if (text[position] === delimiter)
-                position++;
-            else if (text[position] !== '}')
-                throw new Error('Invalid PostgreSQL array separator.');
-        }
-        if (text[position++] !== '}')
-            throw new Error('Unterminated PostgreSQL array.');
-        return values;
-    }
-    const result = array();
-    if (position !== text.length)
-        throw new Error('Unexpected PostgreSQL array suffix.');
-    return result;
-}

package/dist/driver/lifecycle.d.ts

@@ -1,15 +0,0 @@
-import type postgres from 'postgres';
-export interface Watch {
-    failure?: Error;
-    check(): void;
-    closed: Promise<never>;
-    reject(error: Error): void;
-}
-interface State {
-    acquiring: Set<(error: Error) => void>;
-    active: Map<number, Watch>;
-    capture(marker: string, watch: Watch): () => void;
-}
-/** Observe the driver's public connection callbacks; never reuse a reconnected transaction. */
-export declare function observeConnections(sql: postgres.Sql): State;
-export {};

package/dist/driver/lifecycle.js

@@ -1,57 +0,0 @@
-const states = new WeakMap();
-function disconnected() {
-    return Object.assign(new Error('The reserved PostgreSQL connection closed.'), {
-        code: 'CONNECTION_CLOSED',
-    });
-}
-/** Observe the driver's public connection callbacks; never reuse a reconnected transaction. */
-export function observeConnections(sql) {
-    const previous = states.get(sql);
-    if (previous)
-        return previous;
-    const markers = new Map();
-    let debug = sql.options.debug;
-    // Capture the bootstrap connection ID, then restore debug before application work.
-    // Leaving it enabled would make the driver include SQL and values in enumerable errors.
-    const captureDebug = (id, text, values, types) => {
-        const watch = markers.get(text);
-        if (watch) {
-            state.active.set(id, watch);
-            markers.delete(text);
-        }
-        if (!markers.size)
-            sql.options.debug = debug;
-        if (typeof debug === 'function')
-            debug(id, text, values, types);
-    };
-    const state = {
-        acquiring: new Set(),
-        active: new Map(),
-        capture(marker, watch) {
-            if (!markers.size) {
-                debug = sql.options.debug;
-                sql.options.debug = captureDebug;
-            }
-            markers.set(marker, watch);
-            return () => {
-                markers.delete(marker);
-                if (!markers.size)
-                    sql.options.debug = debug;
-            };
-        },
-    };
-    const onclose = sql.options.onclose;
-    sql.options.onclose = (id) => {
-        const error = disconnected();
-        const watch = state.active.get(id);
-        if (watch) {
-            watch.failure ??= error;
-            watch.reject(watch.failure);
-        }
-        for (const reject of state.acquiring)
-            reject(error);
-        onclose?.(id);
-    };
-    states.set(sql, state);
-    return state;
-}

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();
-    }
-}