@proteinjs/db-driver-knex 1.14.1 → 1.15.1

package/test/OperationDeadline.test.ts

@@ -0,0 +1,118 @@
+import knex from 'knex';
+import { KnexDriver } from '@proteinjs/db-driver-knex';
+import { Logger } from '@proteinjs/logger';
+
+/**
+ * The driver's per-operation deadline: every query and DML statement runs under it, and the driver
+ * reports it (`DbDriver.getOperationDeadlineMs`) — so code that sizes a wait by the driver's
+ * deadline is sized by a bound the driver actually enforces. A statement the server never answers
+ * fails AT the deadline with an error naming it, and the statement is cancelled on the server
+ * (`KILL QUERY` naming the connection it runs on), instead of holding its connection indefinitely.
+ *
+ * No server is needed: the REAL query layer and dialect run over a stub connection that answers
+ * transaction control and `KILL QUERY`, and never answers any other statement.
+ */
+
+type DriverStatics = { KNEX?: unknown };
+type DriverInternals = { logger: Logger };
+
+/** The thread ids of the connections a statement was left unanswered on. */
+const unanswered: number[] = [];
+/** Every `KILL QUERY` the stub server received, by the thread id it named. */
+const killed: number[] = [];
+let nextThreadId = 100;
+
+/** A connection whose server never answers a statement — until it is killed. */
+const silentConnection = () => {
+  const threadId = nextThreadId++;
+  return {
+    threadId,
+    state: 'authenticated',
+    on: () => undefined,
+    removeAllListeners: () => undefined,
+    connect: (done: (error?: Error) => void) => done(),
+    end: (done: (error?: Error) => void) => done(),
+    query: (options: { sql: string }, bindings: any[], done: (error: Error | null, rows?: unknown[]) => void) => {
+      if (/^\s*(BEGIN|COMMIT|ROLLBACK)/i.test(options.sql)) {
+        done(null, []);
+        return;
+      }
+      if (/^\s*KILL QUERY/i.test(options.sql)) {
+        killed.push(bindings[0]);
+        done(null, []);
+        return;
+      }
+      // Never answered: the statement a dead link or a stuck server leaves in flight.
+      unanswered.push(threadId);
+    },
+  };
+};
+
+const config = { host: 'localhost', user: 'root', password: '', dbName: 'test' };
+const statement = () => ({ sql: 'SELECT `id` FROM `row` WHERE `id` = ?', params: ['row-1'] });
+
+describe('The knex driver`s per-operation deadline: reported, and enforced on every statement', () => {
+  const statics = KnexDriver as unknown as DriverStatics;
+  let instance: ReturnType<typeof knex>;
+  let previousInstance: unknown;
+
+  beforeAll(() => {
+    instance = knex({ client: 'mysql', connection: { host: 'localhost', user: 'root', password: '' } });
+    // The dialect's own connection lifecycle, over a stub client library.
+    (instance as any).client.driver = { createConnection: silentConnection };
+    previousInstance = statics.KNEX;
+    statics.KNEX = instance;
+  });
+
+  afterAll(async () => {
+    statics.KNEX = previousInstance;
+    await instance.destroy();
+  });
+
+  beforeEach(() => {
+    unanswered.length = 0;
+    killed.length = 0;
+  });
+
+  /** A driver with `deadlineMs`, its failure lines kept off the test output. */
+  const driverWith = (deadlineMs: number) => {
+    const driver = new KnexDriver({ ...config, operationDeadlineMs: deadlineMs });
+    (driver as unknown as DriverInternals).logger = new Logger({
+      name: 'KnexDriver',
+      logWriter: { write: () => undefined } as any,
+    });
+    return driver;
+  };
+
+  test('the driver reports the deadline it is configured with, and 60 s when none is configured', () => {
+    expect(driverWith(500).getOperationDeadlineMs()).toBe(500);
+    expect(new KnexDriver(config).getOperationDeadlineMs()).toBe(60_000);
+  });
+
+  test('a statement the server never answers fails AT the deadline, naming it, and is cancelled on the server', async () => {
+    const driver = driverWith(500);
+
+    const before = Date.now();
+    await expect(driver.runQuery(statement)).rejects.toThrow(/Defined query timeout of 500ms exceeded/);
+    const elapsed = Date.now() - before;
+
+    expect(elapsed).toBeGreaterThanOrEqual(450);
+    expect(elapsed).toBeLessThan(3_000);
+    // The cancel named the connection the statement was left on.
+    expect(unanswered).toHaveLength(1);
+    expect(killed).toEqual(unanswered);
+  }, 10_000);
+
+  test('a statement inside a transaction runs under the same deadline, and the transaction fails with it', async () => {
+    const driver = driverWith(500);
+
+    const before = Date.now();
+    await expect(driver.runTransaction((transaction) => driver.runDml(statement, transaction))).rejects.toThrow(
+      /Defined query timeout of 500ms exceeded/
+    );
+
+    expect(Date.now() - before).toBeLessThan(3_000);
+    expect(unanswered).toHaveLength(1);
+    expect(killed).toEqual(unanswered);
+  }, 10_000);
+});

