node-firebird 2.3.2 → 2.3.4

package/README.md

@@ -67,6 +67,8 @@ options.role = null; // default
 options.pageSize = 4096; // default when creating database
 options.retryConnectionInterval = 1000; // reconnect interval in case of connection drop
 options.blobAsText = false; // set to true to get blob as text, only affects blob subtype 1
+options.blobChunkSize = 1024; // segment size in bytes used when WRITING blobs (default 1024, max 65535)
+options.blobReadChunkSize = 1024; // buffer size in bytes requested per op_get_segment when READING blobs (default 1024, max 65535)
 options.encoding = 'UTF8'; // default encoding for connection is UTF-8
 options.wireCompression = false; // set to true to enable firebird compression on the wire (works only on FB >= 3 and compression is enabled on server (WireCompression = true in firebird.conf))
 options.wireCrypt = Firebird.WIRE_CRYPT_ENABLE; // default; set to Firebird.WIRE_CRYPT_DISABLE to disable wire encryption (FB >= 3)
@@ -372,6 +374,34 @@ Firebird.attach(options, (err, db) => {
 });
 ```
 
+### Optimizing BLOB Read/Write Chunk Sizes
+
+When working with large blobs (especially over remote or high-latency connections), you can configure the chunk/segment sizes to minimize the number of network round-trips:
+
+*   **blobChunkSize**: The segment size in bytes used when writing blobs (default: `1024`, maximum: `65535`).
+*   **blobReadChunkSize**: The buffer size in bytes requested per segment read operation when reading blobs (default: `1024`, maximum: `65535`).
+
+For example, setting `blobReadChunkSize: 65535` requests 64KB segments at a time, resulting in up to 64x fewer network packets/round-trips when reading large blobs.
+
+```js
+var options = {
+    host: '127.0.0.1',
+    port: 3050,
+    database: 'database.fdb',
+    user: 'SYSDBA',
+    password: 'masterkey',
+    blobChunkSize: 65535,      // Minimize write round-trips
+    blobReadChunkSize: 65535   // Minimize read round-trips
+};
+
+Firebird.attach(options, function (err, db) {
+  if (err) throw err;
+
+  // Insert/Read operations will use the configured 64KB chunk sizes
+  db.detach();
+});
+```
+
 ### Streaming a big data
 
 ```js
@@ -697,15 +727,47 @@ fb.attach(_connection, function (err, svc) {
 });
 ```
 
-### Charset for database connection is always UTF-8
+### Character Set & Encoding Support
+
+Node-Firebird defaults to `UTF-8` for database connections, but fully supports custom client character sets. You can set the connection encoding by specifying `options.encoding` (e.g. `'UTF8'`, `'WIN1252'`, `'ISO8859_1'`, `'LATIN1'`, `'ASCII'`, or `'NONE'`).
 
-Node Firebird uses UTF-8 as the default charset. If you want a different one, such as Latin1, you will need to go into the library and modify the default_encoding in the index.js file
+Commonly used Firebird character sets are automatically mapped to their corresponding Node.js Buffer encodings:
 
+| Firebird Character Set | Node.js Buffer Encoding | Description / Notes |
+| ---------------------- | ----------------------- | ------------------- |
+| `UTF8`, `UNICODE_FSS`  | `utf8`                  | Unicode. Handles character-level truncation automatically based on charset width. |
+| `WIN1252`, `ISO8859_1`, `LATIN1` | `latin1`      | 8-bit European encodings. Safely decodes special accented characters. |
+| `ASCII`                | `ascii`                 | 7-bit ASCII. |
+| `NONE`                 | `latin1`                | Raw/unspecified character set. Treated as binary-safe 8-bit characters. |
+
+Accented characters and fixed-length `CHAR(N)` column whitespace/truncation are handled automatically matching the connection character set width definitions.
+
+#### Custom Charset Connection Example
 ```js
-const default_encoding = 'latin1';
-```
+var options = {
+    host: '127.0.0.1',
+    port: 3050,
+    database: 'win1252_db.fdb',
+    user: 'SYSDBA',
+    password: 'masterkey',
+    encoding: 'WIN1252' // Automatically maps to 'latin1' under the hood
+};
 
-This is why you should use **Firebird 2.5** server at least.
+Firebird.attach(options, function (err, db) {
+    if (err) throw err;
+
+    // Writes 'Ç Ã É Ú Ñ' correctly using Windows-1252 encoding
+    db.query('INSERT INTO ACCENTED_TEST (ID, NAME) VALUES (?, ?)', [1, 'Ç Ã É Ú Ñ'], function (err) {
+        if (err) throw err;
+
+        db.query('SELECT NAME FROM ACCENTED_TEST WHERE ID = 1', function (err, rows) {
+            if (err) throw err;
+            console.log(rows[0].name); // 'Ç Ã É Ú Ñ' (perfectly decoded)
+            db.detach();
+        });
+    });
+});
+```
 
 ### Firebird 3.0+ Support
 
