node-firebird 2.9.0 → 2.10.0

package/lib/wire/statement.d.ts

@@ -3,13 +3,21 @@
  *   Statement
  *
  ***************************************/
+import { type Callback, type SimpleCallback } from '../callback';
+import type Connection from './connection';
+import type Transaction from './transaction';
+import type { SQLVarBase } from './xsqlvar';
+import type { QueryOptions, QueryParams } from '../types';
 declare class Statement {
-    connection: any;
+    connection: Connection;
     query: string;
     type: number;
-    output: any[];
-    input: any[];
-    options: any;
+    output: SQLVarBase[];
+    input: SQLVarBase[];
+    /** per-execute query options (asObject/asStream/timeout/...) */
+    options: (QueryOptions & {
+        [key: string]: any;
+    }) | undefined;
     handle: number;
     plan: string;
     /**
@@ -18,27 +26,31 @@ declare class Statement {
      * null/undefined otherwise. Set by Transaction.newStatement.
      */
     namedParams?: string[] | null;
-    [key: string]: any;
-    constructor(connection: any);
-    close(callback?: (err?: any) => void): void;
-    drop(callback?: (err?: any) => void): void;
-    release(callback?: (err?: any) => void): void;
-    execute(transaction: any, params?: any, callback?: any, options?: any): void;
-    fetch(transaction: any, count: number | string, callback: (err: any, result?: any) => void): void;
-    fetchScroll(transaction: any, direction: string | number, offset?: any, count?: any, callback?: any): void;
-    fetchAll(transaction: any, callback: (err: any, result?: any) => void): void;
+    /** set when an execute/fetch on this statement errored — the statement
+     *  is dropped on release instead of going back into the cache */
+    _failed?: boolean;
+    /** rows fetched so far by the current cursor (decodeResponse) */
+    nbrowsfetched?: number;
+    constructor(connection: Connection);
+    close(callback?: SimpleCallback): void;
+    drop(callback?: SimpleCallback): void;
+    release(callback?: SimpleCallback): void;
+    execute(transaction: Transaction, params?: any, callback?: any, options?: any): void;
+    fetch(transaction: Transaction, count: number | string, callback: Callback): void;
+    fetchScroll(transaction: Transaction, direction: string | number, offset?: any, count?: any, callback?: any): void;
+    fetchAll(transaction: Transaction, callback: Callback): void;
     /**
      * Execute this statement once per row via the Firebird 4 batch API
      * (protocol 16+). `rows` is an array of parameter arrays — or, when the
      * statement was prepared with named placeholders, of values-by-name
      * objects (the two forms can be mixed).
      */
-    executeBatch(transaction: any, rows: any[][], callback?: any, options?: any): void;
-    executeAsync(transaction: any, params?: any, options?: any): Promise<any>;
-    executeBatchAsync(transaction: any, rows: any[][], options?: any): Promise<any>;
-    fetchAsync(transaction: any, count: number | string): Promise<any>;
-    fetchScrollAsync(transaction: any, direction: string | number, offset?: any, count?: any): Promise<any>;
-    fetchAllAsync(transaction: any): Promise<any>;
+    executeBatch(transaction: Transaction, rows: QueryParams[], callback?: any, options?: any): void;
+    executeAsync(transaction: Transaction, params?: any, options?: any): Promise<any>;
+    executeBatchAsync(transaction: Transaction, rows: QueryParams[], options?: any): Promise<any>;
+    fetchAsync(transaction: Transaction, count: number | string): Promise<any>;
+    fetchScrollAsync(transaction: Transaction, direction: string | number, offset?: any, count?: any): Promise<any>;
+    fetchAllAsync(transaction: Transaction): Promise<any>;
     closeAsync(): Promise<void>;
     dropAsync(): Promise<void>;
     releaseAsync(): Promise<void>;

package/lib/wire/statement.js

@@ -17,11 +17,7 @@ class Statement {
         this.connection.dropStatement(this, callback);
     }
     release(callback) {
-        var cache_query = this.connection.getCachedQuery(this.query);
-        if (cache_query)
-            this.connection.closeStatement(this, callback);
-        else
-            this.connection.dropStatement(this, callback);
+        this.connection.releaseStatement(this, callback);
     }
     execute(transaction, params, callback, options) {
         if (params instanceof Function) {

package/lib/wire/transaction.d.ts

@@ -1,15 +1,27 @@
+import { type Callback, type SimpleCallback } from '../callback';
+import type Connection from './connection';
+import type Database from './database';
+import type Statement from './statement';
+import type { BatchCb, StatementCb, InternalQueryOptions } from './wire-types';
+import type { BatchOptions, BatchResult, QueryOptions, QueryParams, QueryStreamOptions, SequentialCallback } from '../types';
 declare class Transaction {
-    connection: any;
-    db: any;
+    connection: Connection;
+    db: Database;
     handle: number;
-    [key: string]: any;
-    constructor(connection: any);
+    constructor(connection: Connection);
     /** Per-call options.namedPlaceholders overrides the connection option. */
     private namedPlaceholdersEnabled;
-    newStatement(query: string, callback: (err: any, statement?: any) => void, options?: any): void;
-    execute(query: string, params?: any, callback?: any, options?: any): void;
-    sequentially(query: string, params?: any, on?: any, callback?: any, options?: any): this;
-    query(query: string, params?: any, callback?: any, options?: any): void;
+    newStatement(query: string, callback: StatementCb, options?: InternalQueryOptions): void;
+    execute(query: string, params?: QueryParams | Callback, callback?: any, options?: InternalQueryOptions): void;
+    sequentially(query: string, params?: any, on?: any, callback?: any, options?: InternalQueryOptions | boolean): this;
+    /**
+     * Run `query` inside this transaction and return an object-mode
+     * Readable emitting one row per chunk, with real backpressure (see
+     * Database.queryStream). The transaction is NOT committed when the
+     * stream ends — commit or roll back yourself.
+     */
+    queryStream(query: string, params?: QueryParams, options?: QueryStreamOptions): import("node:stream").Readable;
+    query(query: string, params?: QueryParams | Callback, callback?: any, options?: InternalQueryOptions): void;
     /**
      * Execute `query` once per row in `rows` using the Firebird 4 batch API
      * (protocol 16+, single network flush). The callback receives a
@@ -19,16 +31,16 @@ declare class Transaction {
      * commit or roll back yourself (or use db.executeBatch for
      * all-or-nothing semantics).
      */
-    executeBatch(query: string, rows: any[][], callback?: any, options?: any): void;
-    executeBatchAsync(query: string, rows: any[][], options?: any): Promise<any>;
-    commit(callback?: (err?: any) => void): void;
-    rollback(callback?: (err?: any) => void): void;
-    commitRetaining(callback?: (err?: any) => void): void;
-    rollbackRetaining(callback?: (err?: any) => void): void;
-    queryAsync(query: string, params?: any, options?: any): Promise<any[]>;
-    executeAsync(query: string, params?: any, options?: any): Promise<any[]>;
-    sequentiallyAsync(query: string, params?: any, on?: any, options?: any): Promise<void>;
-    newStatementAsync(query: string): Promise<any>;
+    executeBatch(query: string, rows: QueryParams[], callback?: BatchCb, options?: BatchOptions & QueryOptions): void;
+    executeBatchAsync(query: string, rows: QueryParams[], options?: BatchOptions & QueryOptions): Promise<BatchResult>;
+    commit(callback?: SimpleCallback): void;
+    rollback(callback?: SimpleCallback): void;
+    commitRetaining(callback?: SimpleCallback): void;
+    rollbackRetaining(callback?: SimpleCallback): void;
+    queryAsync(query: string, params?: QueryParams, options?: InternalQueryOptions): Promise<any[]>;
+    executeAsync(query: string, params?: QueryParams, options?: InternalQueryOptions): Promise<any[]>;
+    sequentiallyAsync(query: string, params?: any, on?: SequentialCallback, options?: InternalQueryOptions | boolean): Promise<void>;
+    newStatementAsync(query: string): Promise<Statement>;
     commitAsync(): Promise<void>;
     rollbackAsync(): Promise<void>;
     commitRetainingAsync(): Promise<void>;

package/lib/wire/transaction.js

@@ -6,6 +6,7 @@ const callback_1 = require("../callback");
 const named_params_1 = require("../named-params");
 const utils_1 = require("../utils");
 const const_1 = __importDefault(require("./const"));
+const query_stream_1 = __importDefault(require("./query-stream"));
 /***************************************
  *
  *   Transaction
@@ -55,6 +56,9 @@ class Transaction {
     newStatement(query, callback, options) {
         var cnx = this.connection;
         var self = this;
+        // the public strict callback shape and the internal optional-args
+        // shape only differ in optionality; treat it as the internal one
+        var cb = callback;
         // With namedPlaceholders on, prepare the positional rewrite and
         // remember the name order on the statement so statement.execute can
         // accept a values-by-name object. The rewritten SQL is the cache key.
@@ -69,9 +73,9 @@ class Transaction {
         var deliver = function (err, statement) {
             if (statement)
                 statement.namedParams = names;
-            callback(err, statement);
+            cb(err, statement);
         };
-        var query_cache = cnx.getCachedQuery(query);
+        var query_cache = cnx.takeCachedStatement(query);
         if (query_cache) {
             deliver(null, query_cache);
         }
@@ -95,11 +99,15 @@ class Transaction {
         }
         var self = this;
         this.newStatement(query, function (err, statement) {
-            if (err) {
+            if (err || !statement) {
                 (0, callback_1.doError)(err, callback);
                 return;
             }
             function dropError(err) {
+                // do not put a statement that just failed back into the cache
+                // (statement is guaranteed by the guard above; hoisting keeps
+                // the narrowing from reaching this function declaration)
+                statement._failed = true;
                 statement.release();
                 (0, callback_1.doCallback)(err, callback);
             }
@@ -209,6 +217,15 @@ class Transaction {
         self.execute(query, params, callback, options);
         return self;
     }
+    /**
+     * Run `query` inside this transaction and return an object-mode
+     * Readable emitting one row per chunk, with real backpressure (see
+     * Database.queryStream). The transaction is NOT committed when the
+     * stream ends — commit or roll back yourself.
+     */
+    queryStream(query, params, options) {
+        return (0, query_stream_1.default)(this, query, params, options);
+    }
     query(query, params, callback, options = {}) {
         if (params instanceof Function) {
             callback = params;
@@ -235,11 +252,13 @@ class Transaction {
     executeBatch(query, rows, callback, options) {
         var self = this;
         this.newStatement(query, function (err, statement) {
-            if (err) {
+            if (err || !statement) {
                 (0, callback_1.doError)(err, callback);
                 return;
             }
             statement.executeBatch(self, rows, function (err, result) {
+                if (err)
+                    statement._failed = true;
                 statement.release();
                 if (callback)
                     callback(err, result);

package/lib/wire/wire-types.d.ts

@@ -0,0 +1,116 @@
+/***************************************
+ *
+ *   Internal wire-protocol types (type-only module)
+ *
+ * Shared vocabulary for the wire core (connection/statement/transaction/
+ * database). Nothing here exists at runtime.
+ *
+ ***************************************/
+import type { Callback, FbStatusItem } from '../callback';
+import type Statement from './statement';
+import type { BatchResult, Options, QueryOptions, Statement as PublicStatement } from '../types';
+/**
+ * One entry of the connection's response queue (`connection._queue`).
+ * The function itself is the user/driver callback; the extra properties
+ * steer decodeResponse:
+ *
+ * - `response`  — pre-allocated object the op_response decode fills in
+ *                 (a Statement, Transaction, or plain response object).
+ * - `statement` — statement whose `output` describes the rows of an
+ *                 op_fetch_response / op_sql_response.
+ * - `lazy_count`— number of chained lazy op_responses this entry consumes
+ *                 (ptype_lazy_send batches e.g. allocate+prepare).
+ *
+ * Deferred ops (op_free_statement, op_close_blob, ...) push `undefined`
+ * placeholders so every server response still pairs with one entry.
+ */
+export interface QueueCallback {
+    (err?: any, obj?: any): void;
+    response?: any;
+    statement?: Statement;
+    lazy_count?: number;
+}
+/** A queue entry: a callback, or a placeholder for a deferred op. */
+export type QueueEntry = QueueCallback | undefined;
+/** XDR quad — 64-bit value as two 32-bit halves (blob ids, object ids). */
+export interface Quad {
+    high: number;
+    low: number;
+}
+/**
+ * Decoded op_response packet (see parseOpResponse): object handle, object
+ * id, optional info buffer and, on failure, the status vector. Statement /
+ * Transaction responses are these fields merged onto the pre-allocated
+ * object from QueueCallback.response.
+ */
+export interface WireResponse {
+    handle?: number;
+    oid?: Quad;
+    buffer?: Buffer;
+    status?: FbStatusItem[];
+    /** isc_arg_warning entries — attached to a SUCCESSFUL response */
+    warnings?: FbStatusItem[];
+    sqlcode?: number;
+    message?: string;
+}
+/** Result of decoding op_fetch_response / op_sql_response row data. */
+export interface FetchResult {
+    data: any[];
+    /** true when the cursor is exhausted (fetch status 100 / singleton). */
+    fetched: boolean;
+    /** pending blobAsText fetches to resolve before delivering rows. */
+    arrBlob?: any[];
+}
+/**
+ * Protocol negotiation result decoded from op_accept / op_cond_accept /
+ * op_accept_data, plus the auth/crypt state accumulated during the
+ * handshake (op_cont_auth rounds, wire-crypt keys).
+ */
+export interface AcceptPacket {
+    protocolVersion: number;
+    protocolArchitecture: number;
+    protocolMinimumType: number;
+    compress: boolean;
+    pluginName: string;
+    authData: any;
+    sessionKey?: any;
+    [key: string]: any;
+}
+/**
+ * Query options as the wire core sees them: the public QueryOptions plus
+ * the internal row-delivery flags set by the Database/Transaction helpers
+ * (query / sequentially / queryStream).
+ */
+export type InternalQueryOptions = QueryOptions & {
+    /** deliver rows as objects keyed by column alias */
+    asObject?: boolean;
+    /** deliver rows one by one (row events / `on` delegate) instead of accumulating */
+    asStream?: boolean;
+    /** per-row delegate installed by sequentially() */
+    on?: (row: any, index: number, meta: any[], next: (err?: any) => void) => void;
+    [key: string]: any;
+};
+/**
+ * newStatement callback: the internal optional-args shape, or the public
+ * strict shape (non-optional statement) declared in types.ts.
+ */
+export type StatementCb = Callback<Statement> | ((err: Error | null, statement: PublicStatement) => void);
+/**
+ * executeBatch callback: the internal optional-args shape, or the public
+ * strict shape (non-optional result) declared in types.ts.
+ */
+export type BatchCb = Callback<BatchResult> | ((err: any, result: BatchResult) => void);
+/**
+ * Connection options as the wire core sees them: the public Options plus
+ * internal flags set by the driver itself.
+ */
+export type InternalOptions = Options & {
+    /** set by the pool so detach() returns the connection instead */
+    isPool?: boolean;
+    /** override path of the firebird.msg error-message file */
+    messageFile?: string;
+    /** legacy statement-cache flags (mapped onto statementCacheSize) */
+    cacheQuery?: boolean;
+    maxCachedQuery?: number;
+    [key: string]: any;
+};

package/lib/wire/wire-types.js

@@ -0,0 +1,10 @@
+"use strict";
+/***************************************
+ *
+ *   Internal wire-protocol types (type-only module)
+ *
+ * Shared vocabulary for the wire core (connection/statement/transaction/
+ * database). Nothing here exists at runtime.
+ *
+ ***************************************/
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/wire/xsqlvar.d.ts

@@ -22,20 +22,20 @@ export declare abstract class SQLVarBase {
     abstract calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarText extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean, options?: any): any;
+    decode(data: XdrReader, lowerV13: boolean, options?: any): string | Buffer<ArrayBufferLike> | null | undefined;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarNull extends SQLVarText {
 }
 export declare class SQLVarString extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean, options?: any): any;
+    decode(data: XdrReader, lowerV13: boolean, options?: any): string | Buffer<ArrayBufferLike> | null | undefined;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarQuad extends SQLVarBase {
     decode(data: XdrReader, lowerV13: boolean): {
         low: number;
         high: number;
-    };
+    } | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarBlob extends SQLVarQuad {
@@ -45,66 +45,66 @@ export declare class SQLVarArray extends SQLVarQuad {
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarInt extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): number;
+    decode(data: XdrReader, lowerV13: boolean): number | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarShort extends SQLVarInt {
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarInt64 extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): number;
+    decode(data: XdrReader, lowerV13: boolean): number | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarInt128 extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): string | number;
+    decode(data: XdrReader, lowerV13: boolean): string | number | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarDecFloat16 extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): string | number;
+    decode(data: XdrReader, lowerV13: boolean): string | number | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarDecFloat34 extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): string | number;
+    decode(data: XdrReader, lowerV13: boolean): string | number | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarFloat extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): number;
+    decode(data: XdrReader, lowerV13: boolean): number | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarDouble extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): number;
+    decode(data: XdrReader, lowerV13: boolean): number | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarDate extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): Date;
+    decode(data: XdrReader, lowerV13: boolean): Date | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarTime extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): Date;
+    decode(data: XdrReader, lowerV13: boolean): Date | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarTimeStamp extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): Date;
+    decode(data: XdrReader, lowerV13: boolean): Date | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarTimeTz extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): Date;
+    decode(data: XdrReader, lowerV13: boolean): Date | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarTimeTzEx extends SQLVarTimeTz {
-    decode(data: XdrReader, lowerV13: boolean): Date;
+    decode(data: XdrReader, lowerV13: boolean): Date | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarTimeStampTz extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): Date;
+    decode(data: XdrReader, lowerV13: boolean): Date | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarTimeStampTzEx extends SQLVarTimeStampTz {
-    decode(data: XdrReader, lowerV13: boolean): Date;
+    decode(data: XdrReader, lowerV13: boolean): Date | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLVarBoolean extends SQLVarBase {
-    decode(data: XdrReader, lowerV13: boolean): boolean;
+    decode(data: XdrReader, lowerV13: boolean): boolean | null;
     calcBlr(blr: BlrWriter): void;
 }
 export declare class SQLParamInt {

package/package.json

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

package/src/index.ts

@@ -1,5 +1,5 @@
 import Const from './wire/const';
-import { doError, doCallback, fromCallback } from './callback';
+import { doError, doCallback, fromCallback, type Callback } from './callback';
 import Connection from './wire/connection';
 import Pool from './pool';
 import { escape as escapeValue } from './utils';
@@ -48,6 +48,36 @@ export const ISOLATION_READ_COMMITTED_READ_ONLY: number[] = Const.ISOLATION_READ
 
 export const escape = escapeValue;
 
+/**
+ * Firebird SQL type codes, as seen in `column.type` inside a `typeCast`
+ * hook (each code also has a friendly `column.typeName`).
+ */
+export const SQL_TYPES: Readonly<Record<string, number>> = Object.freeze({
+    SQL_TEXT: Const.SQL_TEXT,
+    SQL_VARYING: Const.SQL_VARYING,
+    SQL_SHORT: Const.SQL_SHORT,
+    SQL_LONG: Const.SQL_LONG,
+    SQL_FLOAT: Const.SQL_FLOAT,
+    SQL_DOUBLE: Const.SQL_DOUBLE,
+    SQL_D_FLOAT: Const.SQL_D_FLOAT,
+    SQL_TIMESTAMP: Const.SQL_TIMESTAMP,
+    SQL_BLOB: Const.SQL_BLOB,
+    SQL_ARRAY: Const.SQL_ARRAY,
+    SQL_QUAD: Const.SQL_QUAD,
+    SQL_TYPE_TIME: Const.SQL_TYPE_TIME,
+    SQL_TYPE_DATE: Const.SQL_TYPE_DATE,
+    SQL_INT64: Const.SQL_INT64,
+    SQL_INT128: Const.SQL_INT128,
+    SQL_TIMESTAMP_TZ: Const.SQL_TIMESTAMP_TZ,
+    SQL_TIMESTAMP_TZ_EX: Const.SQL_TIMESTAMP_TZ_EX,
+    SQL_TIME_TZ: Const.SQL_TIME_TZ,
+    SQL_TIME_TZ_EX: Const.SQL_TIME_TZ_EX,
+    SQL_DEC16: Const.SQL_DEC16,
+    SQL_DEC34: Const.SQL_DEC34,
+    SQL_BOOLEAN: Const.SQL_BOOLEAN,
+    SQL_NULL: Const.SQL_NULL,
+});
+
 /**
  * The most recent Connection created by attach()/create()/attachOrCreate().
  * Kept for backwards compatibility with the previous CommonJS module where
@@ -114,7 +144,7 @@ export function create(options: Options | string, callback: DatabaseCallback): v
                 return;
             }
 
-            cnx.createDatabase(options, callback);
+            cnx.createDatabase(options, callback as any);
         });
     }, options);
 }
@@ -146,11 +176,13 @@ export function attachOrCreate(options: Options | string, callback: DatabaseCall
                 if (!err) {
                     if (self.db)
                         self.db.emit('connect', ret);
-                    doCallback(ret, callback);
+                    // DatabaseCallback stays permissive (db non-optional) for
+                    // API users; internally the error path passes no db
+                    doCallback(ret, callback as Callback<Database>);
                     return;
                 }
 
-                cnx.createDatabase(options, callback);
+                cnx.createDatabase(options, callback as any);
             });
         });
 

package/src/messages.ts

@@ -138,7 +138,7 @@ export const lookupMessages = function(status: FbStatusItem[], messageFile: stri
             buffer = Buffer.alloc(bucket_size);
 
             var i = 0;
-            var text;
+            var text: string | undefined;
 
             function loop() {
                 lookup(status[i], function(line) {

package/src/pool.ts

@@ -161,7 +161,7 @@ class Pool extends Events.EventEmitter {
         if ((self.dbinuse + self._creating) >= self.max)
             return self;
 
-        var cb = self.pending.shift();
+        const cb = self.pending.shift();
         if (!cb)
             return self;
         if (self.pooldb.length) {

package/src/srp.ts

@@ -67,7 +67,7 @@ export function clientSeed(a: bigint = toBigInt(crypto.randomBytes(SRP_KEY_SIZE)
  * @param b BigInt Server private key.
  * @returns {{private: BigInt, public: BigInt}}
  */
-export function serverSeed(user: string, password: string, salt: Buffer, b?: bigint | string, hashAlgo: string = 'sha1'): KeyPair {
+export function serverSeed(user: string, password: string, salt: Buffer | string, b?: bigint | string, hashAlgo: string = 'sha1'): KeyPair {
     if (typeof b === 'string') {
         hashAlgo = b;
         b = undefined;
@@ -104,7 +104,7 @@ export function serverSeed(user: string, password: string, salt: Buffer, b?: big
  * @param b BigInt Server private key.
  * @returns {BigInt}
  */
-export function serverSession(user: string, password: string, salt: Buffer, A: bigint, B: bigint, b: bigint, hashAlgo: string = 'sha1'): bigint {
+export function serverSession(user: string, password: string, salt: Buffer | string, A: bigint, B: bigint, b: bigint, hashAlgo: string = 'sha1'): bigint {
     var u = getScramble(A, B, 'sha1');
     var v = getVerifier(user, password, salt, 'sha1');
     var vu = modPow(v, u, PRIME.N);
@@ -121,7 +121,7 @@ export function serverSession(user: string, password: string, salt: Buffer, A: b
 /**
  * M = H(H(N) xor H(g), H(I), s, A, B, K)
  */
-export function clientProof(user: string, password: string, salt: Buffer, A: bigint, B: bigint, a: bigint, hashAlgo: string = 'sha1'): ClientProof {
+export function clientProof(user: string, password: string, salt: Buffer | string, A: bigint, B: bigint, a: bigint, hashAlgo: string = 'sha1'): ClientProof {
     var K = clientSession(user, password, salt, A, B, a, 'sha1');
     var n1, n2;
 
@@ -222,7 +222,7 @@ function getScramble(A: bigint, B: bigint, hashAlgo: string = 'sha1'): bigint {
  * @returns Buffer The raw session-key digest (fixed length, may start
  *                 with a zero byte — significant for the proof).
  */
-function clientSession(user: string, password: string, salt: Buffer, A: bigint, B: bigint, a: bigint, hashAlgo: string = 'sha1'): Buffer {
+function clientSession(user: string, password: string, salt: Buffer | string, A: bigint, B: bigint, a: bigint, hashAlgo: string = 'sha1'): Buffer {
     var u = getScramble(A, B, 'sha1');
     var x = getUserHash(user, salt, password, 'sha1');
     var gx = modPow(PRIME.g, x, PRIME.N);
@@ -264,7 +264,7 @@ function clientSession(user: string, password: string, salt: Buffer, A: bigint,
  * @param password string Connection password.
  * @returns {BigInt}
  */
-function getUserHash(user: string, salt: Buffer, password: string, hashAlgo: string = 'sha1'): bigint {
+function getUserHash(user: string, salt: Buffer | string, password: string, hashAlgo: string = 'sha1'): bigint {
     var hash1 = getHash(hashAlgo, user.toUpperCase(), ':', password);
     var hash2 = getHash(hashAlgo, salt, toBuffer(hash1));
 
@@ -279,7 +279,7 @@ function getUserHash(user: string, salt: Buffer, password: string, hashAlgo: str
  * @param salt  BigInt Connection salt.
  * @returns {BigInt}
  */
-function getVerifier(user: string, password: string, salt: Buffer, hashAlgo: string = 'sha1'): bigint {
+function getVerifier(user: string, password: string, salt: Buffer | string, hashAlgo: string = 'sha1'): bigint {
     return modPow(PRIME.g, getUserHash(user, salt, password, hashAlgo), PRIME.N);
 }