package/test/StatementLogNeverThrows.test.ts

@@ -1,6 +1,6 @@
 import knex from 'knex';
 import { inspect } from 'util';
-import { KnexDriver } from '@proteinjs/db-driver-knex';
+import { KnexDriver, KnexFailureLine } from '@proteinjs/db-driver-knex';
 import { Logger } from '@proteinjs/logger';
 import { CapturedLog, lineOf } from './util/printedLine';
 
@@ -12,7 +12,7 @@ import { CapturedLog, lineOf } from './util/printedLine';
  *
  * Two layers hold that, and this suite holds both:
  *
- *  - the helpers that build the line (`describeParams`, `causeSummary`) are TOTAL: whatever they
+ *  - the helpers that build the line (`describeParams`, `KnexFailureLine.causeOf`) are TOTAL: whatever they
  *    are handed — positional bindings, a bindings dictionary, nothing, null, a scalar, a Map, a
  *    value whose accessor or `toJSON` throws, a proxy that refuses everything — they return a
  *    description and never a value;
@@ -34,7 +34,6 @@ type ParamsDescription = ParamDescription[] | { [name: string]: ParamDescription
 type DriverInternals = {
   logger: Logger;
   describeParams: (params?: unknown) => ParamsDescription | undefined;
-  causeSummary: (error: unknown) => { [fact: string]: unknown };
 };
 type DriverStatics = { KNEX?: unknown };
 
@@ -164,13 +163,8 @@ describe('describeParams is total: any bindings, a description, never a value',
   });
 });
 