@@ -759,17 +821,18 @@ Firebird.attach({
 - Empty or undefined values send an empty response to the callback
 - This feature requires Firebird 3.0.1+ (protocol 14/15) for encrypted databases
 
-### Firebird 4.0 and 5.0
+### Firebird 4.0 and 5.0 Support
 
-Firebird 4 wire protocol (versions 16 and 17) is now supported with the following features:
+Firebird 4.0+ wire protocol (versions 16 and 17) is fully supported, including:
 
-- **Protocol versions 16 and 17** — Full support for Firebird 4.0+ wire protocol
-- **DECFLOAT data types** — Support for DECFLOAT(16) and DECFLOAT(34) using IEEE 754 Decimal64 and Decimal128 formats
-- **INT128 data type** — Native support for 128-bit integers
-- **Extended metadata identifiers** — Support for identifiers up to 63 characters
-- **Backward compatibility** — Automatically negotiates the best protocol version with the server
+- **Protocol versions 16 and 17** — Full support for Firebird 4.0+ and 5.0+ wire protocols (automatic fallback/negotiation).
+- **DECFLOAT data types** — Production-ready support for `DECFLOAT(16)` (Decimal64, 8 bytes) and `DECFLOAT(34)` (Decimal128, 16 bytes) complying with the full IEEE 754-2008 standard using BID (Binary Integer Decimal) encoding. Supports special values such as `NaN`, `+Infinity`, `-Infinity`, `+0`, and `-0`.
+- **INT128 data type** — Native support for 128-bit integers using Node.js `BigInt`.
+- **Statement Timeout** — Support for query and statement-level execution timeouts (Protocol 16+).
+- **Time Zone Support** — Native support for `TIME WITH TIME ZONE` and `TIMESTAMP WITH TIME ZONE` (represented as JavaScript `Date` objects).
+- **Extended metadata identifiers** — Support for identifiers up to 63 characters.
 
-The driver will automatically negotiate the best protocol version supported by both the client and server. No configuration changes are required for Firebird 4.0 servers.
+No configuration changes are required for Firebird 4.0 or 5.0 servers. The driver will automatically negotiate the best protocol version supported by both the client and server.
 
 ```js
 Firebird.attach({
@@ -783,27 +846,12 @@ Firebird.attach({
   
   // DECFLOAT and INT128 types are automatically supported
   db.query('SELECT CAST(123.456 AS DECFLOAT(16)) AS df16, CAST(9876543210 AS INT128) AS i128 FROM RDB$DATABASE', function(err, result) {
-    console.log(result); // { df16: 123.456, i128: '9876543210' }
+    console.log(result); // { df16: 123.456, i128: 9876543210n }
     db.detach();
   });
 });
 ```
 
-**Important Notes:**
-
-1. **Statement Timeouts:** Statement timeouts (a Protocol 16 feature) are not yet implemented. This will be added in a future release.
-
-2. **DECFLOAT Encoding:** The current DECFLOAT implementation uses a simplified encoding/decoding mechanism and does NOT implement proper IEEE 754 Decimal64/Decimal128 formats. For production use with DECFLOAT types requiring full precision and standards compliance, consider:
-   - Using a proper IEEE 754 Decimal library (e.g., `decimal128` npm package)
-   - Contributing a full IEEE 754 implementation to this driver
-   - Working with DECFLOAT values as strings or Buffers to preserve exact precision
-
-For legacy Firebird 4 servers with SRP authentication only, use the following configuration in `firebird.conf`:
-Firebird 4 wire protocol (versions 16 and 17) is partially supported, including:
-- **Time Zone Support**: Native support for `TIME WITH TIME ZONE` and `TIMESTAMP WITH TIME ZONE` (Protocol 16+).
-- **INT128 support**: Native support for 128-bit integers.
-- **Statement Timeout**: Support for statement-level timeouts.
-
 #### Using Timezones (FB 4.0+)
 
 Columns of type `TIMESTAMP WITH TIME ZONE` and `TIME WITH TIME ZONE` are automatically mapped to JavaScript `Date` objects. Values are read as UTC and represented in the local timezone of the Node.js process.
@@ -820,8 +868,7 @@ db.query('INSERT INTO FB4_TABLE (TS_TZ_COL) VALUES (?)', [new Date()], function(
 });
 ```
 
-Srp256 authentication and wire encryption are now supported natively,
-so you only need the following minimal configuration in `firebird.conf`:
+For legacy Firebird 4 servers with SRP authentication only, use the following configuration in `firebird.conf`:
 
 ```bash
 AuthServer = Srp256, Srp
@@ -836,6 +883,91 @@ For more details see:
 - [Firebird 5 migration guide — authorization](https://ib-aid.com/download/docs/fb5migrationguide.html#_authorization_from_firebird_2_5_client_libraries)
 
 
+## Extensive Examples
+
+### Firebird 4.0+ DECFLOAT & INT128 Usage
+```js
+Firebird.attach({
+  host: '127.0.0.1',
+  database: '/path/to/fb4.fdb',
+  user: 'SYSDBA',
+  password: 'masterkey',
+}, function(err, db) {
+  if (err) throw err;
+
+  // Insert DECFLOAT and INT128 types
+  db.query(
+    'INSERT INTO INVENTORY (ID, PRICE, SERIAL_NUMBER) VALUES (?, ?, ?)',
+    [1n, '12.34567890123456', 987654321098765432109876543210n],
+    function(err) {
+      if (err) throw err;
+
+      // Select them back
+      db.query('SELECT PRICE, SERIAL_NUMBER FROM INVENTORY WHERE ID = 1', function(err, result) {
+        if (err) throw err;
+        console.log(typeof result[0].price);          // 'string' (e.g. '12.34567890123456')
+        console.log(typeof result[0].serial_number);   // 'bigint' (e.g. 987654321098765432109876543210n)
+        db.detach();
+      });
+    }
+  );
+});
+```
+
+### Statement Timeouts (Firebird 4.0+)
+Setting a statement timeout allows the client to automatically abort queries that take too long on the server.
+```js
+Firebird.attach(options, function(err, db) {
+  if (err) throw err;
+
+  // Specify a statement-level execution timeout of 1000ms
+  db.query(
+    'SELECT * FROM MY_LARGE_TABLE',
+    [],
+    function(err, result) {
+      if (err) {
+        if (err.message.includes('timeout')) {
+          console.error('Query timed out!');
+        } else {
+          console.error('Error:', err);
+        }
+      }
+      db.detach();
+    },
+    { timeout: 1000 } // timeout option passed to query/execute
+  );
+});
+```
+
+### Advanced Connection Pooling & Life-cycle
+```js
+var pool = Firebird.pool(10, {
+    host: '127.0.0.1',
+    database: 'db.fdb',
+    user: 'SYSDBA',
+    password: 'masterkey',
+    connectTimeout: 5000 // 5 seconds connect timeout for pool.get()
+});
+
+// Retrieve a connection
+pool.get(function(err, db) {
+    if (err) {
+        console.error('Could not get connection from pool:', err);
+        return;
+    }
+
+    db.query('SELECT * FROM TABLE', function(err, result) {
+        // Return connection back to the pool
+        db.detach();
+    });
+});
+
+// Close all pool connections and reject pending requests
+process.on('SIGTERM', function() {
+    pool.destroy();
+});
+```
+
 ## Contributors
 
 - Henri Gourvest, <https://github.com/hgourvest>

package/lib/index.d.ts

@@ -114,6 +114,18 @@ declare module 'node-firebird' {
         retryConnectionInterval?: number;
         encoding?: SupportedCharacterSet;
         blobAsText?: boolean; // only affects for blob subtype 1
+        /**
+         * Segment size in bytes used when WRITING blobs (op_batch_segments).
+         * Default 1024, max 65535. Use 65535 to minimize round-trips on
+         * remote/high-latency connections.
+         */
+        blobChunkSize?: number;
+        /**
+         * Buffer size in bytes requested per op_get_segment when READING
+         * blobs. Default 1024, max 65535. Use 65535 to minimize round-trips
+         * on remote/high-latency connections (~64x fewer round-trips).
+         */
+        blobReadChunkSize?: number;
         wireCrypt?: number; // WIRE_CRYPT_DISABLE or WIRE_CRYPT_ENABLE
         wireCompression?: boolean;
         pluginName?: string;

package/lib/pool.js

@@ -42,9 +42,18 @@ class Pool {
         if (!cb)
             return self;
         if (self.pooldb.length) {
+            var db = self.pooldb.shift();
+            // Discard connections that have been closed or destroyed while idle
+            if (db.connection && (db.connection._isClosed || db.connection._isDetach || !db.connection._socket || db.connection._socket.destroyed)) {
+                var idx = self.internaldb.indexOf(db);
+                if (idx !== -1) self.internaldb.splice(idx, 1);
+                self.pending.unshift(cb);
+                setImmediate(function () { self.check(); });
+                return self;
+            }
             // Idle connection available — hand it out immediately.
             self.dbinuse++;
-            cb(null, self.pooldb.shift());
+            cb(null, db);
         } else {
             // No idle connection — create a new one via attach().
             self._creating++;

package/lib/srp.js

@@ -24,7 +24,11 @@ const PRIME = {
  * @param a BigInt Client private key.
  * @returns {{private: BigInt, public: BigInt}}
  */
-exports.clientSeed = function(a = toBigInt(crypto.randomBytes(SRP_KEY_SIZE))) {
+exports.clientSeed = function(a = toBigInt(crypto.randomBytes(SRP_KEY_SIZE)) % PRIME.N) {
+    // a must be in [0, N): clientSession() reduces the exponent (a + ux) mod N
+    // to match the Firebird engine, but A = g^a is computed from the raw a.
+    // When random a >= N (~10% of 1024-bit values), the proof diverges from
+    // the server's session key, causing sporadic auth failures.
     var A = modPow(PRIME.g, a, PRIME.N);
 
     dump('a', a);
@@ -127,6 +131,13 @@ function hexPad(hex) {
 }
 exports.hexPad = hexPad;
 
+/**
+ * The SRP prime modulus N (1024-bit, same value used by Firebird).
+ * Exported so tests and tooling can assert key-size invariants without
+ * duplicating the constant.
+ */
+exports.PRIME_N = PRIME.N;
+
 /**
  * Pad key with SRP_KEY_SIZE.
  *

package/lib/wire/connection.js

@@ -40,6 +40,7 @@ class Connection {
         this._isUsed = false;
         this._pooled = options.isPool||false;
         if (options && options.blobChunkSize > 65535) options.blobChunkSize = 65535;
+        if (options && options.blobReadChunkSize > 65535) options.blobReadChunkSize = 65535;
         this.options = options;
         this._bind_events(host, port, callback);
         this.error;
@@ -155,6 +156,7 @@ class Connection {
     
             while (xdr.pos < xdr.buffer.length) {
                 var cb = self._queue[0], pos = xdr.pos;
+                var lazySnapshot = cb ? cb.lazy_count : undefined;
     
                 decodeResponse(xdr, cb, self, self._lowercase_keys, function (err, obj) {
     
@@ -171,8 +173,17 @@ class Connection {
                                     xdr.buffer.length, pos, self._queue.length);
                             }
 
-                            if (self.accept && self.accept.protocolMinimumType === Const.ptype_lazy_send && self._queue.length > 0) {
-                                self._queue[0].lazy_count = 2;
+                            // Restore lazy_count to its value before this (failed)
+                            // decode attempt. Forcing lazy_count = 2 here made the
+                            // decoder expect a second op_response that never arrives
+                            // whenever a single large response (e.g. op_get_segment
+                            // with a big buffer) spans multiple TCP packets.
+                            if (cb) {
+                                if (lazySnapshot === undefined) {
+                                    delete cb.lazy_count;
+                                } else {
+                                    cb.lazy_count = lazySnapshot;
+                                }
                             }
                         } else {
                             // Any other error (truly unknown opcode not handled above).
@@ -1287,9 +1298,22 @@ class Connection {
             }
 
             if (ret && ret.data && ret.data.length) {
-                const arrPromise = (ret.arrBlob || []).map((value) => value(transaction));
+                // Read blobs sequentially instead of in parallel to avoid
+                // exceeding Firebird's per-connection open-blob-handle limit,
+                // which causes a server-side deadlock when many rows contain
+                // BLOBs and blobAsText is true. See issue #387.
+                const arrBlobFns = ret.arrBlob || [];
+                const readBlobsSequentially = (index, results) => {
+                    if (index >= arrBlobFns.length) {
+                        return Promise.resolve(results);
+                    }
+                    return arrBlobFns[index](transaction).then((v) => {
+                        results.push(v);
+                        return readBlobsSequentially(index + 1, results);
+                    });
+                };
 
-                Promise.all(arrPromise).then((arrBlob) => {
+                readBlobsSequentially(0, []).then((arrBlob) => {
                     for (let i = 0; i < arrBlob.length; i++) {
                         const blob = arrBlob[i];
                         ret.data[blob.row][blob.column] = blob.value;
@@ -1354,7 +1378,7 @@ class Connection {
         msg.pos = 0;
         msg.addInt(Const.op_get_segment);
         msg.addInt(blob.handle);
-        msg.addInt(1024); // buffer length
+        msg.addInt(this.options.blobReadChunkSize || 1024); // buffer length (max 65535)
         msg.addInt(0); // ???
         this._queueEvent(callback);
     }
@@ -1718,7 +1742,7 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                             _xdrpos = data.pos;
                             const key = custom.asObject ? data.fcols[data.fcolumn] : data.fcolumn;
                             const row = data.frows.length;
-                            let value = item.decode(data, lowerV13);
+                            let value = item.decode(data, lowerV13, cnx.options);
 
                             if (item.type === Const.SQL_BLOB && value !== null) {
                                 if (item.subType === Const.isc_blob_text && cnx.options.blobAsText) {
@@ -1808,7 +1832,15 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
 
                     if (is_authenticated === 0) {
                         if (cnx.options.pluginName && cnx.options.pluginName !== accept.pluginName) {
-                            doError(new Error('Server don\'t accept plugin : ' + cnx.options.pluginName + ', but support : ' + accept.pluginName), callback);
+                            var errPlugin = new Error('Server don\'t accept plugin : ' + cnx.options.pluginName + ', but support : ' + accept.pluginName);
+                            doError(errPlugin, callback);
+                            return cb(errPlugin);
+                        }
+
+                        if (Const.AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1 && !cnx.clientKeys) {
+                            var errPlugin = new Error('Server accepted plugin : ' + accept.pluginName + ', but client did not initialize SRP keys');
+                            doError(errPlugin, callback);
+                            return cb(errPlugin);
                         }
 
                         if (Const.AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1) {

package/lib/wire/socket.js

@@ -55,6 +55,7 @@ class Socket {
     constructor(port, host) {
         this._socket = net.createConnection(port, host);
         this._socket.setNoDelay(true);
+        this._socket.setKeepAlive(true, 60000); // 1 minute delay to detect dead/stale connections
         this.compressor = null;
         this.compressorBuffer = [];
         this.decompressor = null;
@@ -99,7 +100,14 @@ class Socket {
      */
     write(data, defer = false) {
         if (defer) {
-            this.buffer = Buffer.from(data);
+            // Accumulate deferred packets instead of overwriting.  Multiple
+            // deferred ops (e.g. op_close_blob followed immediately by
+            // op_free_statement) must all be kept until the next flush;
+            // overwriting the buffer silently drops packets and desynchronises
+            // the request/response queue, causing the connection to hang.
+            this.buffer = this.buffer
+                ? Buffer.concat([this.buffer, Buffer.from(data)])
+                : Buffer.from(data);
             return;
         }
 
@@ -167,6 +175,10 @@ class Socket {
             return this[field].bind(this);
         }
 
+        if (typeof target[field] === 'function') {
+            return target[field].bind(target);
+        }
+
         return target[field];
     }
 }

package/lib/wire/xsqlvar.js

@@ -13,17 +13,79 @@ const
     TimeCoeff = 86400000,
     MsPerMinute = 60000;
 
+/**
+ * Maps Firebird character-set names (upper-case) to the Node.js Buffer
+ * encoding string used by Buffer.toString() / Buffer.from().
+ *
+ * Firebird stores CHAR/VARCHAR data in the on-wire character set of the
+ * column (or the connection character set for NONE/unspecified columns).
+ * We must decode raw bytes with the matching Node.js encoding so that
+ * characters outside ASCII are reproduced correctly.
+ *
+ * Commonly used Firebird charsets not listed here fall back to the
+ * connection-level DEFAULT_ENCODING (typically 'utf8').
+ */
+const FirebirdToNodeEncoding = Object.freeze({
+    UTF8:        'utf8',
+    UNICODE_FSS: 'utf8',
+    WIN1252:     'latin1',
+    ISO8859_1:   'latin1',
+    LATIN1:      'latin1',
+    ASCII:       'ascii',
+    NONE:        'latin1',   // unspecified charset – treat as binary-safe latin1
+});
+
+const FirebirdCharsetWidths = {
+    'UTF8': 4,
+    'UNICODE_FSS': 3,
+    'SJIS': 2,
+    'EUCJ': 2
+};
+
+function getFirebirdCharsetWidth(charset) {
+    if (!charset) return 4;
+    const upper = charset.toUpperCase();
+    return FirebirdCharsetWidths[upper] || 1;
+}
+
+/**
+ * Resolve the Node.js Buffer encoding to use when decoding text from a
+ * Firebird response buffer.
+ *
+ * @param {object|null} options  Connection options object (may be falsy).
+ * @returns {string}             A Node.js-compatible encoding string.
+ */
+function resolveTextEncoding(options) {
+    const encoding = (options && options.encoding)
+        ? options.encoding.toUpperCase()
+        : Const.DEFAULT_ENCODING;
+    return FirebirdToNodeEncoding[encoding] || Const.DEFAULT_ENCODING.toLowerCase();
+}
+
 //------------------------------------------------------
 
 class SQLVarText {
-    decode(data, lowerV13) {
+    decode(data, lowerV13, options) {
         let ret;
+        const textEncoding = resolveTextEncoding(options);
         if (this.subType > 1) {
             // ToDo: with column charset
-            ret = data.readText(this.length, Const.DEFAULT_ENCODING);
+            ret = data.readText(this.length, textEncoding);
+            const encoding = options && options.encoding ? options.encoding : 'UTF8';
+            const width = getFirebirdCharsetWidth(encoding);
+            const charLength = Math.floor(this.length / width);
+            if (ret.length > charLength) {
+                ret = ret.substring(0, charLength);
+            }
         } else if (this.subType === 0) {
             // without charset definition
-            ret = data.readText(this.length, Const.DEFAULT_ENCODING);
+            ret = data.readText(this.length, textEncoding);
+            const encoding = options && options.encoding ? options.encoding : 'UTF8';
+            const width = getFirebirdCharsetWidth(encoding);
+            const charLength = Math.floor(this.length / width);
+            if (ret.length > charLength) {
+                ret = ret.substring(0, charLength);
+            }
         } else {
             ret = data.readBuffer(this.length);
         }
@@ -49,14 +111,15 @@ class SQLVarNull extends SQLVarText {
 //------------------------------------------------------
 
 class SQLVarString {
-    decode(data, lowerV13) {
+    decode(data, lowerV13, options) {
         let ret;
+        const textEncoding = resolveTextEncoding(options);
         if (this.subType > 1) {
             // ToDo: with column charset
-            ret = data.readString(Const.DEFAULT_ENCODING);
+            ret = data.readString(textEncoding);
         } else if (this.subType === 0) {
             // without charset definition
-            ret = data.readString(Const.DEFAULT_ENCODING);
+            ret = data.readString(textEncoding);
         } else {
             ret = data.readBuffer();
         }

package/package.json

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

package/poc/node_modules/.package-lock.json

@@ -0,0 +1,14 @@
+{
+  "name": "node-firebird-pool-poc",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/node-firebird": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/node-firebird/-/node-firebird-2.3.1.tgz",
+      "integrity": "sha512-3yTwiLHwgtLYRv+aS4frzsQEwHMDXkP5Z1SPM/W103TvMemVRoCIaxPYO7axnUrKhgTfPHGXzqC5umYlQail/w==",
+      "license": "MPL-2.0"
+    }
+  }
+}

package/poc/node_modules/node-firebird/.eslintrc.json

@@ -0,0 +1,12 @@
+{
+    "parserOptions": {
+        "ecmaVersion": 6,
+        "sourceType": "module",
+        "ecmaFeatures": {
+            "jsx": true
+        }
+    },
+    "rules": {
+        "semi": "error"
+    }
+}

package/poc/node_modules/node-firebird/.github/workflows/codeql.yml

@@ -0,0 +1,76 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "master" ]
+  schedule:
+    - cron: '26 2 * * 3'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Use only 'java' to analyze code written in Java, Kotlin or both
+        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines.
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #     echo "Run, Build Application using script"
+    #     ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      with:
+        category: "/language:${{matrix.language}}"