@feasibleone/blong-gogo 1.28.0 → 1.30.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [1.30.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.29.0...blong-gogo-v1.30.0) (2026-08-21)
+
+
+### Features
+
+* access sessions and audit ([694349f](https://github.com/feasibleone/blong/commit/694349f7e70973b984a30f696d2b6e892b55ec02))
+* improve MySQL handling in CI ([4770eec](https://github.com/feasibleone/blong/commit/4770eec3a24cd38cd1931da1c553e0a804ca58dd))
+
+
+### Bug Fixes
+
+* api gateway wiring ([cbdb743](https://github.com/feasibleone/blong/commit/cbdb7439a997925ca6a4ba07e046ad2809d37218))
+* blong-access-mock, silent error, expected error ([dc00429](https://github.com/feasibleone/blong/commit/dc00429a63a973996d6e94359830cc52d149b995))
+* build ([fc98bed](https://github.com/feasibleone/blong/commit/fc98beda0e7ba800682bd663eeebd4408ce04bf1))
+
+## [1.29.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.28.0...blong-gogo-v1.29.0) (2026-08-19)
+
+
+### Features
+
+* blong-access UI ([999de20](https://github.com/feasibleone/blong/commit/999de20b5f8e36979787bed71695de45a4006f5f))
+
 ## [1.28.0](https://github.com/feasibleone/blong/compare/blong-gogo-v1.27.0...blong-gogo-v1.28.0) (2026-08-19)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feasibleone/blong-gogo",
-  "version": "1.28.0",
+  "version": "1.30.0",
   "repository": {
     "url": "git+https://github.com/feasibleone/blong.git"
   },
@@ -87,6 +87,7 @@
     "playwright": "^1.60.0",
     "tap": "^21.6.3",
     "typescript": "^6.0.3",
+    "vite": "^8.2.1",
     "@feasibleone/blong-dev": "1.2.0"
   },
   "scripts": {

package/src/AdapterBase.ts

@@ -183,6 +183,7 @@ export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext
 
     error(error: ITypedError, $meta: IMeta): ITypedError {
         if ($meta) error.method = $meta.method;
+        if (error.silent) return error;
         if (isExpectedError(error.type, $meta?.expect)) {
             (this.log as {debug?: (...args: unknown[]) => void})?.debug?.(error);
             return error;
@@ -195,14 +196,22 @@ export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext
         return null;
     }
 
+    namespaces(): (string | RegExp)[] {
+        const namespace = this.config.namespace;
+        return ([] as (string | RegExp)[]).concat(
+            namespace
+                ? Array.isArray(namespace) || typeof namespace === 'string'
+                    ? namespace
+                    : Object.keys(namespace)
+                : this.config.imports || this.config.id.replace(/\./g, '-'),
+        );
+    }
+
     handles(name: string): boolean {
         if (reserved.includes(name)) return true;
-        const id = this.config.id.replace(/\./g, '-');
-        return ([] as (string | RegExp)[])
-            .concat(this.config.namespace || this.config.imports || id)
-            .some(namespace =>
-                typeof namespace === 'string' ? name.startsWith(namespace) : namespace.test(name),
-            );
+        return this.namespaces().some(namespace =>
+            typeof namespace === 'string' ? name.startsWith(namespace) : namespace.test(name),
+        );
     }
 
     methodPath(methodName: string): string {
@@ -297,10 +306,7 @@ export class AdapterBase<T, C extends IContext> implements AdapterHandlerContext
     }
 
     forNamespaces<R>(reducer: (prev: R, current: unknown) => R, initial: R): R {
-        const id = this.config.id.replace(/\./g, '-');
-        return ([] as (string | RegExp)[])
-            .concat(this.config.namespace || this.config.imports || id)
-            .reduce(reducer.bind(this), initial);
+        return this.namespaces().reduce(reducer.bind(this), initial);
     }
 
     async start(): Promise<unknown> {
@@ -390,12 +396,34 @@ export default async function adapter<T, C extends IContext>(
 
     const base = new AdapterBase<T, C>(api, configBase, activationNames);
 
-    const result = handlers!({utError, remote, type, schema: registry.objectSchema, manifest: api.manifest});
+    const result = handlers!({
+        utError,
+        remote,
+        type,
+        schema: registry.objectSchema,
+        manifest: api.manifest,
+    });
     let current = result;
     while (current.extends) {
         const parent = await (typeof current.extends === 'string'
-            ? adapterFactory(current.extends)!({utError, remote, rpc, local, registry, schema, manifest: api.manifest})
-            : current.extends({utError, remote, rpc, local, registry, schema, manifest: api.manifest}));
+            ? adapterFactory(current.extends)!({
+                  utError,
+                  remote,
+                  rpc,
+                  local,
+                  registry,
+                  schema,
+                  manifest: api.manifest,
+              })
+            : current.extends({
+                  utError,
+                  remote,
+                  rpc,
+                  local,
+                  registry,
+                  schema,
+                  manifest: api.manifest,
+              }));
         Object.setPrototypeOf(current, parent);
         current = parent;
     }

package/src/Gateway.ts

@@ -78,6 +78,17 @@ interface IConfig extends IConfigMLE {
      * then enforces that every request's methodId is in the allowed list.
      */
     authorize?: string;
+    /**
+     * Optional access-check audit.  When set, the gateway records every
+     * authorization decision (allow/deny) at the access-check point into the
+     * configured handler, plus sanitised DML context for access.* write
+     * methods.  `exclude` lists methodId patterns (exact or `prefix*`) that
+     * must not be audited.  Best-effort — audit failures never block requests.
+     */
+    audit?: {
+        handler: string;
+        exclude?: string[];
+    };
     errorFields: unknown[];
     jwt: {
         cache: object;
@@ -171,6 +182,7 @@ export default class Gateway extends Internal implements IGateway {
         debug: false,
         expectedErrors: false,
         authorize: undefined,
+        audit: undefined,
         errorFields: [],
         jwt: {
             cache: {},
@@ -369,6 +381,8 @@ export default class Gateway extends Internal implements IGateway {
                     ...(value.bundle !== undefined && {bundle: value.bundle}),
                     ...(value.creditCost !== undefined && {creditCost: value.creditCost}),
                     ...(value.meter !== undefined && {meter: value.meter}),
+                    ...(value.audit !== undefined && {audit: value.audit}),
+                    ...(value.skipAuthorize && {skipAuthorize: true}),
                 },
                 schema: Type && {
                     ...('body' in value
@@ -530,18 +544,23 @@ export default class Gateway extends Internal implements IGateway {
                             httpResponse?: unknown;
                             [key: string]: unknown;
                         };
-                        if (
-                            isExpectedError(typedError.type as string | undefined, resolvedExpect)
-                        ) {
-                            request.log.debug(
-                                {err: error, method: methodName},
-                                'gateway expected error',
-                            );
-                        } else {
-                            request.log.error(
-                                {err: error, method: methodName},
-                                'gateway handler error',
-                            );
+                        if (!typedError.silent) {
+                            if (
+                                isExpectedError(
+                                    typedError.type as string | undefined,
+                                    resolvedExpect,
+                                )
+                            ) {
+                                request.log.debug?.(
+                                    {err: error, method: methodName},
+                                    'gateway expected error',
+                                );
+                            } else {
+                                request.log.error?.(
+                                    {err: error, method: methodName},
+                                    'gateway handler error',
+                                );
+                            }
                         }
                         this._applyMeta(
                             reply
@@ -614,6 +633,7 @@ export default class Gateway extends Internal implements IGateway {
                 errors: this.#errors,
                 audience: this.#config.jwt.audience,
                 authorize: this.#config.authorize,
+                audit: this.#config.audit,
                 local: this.#local,
                 methodId: methodId,
                 methodParts: methodParts,

package/src/adapter/browser.ts

@@ -1,3 +1,4 @@
+/// <reference types="vite/client" />
 import {realm} from '@feasibleone/blong/types';
 
 export default realm(blong => ({

package/src/adapter/schema/knex/json.test.ts

@@ -11,9 +11,11 @@ import {test} from 'tap';
 
 import {
     isDeadlock,
+    isRetryableConnectionError,
     parseJsonResult,
     parseJsonRow,
     stringifyJsonValues,
+    withConnectionRetry,
     wrapJsonBuilder,
     wrapKnex,
 } from './json.ts';
@@ -216,6 +218,173 @@ test('wrapKnex transaction() wraps the resolved trx (promise form)', async t =>
     t.end();
 });
 
+const CONN_LOST = {
+    code: 'PROTOCOL_CONNECTION_LOST',
+    fatal: true,
+    sql: 'UPDATE `t` SET `x` = 1',
+    sqlMessage: 'Connection lost: The server closed the connection.',
+    message: 'Connection lost: The server closed the connection.',
+};
+
+const DUP_ENTRY = {errno: 1062, code: 'ER_DUP_ENTRY', message: 'Duplicate entry'};
+
+const BOOM = new Error('boom');
+
+test('isRetryableConnectionError detects transient connection errors only', t => {
+    t.equal(
+        isRetryableConnectionError({code: 'PROTOCOL_CONNECTION_LOST', fatal: true}),
+        true,
+        'PROTOCOL_CONNECTION_LOST with fatal flag',
+    );
+    t.equal(isRetryableConnectionError({fatal: true}), true, 'fatal flag alone');
+    t.equal(isRetryableConnectionError({code: 'ECONNRESET'}), true, 'ECONNRESET');
+    t.equal(isRetryableConnectionError({code: 'ER_CON_COUNT_ERROR'}), true, 'too many connections');
+    t.equal(
+        isRetryableConnectionError({code: 'ER_LOCK_DEADLOCK', errno: 1213}),
+        false,
+        'deadlock is not a connection error',
+    );
+    t.equal(isRetryableConnectionError(DUP_ENTRY), false, 'constraint violation');
+    t.equal(isRetryableConnectionError(BOOM), false, 'plain error');
+    t.equal(isRetryableConnectionError(null), false, 'null');
+    t.equal(isRetryableConnectionError('PROTOCOL_CONNECTION_LOST'), false, 'string');
+    t.end();
+});
+
+test('withConnectionRetry runs once when retry is disabled (default)', async t => {
+    let calls = 0;
+    const run = async () => {
+        calls += 1;
+        throw CONN_LOST;
+    };
+    await t.rejects(withConnectionRetry(run, {}), CONN_LOST, 'error propagates');
+    t.equal(calls, 1, 'exactly one attempt');
+    t.end();
+});
+
+test('withConnectionRetry retries transient connection errors and recovers', async t => {
+    let calls = 0;
+    const run = async () => {
+        calls += 1;
+        if (calls < 3) throw CONN_LOST;
+        return 'ok';
+    };
+    const result = await withConnectionRetry(run, {
+        retry: {enabled: true, maxRetries: 3, backoffMs: 1},
+    });
+    t.equal(result, 'ok');
+    t.equal(calls, 3, 'first attempt + two retries');
+    t.end();
+});
+
+test('withConnectionRetry does not retry non-connection errors', async t => {
+    let calls = 0;
+    const run = async () => {
+        calls += 1;
+        throw DUP_ENTRY;
+    };
+    await t.rejects(
+        withConnectionRetry(run, {retry: {enabled: true, maxRetries: 3, backoffMs: 1}}),
+        DUP_ENTRY,
+    );
+    t.equal(calls, 1, 'constraint violations are not retried');
+    t.end();
+});
+
+test('withConnectionRetry gives up after maxRetries and surfaces the error', async t => {
+    let calls = 0;
+    const run = async () => {
+        calls += 1;
+        throw CONN_LOST;
+    };
+    await t.rejects(
+        withConnectionRetry(run, {retry: {enabled: true, maxRetries: 2, backoffMs: 1}}),
+        CONN_LOST,
+        'final error surfaces',
+    );
+    t.equal(calls, 3, 'first attempt + maxRetries retries');
+    t.end();
+});
+
+test('wrapJsonBuilder recovers a transient connection error via clone re-execution', async t => {
+    const builder = makeFlakyBuilder(2, CONN_LOST);
+    const wrapped = wrapJsonBuilder(builder, {
+        retry: {enabled: true, maxRetries: 5, backoffMs: 1},
+    });
+
+    const result = await wrapped.then((value: unknown) => value);
+    t.same(result, {ok: 3}, 'query succeeds after two dropped connections');
+    t.equal(builder.attempts(), 3, 'original + two clone re-executions');
+    t.end();
+});
+
+test('wrapJsonBuilder reports connection errors via onConnectionError', async t => {
+    const reported: unknown[] = [];
+    const builder = makeFlakyBuilder(1, CONN_LOST);
+    const wrapped = wrapJsonBuilder(builder, {
+        retry: {enabled: true, maxRetries: 3, backoffMs: 1},
+        onConnectionError: error => reported.push(error),
+    });
+
+    const result = await wrapped.then((value: unknown) => value);
+    t.same(result, {ok: 2}, 'recovers');
+    t.same(reported, [CONN_LOST], 'the dropped connection was reported');
+    t.end();
+});
+
+test('wrapJsonBuilder does not retry when retry is disabled', async t => {
+    const reported: unknown[] = [];
+    const builder = makeFlakyBuilder(1, CONN_LOST);
+    const wrapped = wrapJsonBuilder(builder, {
+        onConnectionError: error => reported.push(error),
+    });
+
+    await t.rejects(Promise.resolve(wrapped.then(null, null)), CONN_LOST, 'error propagates');
+    t.equal(builder.attempts(), 1, 'exactly one attempt');
+    t.same(reported, [CONN_LOST], 'connection error still reported for diagnostics');
+    t.end();
+});
+
+test('wrapJsonBuilder never retries non-connection errors', async t => {
+    const builder = makeFlakyBuilder(1, BOOM);
+    const wrapped = wrapJsonBuilder(builder, {
+        retry: {enabled: true, maxRetries: 3, backoffMs: 1},
+    });
+
+    await t.rejects(Promise.resolve(wrapped.then(null, null)), /boom/, 'error propagates');
+    t.equal(builder.attempts(), 1, 'plain errors are not retried');
+    t.end();
+});
+
+test('wrapKnex raw() retries transient connection errors by re-invoking raw', async t => {
+    let calls = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const fakeKnex = (() => undefined) as any;
+    fakeKnex.raw = () => {
+        calls += 1;
+        const ok = calls > 1;
+        return {
+            then(
+                onFulfilled?: (value: unknown) => unknown,
+                onRejected?: (reason: unknown) => unknown,
+            ) {
+                return ok
+                    ? Promise.resolve({rows: [{n: calls}]}).then(onFulfilled, onRejected)
+                    : Promise.reject(CONN_LOST).then(onFulfilled, onRejected);
+            },
+        };
+    };
+    const wrapped = wrapKnex(fakeKnex, {
+        retry: {enabled: true, maxRetries: 3, backoffMs: 1},
+    });
+
+    const raw = wrapped.raw('CALL something()');
+    const result = await Promise.resolve(raw.then((value: unknown) => value));
+    t.same(result, {rows: [{n: 2}]}, 'raw re-invoked on retry');
+    t.equal(calls, 2, 'knex.raw called twice');
+    t.end();
+});
+
 /** A minimal knex-like builder whose `then` rejects with `error`. */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function makeRejectingBuilder(error: unknown): any {
@@ -241,3 +410,32 @@ function makeRejectingThenable(error: unknown): any {
         },
     };
 }
+
+/**
+ * A knex-like builder whose first `failures` `then` calls reject with `error`
+ * and whose later calls resolve. `clone()` returns a fresh builder sharing the
+ * same attempt counter, mirroring how the retry path re-runs a cloned builder.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function makeFlakyBuilder(failures: number, error: unknown): any {
+    let attempts = 0;
+    const make = () => ({
+        insert(..._args: unknown[]) {
+            return this;
+        },
+        update(..._args: unknown[]) {
+            return this;
+        },
+        then(onFulfilled?: (value: unknown) => unknown, onRejected?: (reason: unknown) => unknown) {
+            attempts += 1;
+            return attempts <= failures
+                ? Promise.reject(error).then(onFulfilled, onRejected)
+                : Promise.resolve({ok: attempts}).then(onFulfilled, onRejected);
+        },
+        clone() {
+            return make();
+        },
+        attempts: () => attempts,
+    });
+    return make();
+}

package/src/adapter/schema/knex/json.ts

@@ -17,6 +17,8 @@
  * `access_credential.credentialParamsJSON`.
  */
 
+import {type IKnexRetryOptions} from './types.ts';
+
 /** Column names ending in `JSON` are treated as JSON documents. */
 const JSON_COLUMN = /JSON$/;
 
@@ -36,11 +38,78 @@ export function isDeadlock(error: unknown): boolean {
 }
 
 /**
- * Optional hooks applied while wrapping the shared knex instance.
+ * Error codes that indicate a *transient* MySQL connection failure worth
+ * retrying — the server closed the socket, the pool hit the server's
+ * `max_connections`, or the TCP link was reset. `fatal: true` is the generic
+ * marker mysql2 sets for errors that invalidate the connection (it is set on
+ * `PROTOCOL_CONNECTION_LOST`, the error observed intermittently in CI).
+ */
+const RETRYABLE_CONNECTION_CODES = new Set([
+    'PROTOCOL_CONNECTION_LOST',
+    'PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR',
+    'ECONNRESET',
+    'ETIMEDOUT',
+    'ER_CON_COUNT_ERROR', // Too many connections (server max_connections)
+    'ER_SERVER_SHUTDOWN', // Server shutting down
+    'ER_ABORTING_CONNECTION',
+]);
+
+/**
+ * Whether a query error is a transient connection failure the adapter may
+ * retry. Only connection-level failures qualify — deadlocks, constraint
+ * violations and ordinary SQL errors are never retried here.
+ */
+export function isRetryableConnectionError(error: unknown): boolean {
+    if (!error || typeof error !== 'object') return false;
+    const {code, fatal} = error as {code?: unknown; fatal?: unknown};
+    return fatal === true || (typeof code === 'string' && RETRYABLE_CONNECTION_CODES.has(code));
+}
+
+/**
+ * Optional hooks and behaviour applied while wrapping the shared knex instance.
  */
 export interface WrapKnexOptions {
     /** Invoked when a query rejects with a deadlock error, before the caller's rejection handler. */
     onDeadlock?: (error: unknown) => void;
+    /**
+     * Invoked when a query rejects with a transient connection error (before the
+     * caller's rejection handler). Fired on every failed attempt — including when
+     * retry is disabled — so connection drops can be logged for diagnostics.
+     */
+    onConnectionError?: (error: unknown) => void;
+    /**
+     * Opt-in retry of transient connection errors. Non-prod only — disabled by
+     * default; enable via the `knex.retry` config block (see `srv.db`).
+     */
+    retry?: IKnexRetryOptions;
+}
+
+/**
+ * Run `run()` once; if it rejects with a transient connection error and retry
+ * is enabled, re-run it (up to `maxRetries`) with linear backoff
+ * (`backoffMs * attempt`). Between attempts the knex pool re-establishes a
+ * healthy connection, so a query that hit a dead socket usually succeeds on the
+ * next attempt. When retry is disabled (default) the query runs exactly once.
+ */
+export async function withConnectionRetry<T>(
+    run: () => Promise<T>,
+    options: WrapKnexOptions,
+): Promise<T> {
+    const retry = options.retry;
+    if (!retry?.enabled) return run();
+    const maxRetries = retry.maxRetries ?? 3;
+    const backoffMs = retry.backoffMs ?? 250;
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await run();
+        } catch (error) {
+            if (!isRetryableConnectionError(error)) throw error;
+            if (attempt >= maxRetries) throw error;
+            attempt += 1;
+            await new Promise(resolve => setTimeout(resolve, backoffMs * attempt));
+        }
+    }
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -96,7 +165,8 @@ export function parseJsonResult(result: unknown): unknown {
  * Only `insert`, `update`, and `then` are intercepted — all other builder
  * behaviour is untouched.  Chained calls keep working because knex builder
  * methods return the same instance.  The `then` rejection path is also
- * intercepted to detect MySQL deadlocks and report them via `options.onDeadlock`.
+ * intercepted to detect MySQL deadlocks and report them via `options.onDeadlock`,
+ * and to retry transient connection errors via `options.retry`.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function wrapJsonBuilder(builder: any, options: WrapKnexOptions = {}): any {
@@ -123,40 +193,83 @@ export function wrapJsonBuilder(builder: any, options: WrapKnexOptions = {}): an
     builder.then = (
         onFulfilled?: ((value: unknown) => unknown) | null,
         onRejected?: ((reason: unknown) => unknown) | null,
-    ) =>
-        originalThen(
-            (result: unknown) => {
-                const processed = parseJsonResult(result);
-                return typeof onFulfilled === 'function' ? onFulfilled(processed) : processed;
-            },
-            (reason: unknown) => {
-                if (isDeadlock(reason)) options.onDeadlock?.(reason);
-                if (typeof onRejected === 'function') return onRejected(reason);
-                throw reason;
-            },
-        );
+    ) => {
+        // Each attempt runs the query again. The first attempt executes the
+        // original builder via its captured `then`; retries re-run a fresh
+        // clone (knex builders are single-shot) whose `then` is the original
+        // prototype method — re-acquiring a healthy connection from the pool.
+        let attempt = 0;
+        const execute = () => {
+            const cloneable = typeof builder.clone === 'function';
+            const target = attempt === 0 || !cloneable ? null : builder.clone();
+            const thenFn = target ? target.then.bind(target) : originalThen;
+            attempt += 1;
+            return new Promise<unknown>((resolve, reject) => {
+                thenFn(
+                    (result: unknown) => {
+                        const processed = parseJsonResult(result);
+                        resolve(
+                            typeof onFulfilled === 'function' ? onFulfilled(processed) : processed,
+                        );
+                    },
+                    (reason: unknown) => {
+                        if (isDeadlock(reason)) options.onDeadlock?.(reason);
+                        if (isRetryableConnectionError(reason)) options.onConnectionError?.(reason);
+                        reject(reason);
+                    },
+                );
+            });
+        };
+        return withConnectionRetry(execute, options).then(undefined, (reason: unknown) => {
+            if (typeof onRejected === 'function') return onRejected(reason);
+            throw reason;
+        });
+    };
 
     return builder;
 }
 
 /**
  * Intercept the `then` rejection path of a thenable (e.g. a knex `Raw` result)
- * so MySQL deadlocks are reported via `options.onDeadlock`. Mirrors the
- * rejection interception in {@link wrapJsonBuilder} without the JSON column
- * handling, which does not apply to `raw` queries / stored-procedure calls.
+ * so MySQL deadlocks are reported via `options.onDeadlock` and transient
+ * connection errors are reported via `options.onConnectionError` / retried via
+ * `options.retry`. `rerun()` re-creates the query (e.g. re-invoking
+ * `knex.raw(...)` with the same args) so a connection failure can be retried.
+ * Mirrors the rejection interception in {@link wrapJsonBuilder} without the JSON
+ * column handling, which does not apply to `raw` queries / stored-procedure calls.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function attachDeadlockHook(thenable: any, options: WrapKnexOptions): any {
+function attachQueryHook(thenable: any, options: WrapKnexOptions, rerun: () => any): any {
     const originalThen = thenable.then.bind(thenable);
     thenable.then = (
         onFulfilled?: ((value: unknown) => unknown) | null,
         onRejected?: ((reason: unknown) => unknown) | null,
-    ) =>
-        originalThen(onFulfilled, (reason: unknown) => {
-            if (isDeadlock(reason)) options.onDeadlock?.(reason);
+    ) => {
+        // The first attempt runs the original thenable via its captured `then`;
+        // retries re-invoke `rerun()` to obtain a fresh thenable backed by a new
+        // query (and, for raw, a freshly acquired pool connection).
+        let attempt = 0;
+        const execute = () => {
+            const target = attempt === 0 ? null : rerun();
+            const thenFn = target ? target.then.bind(target) : originalThen;
+            attempt += 1;
+            return new Promise<unknown>((resolve, reject) => {
+                thenFn(
+                    (result: unknown) =>
+                        resolve(typeof onFulfilled === 'function' ? onFulfilled(result) : result),
+                    (reason: unknown) => {
+                        if (isDeadlock(reason)) options.onDeadlock?.(reason);
+                        if (isRetryableConnectionError(reason)) options.onConnectionError?.(reason);
+                        reject(reason);
+                    },
+                );
+            });
+        };
+        return withConnectionRetry(execute, options).then(undefined, (reason: unknown) => {
             if (typeof onRejected === 'function') return onRejected(reason);
             throw reason;
         });
+    };
     return thenable;
 }
 
@@ -186,7 +299,8 @@ export function wrapKnex<T>(knex: T, options: WrapKnexOptions = {}): T {
                 const original = Reflect.get(target, prop, target);
                 if (typeof original !== 'function') return original;
                 const bound = original.bind(target);
-                return (...args: unknown[]) => attachDeadlockHook(bound(...args), options);
+                return (...args: unknown[]) =>
+                    attachQueryHook(bound(...args), options, () => bound(...args));
             }
             if (prop === 'transaction') {
                 const original = Reflect.get(target, prop, target);