-describe('causeSummary is total: anything thrown, a summary of codes, never the rewritten message', () => {
-  const internals = new KnexDriver({
-    host: 'localhost',
-    user: 'root',
-    password: '',
-    dbName: 'test',
-  }) as unknown as DriverInternals;
+describe('KnexFailureLine.causeOf is total: anything thrown, a summary of codes and the driver`s sentence, never the vendor`s text', () => {
+  const UNNAMED = 'the database refused the statement';
   const vendorFacts = {
     code: 'ER_NO_SUCH_TABLE',
     errno: 1146,
@@ -182,27 +176,37 @@ describe('causeSummary is total: anything thrown, a summary of codes, never the
     [
       'a vendor error whose message and sql carry the bindings',
       () => Object.assign(new Error(`insert ... '${CANARY}'`), vendorFacts, { sql: `insert ... '${CANARY}'` }),
-      { name: 'Error', ...vendorFacts },
+      {
+        name: 'Error',
+        code: 'ER_NO_SUCH_TABLE',
+        errno: 1146,
+        sqlState: '42S02',
+        message: 'a table the statement names does not exist',
+      },
+    ],
+    ['nothing', () => undefined, { message: UNNAMED }],
+    ['null', () => null, { message: UNNAMED }],
+    ['a thrown string', () => CANARY, { message: UNNAMED }],
+    ['a thrown number', () => 1146, { message: UNNAMED }],
+    [
+      'facts of the wrong kind',
+      () => ({ name: 5, code: 1146, errno: '1146', sqlState: null, sqlMessage: {} }),
+      { message: UNNAMED },
     ],
-    ['nothing', () => undefined, {}],
-    ['null', () => null, {}],
-    ['a thrown string', () => CANARY, {}],
-    ['a thrown number', () => 1146, {}],
-    ['facts of the wrong kind', () => ({ name: 5, code: 1146, errno: '1146', sqlState: null, sqlMessage: {} }), {}],
     [
       'an error with a fact whose accessor throws',
       () => throwingEntry(Object.assign(new Error(CANARY), vendorFacts), 'code'),
-      { name: 'Error', errno: 1146, sqlState: '42S02', sqlMessage: vendorFacts.sqlMessage },
+      { name: 'Error', errno: 1146, sqlState: '42S02', message: UNNAMED },
     ],
-    ['an error that refuses every read', () => refusesEverything(new Error(CANARY)), {}],
-    ['a revoked error', () => revoked(new Error(CANARY)), {}],
+    ['an error that refuses every read', () => refusesEverything(new Error(CANARY)), { message: UNNAMED }],
+    ['a revoked error', () => revoked(new Error(CANARY)), { message: UNNAMED }],
   ];
 
   test.each(THROWN)('%s', (_shape, thrown, expected) => {
     let summary: { [fact: string]: unknown } | undefined;
 
     expect(() => {
-      summary = internals.causeSummary(thrown());
+      summary = KnexFailureLine.causeOf(thrown());
     }).not.toThrow();
 
     expect(summary).toEqual(expected);

package/test/StatementParamLogging.test.ts

@@ -14,8 +14,8 @@ import { CapturedLog, lineOf } from './util/printedLine';
  * The contract: the failure line carries the SQL text (placeholders only), the parameters
  * DESCRIBED — each one's position, the kind of its value and, for strings, arrays and bytes, its
  * length; one private helper (`describeParams`) owns that form — and a summary of the failure (the
- * error's name, the vendor's codes, the server's own message). The vendor error itself no longer
- * rides the line. (The dev-only switch that adds the values back is LogValuesSwitch.test.ts; it is
+ * error's name, the vendor's codes, the driver's own sentence — KnexFailureLine). The vendor error
+ * itself no longer rides the line. (The dev-only switch that adds the values back is LogValuesSwitch.test.ts; it is
  * off here.) A statement's bindings are typed as an array, but the query layer also accepts a
  * bindings DICTIONARY (`:name` placeholders) and the driver forwards what it was handed: a
  * dictionary is described by entry name. (Every other shape the driver can be handed, and a log
@@ -26,13 +26,10 @@ import { CapturedLog, lineOf } from './util/printedLine';
  * that prints what it catches still prints the interpolated SQL; that is the query layer's
  * behaviour and this contract does not change it.
  *
- * SCOPE, by name: this suite holds what the DRIVER prints of the parameters it was handed. It does
- * NOT hold the vendor-echo class — the server's own message can quote a bound value (`Duplicate
- * entry '…' for key 'PRIMARY'`), and that text reaches the line's cause summary and the thrown
- * error exactly as it did before. Closing that class means changing what the driver throws; that
- * work is parked on the branch `fix/driver-logs-never-carry-param-values`, pending a decision. So
- * the canaries below are bound to parameters the server does not echo, and the one value it does
- * echo — the colliding key — is left out of the assertions on purpose.
+ * SCOPE, by name: this suite holds what the DRIVER prints of the parameters it was handed. The
+ * vendor-echo class — the server's own message quoting a bound value (`Duplicate entry '…' for key
+ * 'PRIMARY'`) — is VendorTextNeverOnALine.test.ts: no line carries the server's message, and a
+ * caller's line about the error it caught carries the driver's sentence in its place.
  *
  * No server is needed: the REAL query layer and dialect run over a stub connection that rejects
  * the way the client library does (its own `format` builds the interpolated `sql`), so the
@@ -140,11 +137,10 @@ describe('The driver never prints a bound value; what it throws is the vendor`s
 
     const failures = captured.filter((log) => log.logLevel === 'error' && log.message === 'Failed when executing sql');
     expect(failures).toHaveLength(1);
-    // (`ECHOED_KEY` is NOT asserted: the server quotes the colliding key in its own message — the
-    // vendor-echo class this suite leaves out by name; see the header.)
     for (const log of captured) {
       expect(lineOf(log)).not.toContain(SECRET_TOKEN);
       expect(lineOf(log)).not.toContain(SECRET_EMAIL);
+      expect(lineOf(log)).not.toContain(ECHOED_KEY);
     }
     const [failure] = failures;
     expect(failure.obj.sql).toBe(INSERT);
@@ -160,7 +156,7 @@ describe('The driver never prints a bound value; what it throws is the vendor`s
       code: 'ER_DUP_ENTRY',
       errno: 1062,
       sqlState: '23000',
-      sqlMessage: `Duplicate entry '${ECHOED_KEY}' for key 'PRIMARY'`,
+      message: 'a row with that key already exists',
     });
     expect(Object.keys(failure.obj)).not.toContain('paramValues');
     // The vendor error itself — the carrier of the interpolated SQL — is not on the line.
@@ -188,11 +184,10 @@ describe('The driver never prints a bound value; what it throws is the vendor`s
     const failures = captured.filter((log) => log.logLevel === 'error');
     expect(failures).toHaveLength(1);
     expect(failures[0].obj.params).toEqual([{ type: 'string', length: SECRET_TOKEN.length }]);
-    // This statement's first binding IS the token, so the stub server echoes it: the summary's
-    // `sqlMessage` is the vendor-echo class. Everything else on the line is the driver's.
-    const { sqlMessage, ...ownFacts } = failures[0].obj.cause;
-    expect(sqlMessage).toContain(SECRET_TOKEN);
-    expect(lineOf({ ...failures[0], obj: { ...failures[0].obj, cause: ownFacts } })).not.toContain(SECRET_TOKEN);
+    // This statement's first binding IS the token, so the stub server echoes it in its own
+    // message — which no line carries.
+    expect(Object.keys(failures[0].obj.cause)).not.toContain('sqlMessage');
+    expect(lineOf(failures[0])).not.toContain(SECRET_TOKEN);
   });
 
   test('a failed statement inside a transaction: the same line, and the transaction rejects with the vendor`s error itself', async () => {

package/test/VendorTextNeverOnALine.test.ts

@@ -0,0 +1,257 @@
+import knex from 'knex';
+import { KnexDriver } from '@proteinjs/db-driver-knex';
+import { Logger } from '@proteinjs/logger';
+import { CapturedLog, lineOf } from './util/printedLine';
+
+/**
+ * The vendor's text never reaches a LOG LINE — the driver's own line, and any line a caller
+ * writes about the error it caught — while what the driver THROWS is the vendor's error itself,
+ * untouched (StatementParamLogging.test.ts holds that law; here the premise of every scenario is
+ * that the caught error still carries the values).
+ *
+ * The vendor error carries a statement's values three ways: the query layer rewrites its
+ * `message` to the SQL with every binding INTERPOLATED, the client library carries the same text
+ * as `sql`, and the server's own message quotes the value it refused (`Duplicate entry '<key>'
+ * for key 'PRIMARY'`). The driver's line never carried the first two; it did carry the third, and
+ * a caller that logged what it caught — whole, as a line's `error` or inside its `obj` — printed
+ * all three.
+ *
+ * So a line carries the vendor's CODES and the driver's own sentence. No server is needed: the
+ * REAL query layer and dialect run over a stub connection that rejects the way the client library
+ * does; lines are captured at the log WRITER and judged as the text a writer would print.
+ */
+
+// Fixture values shaped like the row content that must never be logged (none is a real credential).
+const SECRET_TOKEN = 'rst_5d41402abc4b2a76b9719d911017c592';
+const SECRET_EMAIL = 'casey.rivers@mail.example';
+const ECHOED_KEY = 'c0ffee00-0000-4000-8000-000000000001';
+const VALUES = [SECRET_TOKEN, SECRET_EMAIL, ECHOED_KEY];
+
+type DriverStatics = { KNEX?: unknown };
+
+/** What the stub's COMMIT answers with; nothing, unless a test says otherwise. */
+let commitRejection: (() => Error) | undefined;
+/** Whether the stub leaves every statement unanswered (a stuck server) instead of rejecting it. */
+let silentStatements = false;
+
+/** A connection that rejects every statement the way the client library does on a duplicate key. */
+const rejectingConnection = () => {
+  const mysql = require('mysql');
+  return {
+    state: 'authenticated',
+    on: () => undefined,
+    removeAllListeners: () => undefined,
+    connect: (done: (error?: Error) => void) => done(),
+    end: (done: (error?: Error) => void) => done(),
+    query: (options: { sql: string }, bindings: any[], done: (error: Error | null, rows?: unknown[]) => void) => {
+      if (/^\s*COMMIT/i.test(options.sql) && commitRejection) {
+        done(commitRejection());
+        return;
+      }
+      if (/^\s*(BEGIN|COMMIT|ROLLBACK)/i.test(options.sql)) {
+        done(null, []);
+        return;
+      }
+      if (/^\s*SELECT 1/i.test(options.sql)) {
+        done(null, [[{ 1: 1 }], []]);
+        return;
+      }
+      if (/^\s*KILL QUERY/i.test(options.sql)) {
+        done(null, []);
+        return;
+      }
+      if (silentStatements) {
+        return;
+      }
+      const sqlMessage = `Duplicate entry '${bindings[0]}' for key 'PRIMARY'`;
+      done(
+        Object.assign(new Error(`ER_DUP_ENTRY: ${sqlMessage}`), {
+          code: 'ER_DUP_ENTRY',
+          errno: 1062,
+          sqlState: '23000',
+          sqlMessage,
+          sql: mysql.format(options.sql, bindings),
+        })
+      );
+    },
+  };
+};
+
+const settle = <T>(promise: Promise<T>): Promise<any> =>
+  promise.then(() => 'resolved' as const).catch((error) => error);
+
+describe('the vendor`s text never reaches a log line; the thrown error still carries it', () => {
+  const driver = new KnexDriver({ host: 'localhost', user: 'root', password: '', dbName: 'test' });
+  const internals = driver as unknown as { logger: Logger };
+  const statics = KnexDriver as unknown as DriverStatics;
+  let captured: CapturedLog[] = [];
+  let instance: ReturnType<typeof knex>;
+  let previousInstance: unknown;
+  const capturing = (name: string) =>
+    new Logger({
+      name,
+      logLevel: 'debug',
+      logWriter: { write: (log: CapturedLog) => captured.push(log) } as any,
+    });
+  const callerLogger = capturing('ACaller');
+
+  beforeAll(() => {
+    instance = knex({ client: 'mysql', connection: { host: 'localhost', user: 'root', password: '' } });
+    (instance as any).client.driver = { createConnection: rejectingConnection };
+    previousInstance = statics.KNEX;
+    statics.KNEX = instance;
+    internals.logger = capturing('KnexDriver');
+  });
+
+  afterAll(async () => {
+    statics.KNEX = previousInstance;
+    await instance.destroy();
+  });
+
+  beforeEach(() => {
+    captured = [];
+    commitRejection = undefined;
+    silentStatements = false;
+  });
+
+  const INSERT = 'INSERT INTO `credential` (`id`, `email`, `token`, `attempts`, `cleared`) VALUES (?, ?, ?, ?, ?)';
+  const insertStatement = () => ({ sql: INSERT, params: [ECHOED_KEY, SECRET_EMAIL, SECRET_TOKEN, 3, null] });
+
+  /** The caller logs what it caught; no line — the driver's or the caller's — carries a value. */
+  const assertNeverOnALine = (caught: any) => {
+    callerLogger.error({ message: 'A caller`s own line about what it caught', error: caught });
+    callerLogger.warn({ message: 'A caller`s own line about what it caught', obj: { caught, list: [caught] } });
+
+    expect(captured.filter((log) => log.message === 'A caller`s own line about what it caught')).toHaveLength(2);
+    for (const log of captured) {
+      for (const value of VALUES) {
+        expect(lineOf(log)).not.toContain(value);
+      }
+    }
+  };
+
+  test('a failed statement: the caught error carries every value; the driver`s line and a caller`s lines carry the codes and the sentence', async () => {
+    const caught = await settle(driver.runDml(insertStatement));
+
+    // The premise: the vendor error, as thrown, carries the values all three ways.
+    expect(caught.message).toContain(SECRET_TOKEN);
+    expect(caught.sql).toContain(SECRET_EMAIL);
+    expect(caught.sqlMessage).toContain(ECHOED_KEY);
+
+    assertNeverOnALine(caught);
+    const [failure] = captured.filter((log) => log.message === 'Failed when executing sql');
+    expect(failure.obj.cause).toEqual({
+      name: 'Error',
+      code: 'ER_DUP_ENTRY',
+      errno: 1062,
+      sqlState: '23000',
+      message: 'a row with that key already exists',
+    });
+    const [callersLine] = captured.filter((log) => log.message === 'A caller`s own line about what it caught');
+    expect(callersLine.error.message).toBe(
+      'Failed when executing sql (ER_DUP_ENTRY, errno 1062): a row with that key already exists'
+    );
+    expect(callersLine.error).toMatchObject({ code: 'ER_DUP_ENTRY', errno: 1062, sqlState: '23000' });
+    expect(String(callersLine.error.stack).split('\n').length).toBeGreaterThan(1);
+  });
+
+  test.each([
+    ['DEVELOPMENT set AND DB_LOG_PARAM_VALUES=1', { DEVELOPMENT: 'true', DB_LOG_PARAM_VALUES: '1' }, true],
+    ['DEVELOPMENT unset, DB_LOG_PARAM_VALUES=1', { DB_LOG_PARAM_VALUES: '1' }, false],
+    ['DEVELOPMENT set, DB_LOG_PARAM_VALUES unset', { DEVELOPMENT: 'true' }, false],
+  ])(
+    'the vendor`s text rides a line only behind the dev-only values switch — %s',
+    async (_gate, env: { [name: string]: string }, open) => {
+      const before = { DEVELOPMENT: process.env.DEVELOPMENT, DB_LOG_PARAM_VALUES: process.env.DB_LOG_PARAM_VALUES };
+      delete process.env.DEVELOPMENT;
+      delete process.env.DB_LOG_PARAM_VALUES;
+      Object.assign(process.env, env);
+      try {
+        const caught = await settle(driver.runDml(insertStatement));
+        callerLogger.error({ message: 'A caller`s own line', error: caught });
+
+        const [callersLine] = captured.filter((log) => log.message === 'A caller`s own line');
+        const [failure] = captured.filter((log) => log.message === 'Failed when executing sql');
+        if (open) {
+          expect(callersLine.error).toBe(caught);
+          expect(failure.obj.cause.sqlMessage).toContain(ECHOED_KEY);
+        } else {
+          expect(callersLine.error).not.toBe(caught);
+          expect(Object.keys(failure.obj.cause)).not.toContain('sqlMessage');
+          for (const log of captured) {
+            expect(lineOf(log)).not.toContain(ECHOED_KEY);
+          }
+        }
+      } finally {
+        for (const [name, value] of Object.entries(before)) {
+          if (value === undefined) {
+            delete process.env[name];
+          } else {
+            process.env[name] = value;
+          }
+        }
+      }
+    }
+  );
+
+  test('a statement past the driver`s deadline: the caught error carries the bound values; every line says the statement timed out, and carries none', async () => {
+    const timedOut = 'the statement or its wait for a connection timed out';
+    silentStatements = true;
+    const deadlined = new KnexDriver({
+      host: 'localhost',
+      user: 'root',
+      password: '',
+      dbName: 'test',
+      operationDeadlineMs: 300,
+    });
+    (deadlined as unknown as { logger: Logger }).logger = capturing('KnexDriver');
+
+    const caught = await settle(deadlined.runDml(insertStatement));
+
+    // The premise: the query layer's timeout error, as thrown, names the deadline and carries the bindings.
+    expect(caught.name).toBe('KnexTimeoutError');
+    expect(caught.message).toMatch(/Defined query timeout of 300ms exceeded/);
+    expect(caught.bindings).toContain(SECRET_TOKEN);
+
+    assertNeverOnALine(caught);
+    const [failure] = captured.filter((log) => log.message === 'Failed when executing sql');
+    expect(failure.obj.cause).toEqual({ name: 'KnexTimeoutError', message: timedOut });
+    const [callersLine] = captured.filter((log) => log.message === 'A caller`s own line about what it caught');
+    expect(callersLine.error.name).toBe('KnexTimeoutError');
+    expect(callersLine.error.message).toBe(`Failed when executing sql: ${timedOut}`);
+  }, 10_000);
+
+  test('the same inside a transaction', async () => {
+    const caught = await settle(driver.runTransaction((transaction) => driver.runDml(insertStatement, transaction)));
+
+    expect(caught.message).toContain(SECRET_TOKEN);
+    assertNeverOnALine(caught);
+  });
+
+  test('a commit the server refuses leaves through the transaction`s door, marked there; a caller`s own error thrown in the body prints as it is', async () => {
+    commitRejection = () =>
+      Object.assign(new Error(`ER_DUP_ENTRY: Duplicate entry '${ECHOED_KEY}' for key 'email'`), {
+        code: 'ER_DUP_ENTRY',
+        errno: 1062,
+        sqlState: '23000',
+        sqlMessage: `Duplicate entry '${ECHOED_KEY}' for key 'email'`,
+      });
+    const refusedCommit = await settle(driver.runTransaction(async () => 'the body ran clean'));
+
+    expect(String(refusedCommit.message)).toContain(ECHOED_KEY);
+    assertNeverOnALine(refusedCommit);
+
+    captured = [];
+    commitRejection = undefined;
+    const callersOwn = new Error('The order is already closed');
+    const outcome = await settle(
+      driver.runTransaction(async () => {
+        throw callersOwn;
+      })
+    );
+    callerLogger.error({ message: 'A caller`s own line', error: outcome });
+
+    expect(outcome).toBe(callersOwn);
+    expect(captured[0].error).toBe(callersOwn);
+  });
+});