node-firebird 2.11.0 → 2.12.0

package/lib/wire/transaction.js

@@ -6,6 +6,8 @@ const callback_1 = require("../callback");
 const named_params_1 = require("../named-params");
 const utils_1 = require("../utils");
 const const_1 = __importDefault(require("./const"));
+const sql_template_1 = require("../sql-template");
+const xsqlvar_1 = require("./xsqlvar");
 const query_stream_1 = __importDefault(require("./query-stream"));
 /***************************************
  *
@@ -44,9 +46,73 @@ function hookAbortSignal(connection, signal, callback) {
 }
 class Transaction {
     constructor(connection) {
+        /** Current savepoint nesting depth (names savepoints, see savepoint()). */
+        this._savepointDepth = 0;
         this.connection = connection;
         this.db = connection.db;
     }
+    /**
+     * Tagged-template query API: tx.sql`SELECT ... ${value}` (see README).
+     * Built lazily — transactions are created per-query internally, and
+     * those throwaway instances must not pay for the tag. The compiled text
+     * is positional-only, so the namedPlaceholders rewriter is disabled:
+     * any `:token` in the template is PSQL (EXECUTE BLOCK), not a
+     * placeholder.
+     */
+    get sql() {
+        return this._sql || (this._sql = (0, sql_template_1.makeSqlTag)((text, params, options) => this.queryAsync(text, params, { ...options, namedPlaceholders: false })));
+    }
+    /**
+     * Run `work` inside a savepoint (Firebird 1.5+): on resolve the
+     * savepoint is released, on reject the transaction rolls back TO the
+     * savepoint — undoing only work's changes — and the error is rethrown,
+     * leaving the transaction itself usable. Nestable (each call generates
+     * a fresh NF_SP_n name), mirroring db.withTransaction's style and
+     * Postgres.js's sql.savepoint().
+     *
+     * Do NOT run sibling savepoints concurrently on one transaction
+     * (Promise.all): Firebird's RELEASE SAVEPOINT also releases every
+     * savepoint created after it, so interleaved siblings release each
+     * other. Nested (awaited) savepoints are fine.
+     */
+    async savepoint(work) {
+        if (typeof work !== 'function') {
+            throw new Error('savepoint(work) expects a function');
+        }
+        // named by nesting depth, not a global counter: sequential
+        // savepoints at the same depth reuse the same three SQL strings, so
+        // the statement cache serves them instead of accumulating
+        // single-use entries (redefining a released savepoint name is legal)
+        const name = 'NF_SP_' + (++this._savepointDepth);
+        try {
+            await this.queryAsync('SAVEPOINT ' + name);
+            let result;
+            try {
+                result = await work(this);
+            }
+            catch (err) {
+                // only a work() failure rolls back to the savepoint — a
+                // RELEASE failure below must NOT undo work's successful
+                // changes
+                try {
+                    await this.queryAsync('ROLLBACK TO SAVEPOINT ' + name);
+                }
+                catch (rollbackErr) {
+                    // the original failure matters more; keep the rollback
+                    // failure attached for diagnosis
+                    if (err && typeof err === 'object') {
+                        err.savepointRollbackError = rollbackErr;
+                    }
+                }
+                throw err;
+            }
+            await this.queryAsync('RELEASE SAVEPOINT ' + name);
+            return result;
+        }
+        finally {
+            this._savepointDepth--;
+        }
+    }
     /** Per-call options.namedPlaceholders overrides the connection option. */
     namedPlaceholdersEnabled(options) {
         if (options && options.namedPlaceholders !== undefined)
@@ -116,6 +182,66 @@ class Transaction {
                     dropError(err);
                     return;
                 }
+                // withMeta applies to query/execute only: in streaming mode
+                // (sequentially/queryStream, which spread user options) rows
+                // bypass fetchAll's array, so a result object here would
+                // carry rows: [] and a meaningless affectedRows
+                var withMeta = Boolean(options && typeof options === 'object' &&
+                    options.withMeta && !options.asStream);
+                // Deliver the historic result shape, or — when options.withMeta
+                // is set — request the per-verb DML row counts while the
+                // statement handle is still open and wrap everything in a
+                // { rows, fields, affectedRows, recordCounts, warnings } object.
+                function deliver(rows, isSelect, plainDml) {
+                    if (!withMeta) {
+                        statement.release();
+                        if (callback) {
+                            if (plainDml) {
+                                // plain DML historically calls back with no args
+                                callback();
+                            }
+                            else {
+                                callback(undefined, rows, statement.output, isSelect);
+                            }
+                        }
+                        return;
+                    }
+                    var execWarnings = (ret && ret.warnings) || [];
+                    var finalize = function (counts) {
+                        statement.release();
+                        if (!callback) {
+                            return;
+                        }
+                        // DML: what the server actually changed; SELECT: rows
+                        // returned (pg's rowCount convention)
+                        var affectedRows = counts
+                            ? counts.insertCount + counts.updateCount + counts.deleteCount
+                            : (Array.isArray(rows) ? rows.length : (rows !== undefined ? 1 : 0));
+                        callback(undefined, {
+                            rows: rows,
+                            fields: (0, xsqlvar_1.describeFields)(statement.output),
+                            affectedRows: affectedRows,
+                            recordCounts: counts,
+                            warnings: execWarnings,
+                        }, statement.output, isSelect);
+                    };
+                    var t = statement.type;
+                    var isDml = t === const_1.default.isc_info_sql_stmt_insert ||
+                        t === const_1.default.isc_info_sql_stmt_update ||
+                        t === const_1.default.isc_info_sql_stmt_delete ||
+                        t === const_1.default.isc_info_sql_stmt_exec_procedure;
+                    if (!isDml) {
+                        finalize();
+                        return;
+                    }
+                    self.connection.statementInfo(statement, const_1.default.RECORDS_INFO, function (err, info) {
+                        if (err) {
+                            dropError(err);
+                            return;
+                        }
+                        finalize((0, xsqlvar_1.parseRecordCounts)(info && info.buffer));
+                    });
+                }
                 switch (statement.type) {
                     case const_1.default.isc_info_sql_stmt_select:
                         statement.fetchAll(self, function (err, r) {
@@ -123,35 +249,27 @@ class Transaction {
                                 dropError(err);
                                 return;
                             }
-                            statement.release();
-                            if (callback)
-                                callback(undefined, r, statement.output, true);
+                            deliver(r, true);
                         });
                         break;
                     case const_1.default.isc_info_sql_stmt_exec_procedure:
                         if (ret && ret.data && ret.data.length > 0) {
-                            statement.release();
-                            if (callback)
-                                callback(undefined, ret.data[0], statement.output, true);
+                            deliver(ret.data[0], true);
                             break;
                         }
                         else if (statement.output.length) {
-                            statement.fetch(self, 1, function (err, ret) {
+                            statement.fetch(self, 1, function (err, fret) {
                                 if (err) {
                                     dropError(err);
                                     return;
                                 }
-                                statement.release();
-                                if (callback)
-                                    callback(undefined, ret.data[0], statement.output, false);
+                                deliver(fret.data[0], false);
                             });
                             break;
                         }
                     // Fall through is normal
                     default:
-                        statement.release();
-                        if (callback)
-                            callback();
+                        deliver(undefined, false, true);
                         break;
                 }
             }, options);

package/lib/wire/xsqlvar.d.ts

@@ -1,4 +1,5 @@
 import type { XdrReader, XdrWriter, BlrWriter } from './serialize';
+import type { RecordCounts } from '../types';
 /**
  * Common shape of all SQLVar descriptor objects.  The metadata properties
  * are populated externally (in connection.ts) from the op_prepare_statement
@@ -41,7 +42,23 @@ export interface ColumnKey {
  * decoder and by fetchBlobSyncRow, which must agree on where each column
  * landed in the row.
  */
-export declare function computeColumnKeys(output: SQLVarBase[], nestTables: boolean | string | undefined, lowercaseKeys: boolean | undefined): ColumnKey[];
+export declare function computeColumnKeys(output: SQLVarBase[], nestTables: boolean | string | undefined, lowercaseKeys: boolean | undefined, transform?: (key: string) => string): ColumnKey[];
+/** transformKeys option value: the built-in 'camel', or a custom mapper. */
+export type KeyTransform = 'camel' | ((key: string) => string);
+/** FIRST_NAME → firstName (the transformKeys: 'camel' built-in). */
+export declare function camelizeKey(key: string): string;
+/**
+ * Resolve the effective transformKeys value (per-query wins over the
+ * connection option) into a callable mapper, or undefined when off.
+ * A custom mapper is guarded like the typeCast hook: a throw inside the
+ * row-decode loop would be mistaken for an incomplete packet and desync
+ * the response queue, so failures fall back to the untransformed key.
+ */
+export declare function resolveKeyTransform(queryOptions: {
+    transformKeys?: KeyTransform;
+} | undefined, connectionOptions: {
+    transformKeys?: KeyTransform;
+} | undefined): ((key: string) => string) | undefined;
 /**
  * Resolve the effective nestTables value: the per-query option wins over
  * the connection option. The decoder and fetchBlobSyncRow both use this —
@@ -60,6 +77,50 @@ export declare function resolveNestTables(queryOptions: {
  * cell by ColumnKey must resolve it through here.
  */
 export declare function nestCell(row: any, table: string | undefined): any;
+/** Human-readable names for the SQL_* wire type codes. */
+export declare const SQL_TYPE_NAMES: Record<number, string>;
+/**
+ * Public column-metadata shape for one output descriptor: the vocabulary
+ * both the typeCast hook and withMeta `fields` deliver. Keep the two in
+ * lockstep by building both through here.
+ */
+export declare function describeField(meta: Partial<SQLVarBase>): {
+    type: number;
+    typeName: string;
+    subType: number | undefined;
+    scale: number | undefined;
+    length: number | undefined;
+    nullable: boolean | undefined;
+    field: string | undefined;
+    relation: string | undefined;
+    relationAlias: string | undefined;
+    relationSchema: string | undefined;
+    alias: string | undefined;
+};
+/**
+ * Map a statement's output descriptors to the column-metadata array
+ * delivered in withMeta results ({ rows, fields, ... }).
+ */
+export declare function describeFields(output: SQLVarBase[]): {
+    type: number;
+    typeName: string;
+    subType: number | undefined;
+    scale: number | undefined;
+    length: number | undefined;
+    nullable: boolean | undefined;
+    field: string | undefined;
+    relation: string | undefined;
+    relationAlias: string | undefined;
+    relationSchema: string | undefined;
+    alias: string | undefined;
+}[];
+/**
+ * Parse the op_info_sql response buffer of a Const.RECORDS_INFO request
+ * into per-verb row counts. The buffer holds an isc_info_sql_records
+ * cluster (2-byte total length, then nested isc_info_req_*_count items,
+ * each 2-byte length + little-endian integer) terminated by isc_info_end.
+ */
+export declare function parseRecordCounts(buffer: Buffer | undefined): RecordCounts;
 export declare class SQLVarText extends SQLVarBase {
     decode(data: XdrReader, lowerV13: boolean, options?: any): string | Buffer<ArrayBufferLike> | null | undefined;
     calcBlr(blr: BlrWriter): void;

package/lib/wire/xsqlvar.js

@@ -3,12 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLParamBool = exports.SQLParamDate = exports.SQLParamQuad = exports.SQLParamBuffer = exports.SQLParamString = exports.SQLParamDouble = exports.SQLParamDecFloat34 = exports.SQLParamDecFloat16 = exports.SQLParamInt128 = exports.SQLParamInt64 = exports.SQLParamInt = exports.SQLVarBoolean = exports.SQLVarTimeStampTzEx = exports.SQLVarTimeStampTz = exports.SQLVarTimeTzEx = exports.SQLVarTimeTz = exports.SQLVarTimeStamp = exports.SQLVarTime = exports.SQLVarDate = exports.SQLVarDouble = exports.SQLVarFloat = exports.SQLVarDecFloat34 = exports.SQLVarDecFloat16 = exports.SQLVarInt128 = exports.SQLVarInt64 = exports.SQLVarShort = exports.SQLVarInt = exports.SQLVarArray = exports.SQLVarBlob = exports.SQLVarQuad = exports.SQLVarString = exports.SQLVarNull = exports.SQLVarText = exports.SQLVarBase = void 0;
+exports.SQLParamBool = exports.SQLParamDate = exports.SQLParamQuad = exports.SQLParamBuffer = exports.SQLParamString = exports.SQLParamDouble = exports.SQLParamDecFloat34 = exports.SQLParamDecFloat16 = exports.SQLParamInt128 = exports.SQLParamInt64 = exports.SQLParamInt = exports.SQLVarBoolean = exports.SQLVarTimeStampTzEx = exports.SQLVarTimeStampTz = exports.SQLVarTimeTzEx = exports.SQLVarTimeTz = exports.SQLVarTimeStamp = exports.SQLVarTime = exports.SQLVarDate = exports.SQLVarDouble = exports.SQLVarFloat = exports.SQLVarDecFloat34 = exports.SQLVarDecFloat16 = exports.SQLVarInt128 = exports.SQLVarInt64 = exports.SQLVarShort = exports.SQLVarInt = exports.SQLVarArray = exports.SQLVarBlob = exports.SQLVarQuad = exports.SQLVarString = exports.SQLVarNull = exports.SQLVarText = exports.SQL_TYPE_NAMES = exports.SQLVarBase = void 0;
 exports.computeColumnKeys = computeColumnKeys;
+exports.camelizeKey = camelizeKey;
+exports.resolveKeyTransform = resolveKeyTransform;
 exports.resolveNestTables = resolveNestTables;
 exports.nestCell = nestCell;
+exports.describeField = describeField;
+exports.describeFields = describeFields;
+exports.parseRecordCounts = parseRecordCounts;
 exports.encodeDateTimeParts = encodeDateTimeParts;
 const const_1 = __importDefault(require("./const"));
+const serialize_1 = require("./serialize");
 /***************************************
  *
  *   SQLVar
@@ -84,12 +90,15 @@ exports.SQLVarBase = SQLVarBase;
  * decoder and by fetchBlobSyncRow, which must agree on where each column
  * landed in the row.
  */
-function computeColumnKeys(output, nestTables, lowercaseKeys) {
+function computeColumnKeys(output, nestTables, lowercaseKeys, transform) {
     return output.map((column) => {
         let key = column.alias || '';
         if (lowercaseKeys) {
             key = key.toLowerCase();
         }
+        if (transform) {
+            key = transform(key);
+        }
         if (nestTables !== true && typeof nestTables !== 'string') {
             return { key };
         }
@@ -97,12 +106,63 @@ function computeColumnKeys(output, nestTables, lowercaseKeys) {
         if (lowercaseKeys) {
             table = table.toLowerCase();
         }
+        if (transform) {
+            table = transform(table);
+        }
         if (nestTables === true) {
             return { table, key };
         }
         return { key: table + nestTables + key };
     });
 }
+/** FIRST_NAME → firstName (the transformKeys: 'camel' built-in). */
+function camelizeKey(key) {
+    const parts = String(key).toLowerCase().split('_');
+    let out = parts[0] || '';
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        if (part) {
+            out += part.charAt(0).toUpperCase() + part.slice(1);
+        }
+    }
+    return out;
+}
+/**
+ * Resolve the effective transformKeys value (per-query wins over the
+ * connection option) into a callable mapper, or undefined when off.
+ * A custom mapper is guarded like the typeCast hook: a throw inside the
+ * row-decode loop would be mistaken for an incomplete packet and desync
+ * the response queue, so failures fall back to the untransformed key.
+ */
+function resolveKeyTransform(queryOptions, connectionOptions) {
+    const value = resolveQueryOption('transformKeys', queryOptions, connectionOptions);
+    if (value === 'camel') {
+        return camelizeKey;
+    }
+    if (typeof value !== 'function') {
+        return undefined;
+    }
+    return (key) => {
+        try {
+            return String(value(key));
+        }
+        catch (err) {
+            console.warn('[node-firebird] transformKeys mapper threw for key "%s": %s — using the untransformed key', key, err && err.message);
+            return key;
+        }
+    };
+}
+/**
+ * Shared precedence rule for per-query-overridable connection options:
+ * the per-query value wins whenever it is present (even if falsy), the
+ * connection option applies otherwise.
+ */
+function resolveQueryOption(name, queryOptions, connectionOptions) {
+    if (queryOptions && queryOptions[name] !== undefined) {
+        return queryOptions[name];
+    }
+    return connectionOptions ? connectionOptions[name] : undefined;
+}
 /**
  * Resolve the effective nestTables value: the per-query option wins over
  * the connection option. The decoder and fetchBlobSyncRow both use this —
@@ -110,10 +170,7 @@ function computeColumnKeys(output, nestTables, lowercaseKeys) {
  * up in the wrong place.
  */
 function resolveNestTables(queryOptions, connectionOptions) {
-    if (queryOptions && queryOptions.nestTables !== undefined) {
-        return queryOptions.nestTables;
-    }
-    return connectionOptions && connectionOptions.nestTables;
+    return resolveQueryOption('nestTables', queryOptions, connectionOptions);
 }
 /**
  * The object a column's value lives in: the row itself, or — when the
@@ -128,6 +185,108 @@ function nestCell(row, table) {
     return row[table] || (row[table] = {});
 }
 //------------------------------------------------------
+/** Human-readable names for the SQL_* wire type codes. */
+exports.SQL_TYPE_NAMES = {
+    [const_1.default.SQL_TEXT]: 'TEXT',
+    [const_1.default.SQL_VARYING]: 'VARYING',
+    [const_1.default.SQL_SHORT]: 'SHORT',
+    [const_1.default.SQL_LONG]: 'LONG',
+    [const_1.default.SQL_FLOAT]: 'FLOAT',
+    [const_1.default.SQL_DOUBLE]: 'DOUBLE',
+    [const_1.default.SQL_D_FLOAT]: 'D_FLOAT',
+    [const_1.default.SQL_TIMESTAMP]: 'TIMESTAMP',
+    [const_1.default.SQL_BLOB]: 'BLOB',
+    [const_1.default.SQL_ARRAY]: 'ARRAY',
+    [const_1.default.SQL_QUAD]: 'QUAD',
+    [const_1.default.SQL_TYPE_TIME]: 'TIME',
+    [const_1.default.SQL_TYPE_DATE]: 'DATE',
+    [const_1.default.SQL_INT64]: 'INT64',
+    [const_1.default.SQL_INT128]: 'INT128',
+    [const_1.default.SQL_TIMESTAMP_TZ]: 'TIMESTAMP_TZ',
+    [const_1.default.SQL_TIMESTAMP_TZ_EX]: 'TIMESTAMP_TZ_EX',
+    [const_1.default.SQL_TIME_TZ]: 'TIME_TZ',
+    [const_1.default.SQL_TIME_TZ_EX]: 'TIME_TZ_EX',
+    [const_1.default.SQL_DEC16]: 'DEC16',
+    [const_1.default.SQL_DEC34]: 'DEC34',
+    [const_1.default.SQL_BOOLEAN]: 'BOOLEAN',
+    [const_1.default.SQL_NULL]: 'NULL',
+};
+/**
+ * Public column-metadata shape for one output descriptor: the vocabulary
+ * both the typeCast hook and withMeta `fields` deliver. Keep the two in
+ * lockstep by building both through here.
+ */
+function describeField(meta) {
+    return {
+        type: meta.type,
+        typeName: exports.SQL_TYPE_NAMES[meta.type] || 'UNKNOWN',
+        subType: meta.subType,
+        scale: meta.scale,
+        length: meta.length,
+        nullable: meta.nullable,
+        field: meta.field,
+        relation: meta.relation,
+        relationAlias: meta.relationAlias,
+        relationSchema: meta.relationSchema,
+        alias: meta.alias,
+    };
+}
+/**
+ * Map a statement's output descriptors to the column-metadata array
+ * delivered in withMeta results ({ rows, fields, ... }).
+ */
+function describeFields(output) {
+    return (output || []).map(describeField);
+}
+/**
+ * Parse the op_info_sql response buffer of a Const.RECORDS_INFO request
+ * into per-verb row counts. The buffer holds an isc_info_sql_records
+ * cluster (2-byte total length, then nested isc_info_req_*_count items,
+ * each 2-byte length + little-endian integer) terminated by isc_info_end.
+ */
+function parseRecordCounts(buffer) {
+    const counts = { selectCount: 0, insertCount: 0, updateCount: 0, deleteCount: 0 };
+    if (!buffer || !buffer.length) {
+        return counts;
+    }
+    // this runs inside a response callback — a malformed/truncated buffer
+    // must yield partial counts, never a throw
+    try {
+        const br = new serialize_1.BlrReader(buffer);
+        while (br.pos < br.buffer.length) {
+            const item = br.readByteCode();
+            if (item === const_1.default.isc_info_end || item === const_1.default.isc_info_truncated) {
+                break;
+            }
+            if (item === const_1.default.isc_info_sql_records) {
+                br.pos += 2; // skip the cluster's total length; nested items follow
+                continue;
+            }
+            switch (item) {
+                case const_1.default.isc_info_req_select_count:
+                    counts.selectCount = br.readInt() || 0;
+                    break;
+                case const_1.default.isc_info_req_insert_count:
+                    counts.insertCount = br.readInt() || 0;
+                    break;
+                case const_1.default.isc_info_req_update_count:
+                    counts.updateCount = br.readInt() || 0;
+                    break;
+                case const_1.default.isc_info_req_delete_count:
+                    counts.deleteCount = br.readInt() || 0;
+                    break;
+                default:
+                    // unknown item: its 2-byte length prefix tells us how far to skip
+                    br.pos += 2 + br.buffer.readUInt16LE(br.pos);
+            }
+        }
+    }
+    catch (e) {
+        // fall through with whatever was parsed so far
+    }
+    return counts;
+}
+//------------------------------------------------------
 class SQLVarText extends SQLVarBase {
     decode(data, lowerV13, options) {
         let ret;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-firebird",
-    "version": "2.11.0",
+    "version": "2.12.0",
     "description": "Pure JavaScript and Asynchronous Firebird client for Node.js.",
     "keywords": [
         "firebird",

package/src/pool.ts

@@ -26,7 +26,12 @@ type AttachFn = (options: any, callback: Callback) => void;
  *
  * Options: max (factory argument), options.min (floor the reaper never
  * shrinks below), options.idleTimeoutMillis (close idle connections after
- * this many ms; 0/absent = never), options.connectTimeout.
+ * this many ms; 0/absent = never), options.connectTimeout,
+ * options.maxUses (retire a connection after this many checkouts — pg's
+ * maxUses), options.maxLifetimeMillis (retire a connection this many ms
+ * after it was created — Postgres.js's max_lifetime). Retirement happens
+ * when the connection is returned to the pool, and the sweep also closes
+ * over-lifetime idle connections; a replacement is created on demand.
  */
 class Pool extends Events.EventEmitter {
     attach: AttachFn;
@@ -37,6 +42,8 @@ class Pool extends Events.EventEmitter {
     max: number;
     min: number;
     idleTimeoutMillis: number;
+    maxUses: number;
+    maxLifetimeMillis: number;
     pending: Callback[];
     options: any;
     _destroyed: boolean;
@@ -52,22 +59,50 @@ class Pool extends Events.EventEmitter {
         this.max       = max || 4;
         this.min       = (options && options.min > 0) ? Math.min(options.min, this.max) : 0;
         this.idleTimeoutMillis = (options && options.idleTimeoutMillis > 0) ? options.idleTimeoutMillis : 0;
+        this.maxUses = (options && options.maxUses > 0) ? options.maxUses : 0;
+        this.maxLifetimeMillis = (options && options.maxLifetimeMillis > 0) ? options.maxLifetimeMillis : 0;
         this.pending   = []; // callbacks waiting for a free slot
         this.options   = options;
         this._destroyed = false; // true after destroy() — prevents further use
         this._reaper   = null;
 
-        if (this.idleTimeoutMillis) {
+        // the sweep serves both idle eviction and lifetime retirement of
+        // idle connections; base its cadence on the tightest configured limit
+        var sweepBasis = Math.min(this.idleTimeoutMillis || Infinity, this.maxLifetimeMillis || Infinity);
+        if (sweepBasis !== Infinity) {
             var self = this;
-            // Sweep at half the idle timeout (bounded to 100ms..30s) so a
-            // connection lives at most ~1.5x idleTimeoutMillis. unref() keeps
+            // Sweep at half the basis (bounded to 100ms..30s) so a
+            // connection lives at most ~1.5x its limit. unref() keeps
             // the timer from holding the process open.
-            var interval = Math.min(Math.max(this.idleTimeoutMillis / 2, 100), 30000);
+            var interval = Math.min(Math.max(sweepBasis / 2, 100), 30000);
             this._reaper = setInterval(function() { self._reap(); }, interval);
             if (this._reaper.unref) this._reaper.unref();
         }
     }
 
+    /** True when the connection exceeded maxUses / maxLifetimeMillis.
+     *  Both stamps are set unconditionally when the pool creates the
+     *  connection, so they can be read bare here. */
+    _isExpired(db: any): boolean {
+        if (this.maxUses > 0 && db.__poolUseCount >= this.maxUses) return true;
+        if (this.maxLifetimeMillis > 0 && Date.now() - db.__poolCreatedAt >= this.maxLifetimeMillis) return true;
+        return false;
+    }
+
+    /** Close a healthy pooled connection for good (reaper/retirement path). */
+    _retire(db: any): void {
+        var self = this;
+        this._forget(db);
+        db.connection._pooled = false;
+        try {
+            db.detach(function(err?: any) {
+                if (err) self._emitError(err, db);
+            });
+        } catch (e) {
+            self._emitError(e, db);
+        }
+    }
+
     /** Physical connections owned by the pool (idle + in use). */
     get totalCount(): number {
         return this.internaldb.length;
@@ -124,19 +159,18 @@ class Pool extends Events.EventEmitter {
                 self._forget(db);
                 return;
             }
+            // lifetime retirement applies even below min — recycling is the
+            // point; replacements are created on demand
+            if (self._isExpired(db)) {
+                self._retire(db);
+                return;
+            }
+            if (!self.idleTimeoutMillis) return;
             if (self.internaldb.length <= self.min) return;
             var idleSince = typeof db.__poolIdleSince === 'number' ? db.__poolIdleSince : now;
             if (now - idleSince < self.idleTimeoutMillis) return;
 
-            self._forget(db);
-            db.connection._pooled = false;
-            try {
-                db.detach(function(err?: any) {
-                    if (err) self._emitError(err, db);
-                });
-            } catch (e) {
-                self._emitError(e, db);
-            }
+            self._retire(db);
         });
     }
 
@@ -175,6 +209,7 @@ class Pool extends Events.EventEmitter {
             }
             // Idle connection available — hand it out immediately.
             self.dbinuse++;
+            db.__poolUseCount = (db.__poolUseCount || 0) + 1;
             self.emit('acquire', db);
             cb(null, db);
         } else {
@@ -235,6 +270,8 @@ class Pool extends Events.EventEmitter {
 
                 if (!err) {
                     self.dbinuse++;
+                    db.__poolCreatedAt = Date.now();
+                    db.__poolUseCount = 1;
                     self.internaldb.push(db);
                     db.on('detach', function () {
                         // also in pool (could be a twice call to detach)
@@ -244,6 +281,12 @@ class Pool extends Events.EventEmitter {
                         if (db.connection._isClosed || db.connection._isDetach || db.connection._pooled === false) {
                             self.internaldb.splice(self.internaldb.indexOf(db), 1);
                             self.emit('remove', db);
+                        } else if (self._isExpired(db)) {
+                            // worn out (maxUses / maxLifetimeMillis): close it
+                            // for good instead of returning it to the idle
+                            // pool. The re-fired detach event exits early via
+                            // the internaldb guard above.
+                            self._retire(db);
                         } else {
                             db.__poolIdleSince = Date.now();
                             self.pooldb.push(db);