node-firebird 1.1.9 → 1.1.10

package/.github/workflows/node.js.yml

@@ -8,7 +8,7 @@ jobs:
 
     strategy:
       matrix:        
-        node: [18, 20]
+        node: [20, 22]
         firebird-version: ['v3']
 
     steps:
@@ -17,11 +17,13 @@ jobs:
         fetch-depth: 10
 
     - name: Setup FirebirdSQL container
-      uses: juarezr/firebirdsql-github-action@v1.2.0
+      uses: juarezr/firebirdsql-github-action@v2.0.1
       with:
         version: ${{ matrix.firebird-version }}
-        isc_password: "masterkey"
-        enable_legacy_client_auth: "true"        
+        firebird_root_password: "masterkey"
+        firebird_conf: |
+          WireCrypt = Enabled
+          AuthServer = Legacy_Auth,Srp,Win_Sspi
 
     - name: Use Node.js ${{ matrix.node }}
       uses: actions/setup-node@v3

package/README.md

@@ -68,6 +68,7 @@ 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.encoding = 'UTF8'; // default encoding for connection is UTF-8
+options.wireCompression = false; // set to true for enable firebird compression on the wire (Work only on FB >= 3 and compression is enable on server (WireCompression = true in firebird.conf))  
 ```
 
 ### Classic
@@ -113,7 +114,21 @@ pool.destroy();
 - `db.execute(query, [params], function(err, result))` - classic query, returns Array of Array
 - `db.sequentially(query, [params], function(row, index), function(err))` - sequentially query
 - `db.detach(function(err))` detach a database
-- `db.transaction(isolation, function(err, transaction))` create transaction
+- `db.transaction(options, function(err, transaction))` create transaction
+
+### Transaction options
+
+```js
+const options = {
+    autoCommit: false,
+    autoUndo: true,
+    isolation: Firebird.ISOLATION_READ_COMMITTED,
+    ignoreLimbo: false,
+    readOnly: false,
+    wait: true,
+    waitTimeout: 0,
+};
+```
 
 ### Transaction methods
 
@@ -581,7 +596,7 @@ for Firebird 3.0 you need to add the following in firebird.conf according to Fir
 
 ```bash
 AuthServer = Srp, Legacy_Auth
-WireCrypt = Disabled
+WireCrypt = Enabled
 UserManager = Legacy_UserManager
 ```
 
@@ -591,13 +606,27 @@ for Firebird 4.0 you need to add the following in firebird.conf according to Fir
 
 ```bash
 AuthServer = Srp256, Srp, Legacy_Auth
-WireCrypt = Disabled
+WireCrypt = Enabled
 UserManager = Legacy_UserManager
 ```
 
 Please read also Authorization with Firebird 2.5 client library from Firebird 4 migration guide
 <https://ib-aid.com/download/docs/fb4migrationguide.html#_authorization_with_firebird_2_5_client_library_fbclient_dll>
 
+Firebird 5 wire protocol is not supported yet so
+for Firebird 5.0 you need to add the following in firebird.conf according to Firebird release notes
+<https://firebirdsql.org/file/documentation/release_notes/html/en/4_0/rlsnotes40.html#rnfb40-config-srp256>
+
+```bash
+AuthServer = Srp256, Srp, Legacy_Auth
+WireCrypt = Enabled
+UserManager = Legacy_UserManager
+```
+
+Please read also Authorization with Firebird 2.5 client library from Firebird 5 migration guide
+<https://ib-aid.com/download/docs/fb5migrationguide.html#_authorization_from_firebird_2_5_client_libraries>
+
+
 ## Contributors
 
 - Henri Gourvest, <https://github.com/hgourvest>

package/Roadmap.md

@@ -0,0 +1,80 @@
+# Node-Firebird Roadmap
+
+This document outlines the future development direction for the `node-firebird` library. Our primary goals are to modernize the codebase, implement support for the latest Firebird features, and improve the overall developer experience.
+
+## Protocol Implementation Status
+
+The following table summarizes the current and planned implementation status of the Firebird wire protocol for each major version.
+
+| Firebird Version | Protocol Versions | Status |
+| :--- | :--- | :--- |
+| 2.5 | 10, 11, 12, 13 | ✅ Implemented |
+| 3.0 | 14, 15 | ❌ Not Implemented |
+| 4.0 | 16, 17 | ❌ Not Implemented |
+| 5.0 | N/A | ❌ Not Implemented |
+| 6.0 | N/A | ❌ Not Implemented |
+
+## Firebird 3 Support
+
+Firebird 3 introduced Protocol 13, which brought significant changes focusing on security and performance. While the base protocol is implemented, several key features are still missing. To fully support Firebird 3, we need to implement the following:
+
+- **Protocol Versions 14 and 15:** Implement the newer wire protocol versions.
+- **Enhanced Authentication:** Fully support the new authentication mechanisms and plugin architecture.
+- **Wire Protocol Encryption:** Implement support for encrypting all network traffic.
+- **Wire Protocol Compression:** Add support for data compression.
+- **Database Encryption Callback:** Support the new callback mechanism for handling database encryption keys.
+- **Packed (NULL-aware) Row Data:** Implement support for the optimized row format.
+- **Performance Optimizations:**
+  - Implement support for the denser data stream and improved prefetch logic.
+  - Utilize the new bitmap for transmitting NULL flags to reduce network traffic.
+- **UTF-8 User Identification:** Ensure all user identification is properly handled with UTF-8 encoding.
+
+## Firebird 4 Support
+
+Firebird 4 introduced Protocol versions 16 and 17, continuing to build upon the foundation of Firebird 3. Key features to implement include:
+
+- **Protocol Versions 16 and 17:** Implement the latest protocol versions to support Firebird 4 features.
+
+## Firebird 5 Support
+
+Firebird 5 introduces a host of new SQL features and performance improvements that will require significant client-side implementation:
+
+- **Bidirectional Cursors:** Implement support for scrollable cursors for remote database access.
+- **`RETURNING` Multiple Rows:** Enhance DML operations to support returning multiple rows.
+- **`SKIP LOCKED`:** Add support for the `SKIP LOCKED` clause in `SELECT WITH LOCK`, `UPDATE`, and `DELETE` statements.
+- **New Data Types and Functions:** Add support for new built-in functions and packages.
+
+## Firebird 6 and Beyond
+
+As Firebird 6 and future versions are released, we will continue to monitor new features and plan for their implementation. Key areas of interest include:
+
+- **JSON Support:** Implement client-side support for the new SQL-compliant JSON functions.
+- **Tablespaces:** Add support for tablespaces.
+- **SQL Schemas:** Implement support for SQL schemas.
+
+## Codebase Refactoring
+
+The current codebase is functional but could be significantly improved by adopting modern JavaScript and TypeScript features.
+
+### Modern JavaScript Classes
+
+The existing codebase is written in a prototype-based style. We plan to refactor the entire library to use modern JavaScript classes (`class` syntax). This will improve readability, maintainability, and make the code easier to understand for new contributors.
+
+**Benefits:**
+
+- Improved code structure and organization.
+- Easier to reason about inheritance and object-oriented patterns.
+- Better alignment with modern JavaScript best practices.
+
+### TypeScript Rewrite
+
+A full rewrite of the library in TypeScript is a long-term goal. This would bring the benefits of static typing, improved developer tooling, and a more robust codebase.
+
+**Benefits:**
+
+- **Type Safety:** Catch errors at compile-time instead of runtime.
+- **Improved Autocomplete:** Better editor support and developer experience.
+- **Self-documenting Code:** Types make the code easier to understand and use.
+- **Easier Refactoring:** Static analysis makes it easier to refactor code with confidence.
+
+We believe these changes will make `node-firebird` a more robust, modern, and developer-friendly library for accessing Firebird databases.

package/lib/index.d.ts

@@ -31,9 +31,19 @@ declare module 'node-firebird' {
 
     export type Isolation = number[];
 
+    export type TransactionOptions = {
+        autoCommit?: boolean;
+        autoUndo?: boolean;
+        isolation?: Isolation;
+        ignoreLimbo?: boolean;
+        readOnly?: boolean;
+        wait?: boolean;
+        waitTimeout?: number;
+    };
+
     export interface Database {
         detach(callback?: SimpleCallback): Database;
-        transaction(isolation: Isolation, callback: TransactionCallback): Database;
+        transaction(options: TransactionOptions|Isolation|TransactionCallback, callback?: TransactionCallback): Database;
         query(query: string, params: any[], callback: QueryCallback): Database;
         execute(query: string, params: any[], callback: QueryCallback): Database;
         sequentially(query: string, params: any[], rowCallback: SequentialCallback, callback: SimpleCallback, asArray?: boolean): Database;

package/lib/wire/connection.js

@@ -1,5 +1,4 @@
 const Events = require('events');
-const net = require('net');
 const os = require('os');
 const path = require('path');
 const BigInt = require('big-integer');
@@ -15,6 +14,7 @@ const Database = require('./database');
 const Statement = require('./statement');
 const Transaction = require('./transaction');
 const {lookupMessages, noop, parseDate} = require('../utils');
+const Socket = require("./socket");
 
 /***************************************
  *
@@ -32,13 +32,14 @@ var Connection = function (host, port, callback, options, db, svc) {
     this._detachTimeout;
     this._detachCallback;
     this._detachAuto;
-    this._socket = net.createConnection(port, host);
+    this._socket = new Socket(port, host);
     this._pending = [];
     this._isOpened = false;
     this._isClosed = false;
     this._isDetach = false;
     this._isUsed = false;
     this._pooled = options.isPool||false;
+    if (options && options.blobChunkSize > 65535) options.blobChunkSize = 65535;
     this.options = options;
     this._bind_events(host, port, callback);
     this.error;
@@ -368,12 +369,14 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     protocolVersion: data.readInt(),
                     protocolArchitecture: data.readInt(),
                     protocolMinimumType: data.readInt(),
+                    compress: false,
                     pluginName: '',
                     authData: '',
                     sessionKey: ''
                 };
 
-                accept.protocolMinimumType = accept.protocolMinimumType & 0xFF;
+                accept.compress = (accept.protocolMinimumType & Const.pflag_compress) !== 0;
+                accept.protocolMinimumType = accept.protocolMinimumType & Const.ptype_mask;
                 //accept.compress = (accept.acceptType & pflag_compress) !== 0; // TODO Handle zlib compression
                 if (accept.protocolVersion < 0) {
                     accept.protocolVersion = (accept.protocolVersion & Const.FB_PROTOCOL_MASK) | Const.FB_PROTOCOL_FLAG;
@@ -450,6 +453,10 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     }
                 }
 
+                if (accept.compress) {
+                    cnx._socket.enableCompression();
+                }
+
                 return cb(undefined, accept);
             case Const.op_cont_auth:
                 var d = new BlrReader(data.readArray());
@@ -577,7 +584,7 @@ Connection.prototype.sendOpContAuth = function(authData, authDataEnc, pluginName
     this._socket.write(msg.getData());
 }
 
-Connection.prototype._queueEvent = function(callback){
+Connection.prototype._queueEvent = function(callback, defer = false){
     var self = this;
 
     if (self._isClosed) {
@@ -586,8 +593,14 @@ Connection.prototype._queueEvent = function(callback){
         return;
     }
 
-    self._queue.push(callback);
-    self._socket.write(self._msg.getData());
+    const canDefer = defer && this.accept.protocolVersion >= Const.PROTOCOL_VERSION11;
+
+    self._socket.write(self._msg.getData(), canDefer);
+    if (canDefer && callback) {
+        callback();
+    } else {
+        self._queue.push(callback);
+    }
 };
 
 Connection.prototype.connect = function (options, callback) {
@@ -633,7 +646,11 @@ Connection.prototype.connect = function (options, callback) {
         msg.addInt(protocol[0]); // Version
         msg.addInt(protocol[1]); // Architecture
         msg.addInt(protocol[2]); // Min type
-        msg.addInt(protocol[3]); // Max type
+        if (protocol[0] >= Const.PROTOCOL_VERSION13 && options.wireCompression) {
+            msg.addInt(protocol[3] | Const.pflag_compress); // Max type with compress flag
+        } else {
+            msg.addInt(protocol[3]); // Max type
+        }
         msg.addInt(protocol[4]); // Preference weight
     }
 
@@ -845,14 +862,34 @@ Connection.prototype.throwClosed = function(callback) {
     return this;
 };
 
-Connection.prototype.startTransaction = function(isolation, callback) {
+Connection.prototype.startTransaction = function(options, callback) {
 
-    if (typeof(isolation) === 'function') {
-        var tmp = isolation;
-        isolation = callback;
+    if (typeof(options) === 'function') {
+        var tmp = options;
+        options = callback;
         callback = tmp;
     }
 
+    // Compatibility
+    if (Array.isArray(options)) {
+        options = {
+            isolation: options,
+            readOnly: (options === Const.ISOLATION_READ_COMMITTED_READ_ONLY),
+        };
+    }
+
+    // Default options
+    options = Object.assign({
+        autoCommit: false,
+        autoUndo: true,
+        isolation: Const.ISOLATION_READ_COMMITTED,
+        ignoreLimbo: false,
+        //lock: [],
+        readOnly: false,
+        wait: true,
+        waitTimeout: 0,
+    }, options);
+
     if (this._isClosed)
         return this.throwClosed(callback);
 
@@ -865,13 +902,44 @@ Connection.prototype.startTransaction = function(isolation, callback) {
     blr.pos = 0;
     msg.pos = 0;
 
-    blr.addBytes(isolation || Const.ISOLATION_REPEATABLE_READ);
+    blr.addByte(Const.isc_tpb_version3);
+    blr.addBytes(options.isolation);
+    blr.addByte(options.readOnly ? Const.isc_tpb_read : Const.isc_tpb_write);
+    if (options.wait) {
+        blr.addByte(Const.isc_tpb_wait);
+
+        if (options.waitTimeout) {
+            blr.addNumeric(Const.isc_tpb_lock_timeout, options.waitTimeout);
+        }
+    } else {
+        blr.addByte(Const.isc_tpb_nowait);
+    }
+    if (!options.autoUndo) {
+        blr.addByte(Const.isc_tpb_no_auto_undo);
+    }
+    if (options.autoCommit) {
+        blr.addByte(Const.isc_tpb_autocommit);
+    }
+    if (options.ignoreLimbo) {
+        blr.addByte(Const.isc_tpb_ignore_limbo);
+    }
+    // TODO
+    /*if (options.lock.length) {
+        for (let table of options.lock) {
+            const lockMode = table.write ? Const.isc_tpb_lock_write : Const.isc_tpb_lock_read;
+            const lockType = table.protected ? Const.isc_tpb_protected : Const.isc_tpb_shared;
+
+            blr.addString(lockMode, table.table || table, Const.DEFAULT_ENCODING);
+            blr.addByte(lockType);
+        }
+    }*/
+
     msg.addInt(Const.op_transaction);
     msg.addInt(this.dbhandle);
     msg.addBlr(blr);
     callback.response = new Transaction(this);
 
-    this.db.emit('transaction', isolation);
+    this.db.emit('transaction', options);
     this._queueEvent(callback);
 };
 
@@ -966,7 +1034,8 @@ Connection.prototype.dropStatement = function (statement, callback) {
     msg.addInt(Const.op_free_statement);
     msg.addInt(statement.handle);
     msg.addInt(Const.DSQL_drop);
-    this._queueEvent(callback);
+
+    this._queueEvent(callback, true);
 };
 
 Connection.prototype.closeStatement = function (statement, callback) {
@@ -983,7 +1052,7 @@ Connection.prototype.closeStatement = function (statement, callback) {
     msg.addInt(statement.handle);
     msg.addInt(Const.DSQL_close);
 
-    this._queueEvent(callback);
+    this._queueEvent(callback, true);
 };
 
 Connection.prototype.allocateAndPrepareStatement = function (transaction, query, plan, callback) {
@@ -1259,8 +1328,11 @@ Connection.prototype.executeStatement = function(transaction, statement, params,
                 else if (!isStream)
                     b = Buffer.from(JSON.stringify(value), Const.DEFAULT_ENCODING);
 
+                // Use configured transfer size or default to 1024
+                var chunkSize = self.options.blobChunkSize || 1024;
+
                 if (Buffer.isBuffer(b)) {
-                    bufferReader(b, 1024, function(b, next) {
+                    bufferReader(b, chunkSize, function (b, next) {
                         self.batchSegments(blob, b, next);
                     }, function() {
                         ret[index] = new Xsql.SQLParamQuad(blob.oid);
@@ -1273,9 +1345,20 @@ Connection.prototype.executeStatement = function(transaction, statement, params,
                 var isEnd = false;
 
                 value.on('data', function(chunk) {
+                    // Optimization: If chunk is smaller than transfer size, send directly
+                    if (chunk.length <= chunkSize) {
+                        self.batchSegments(blob, chunk, function () {
+                            if (isEnd && !isReading) {
+                                ret[index] = new Xsql.SQLParamQuad(blob.oid);
+                                self.closeBlob(blob, callback);
+                            }
+                        });
+                        return;
+                    }
+
                     value.pause();
                     isReading = true;
-                    bufferReader(chunk, 1024, function(b, next) {
+                    bufferReader(chunk, chunkSize, function (b, next) {
                         self.batchSegments(blob, b, next);
                     }, function() {
                         isReading = false;
@@ -1292,8 +1375,12 @@ Connection.prototype.executeStatement = function(transaction, statement, params,
                     isEnd = true;
                     if (isReading)
                         return;
-                    ret[index] = new Xsql.SQLParamQuad(blob.oid);
-                    self.closeBlob(blob, callback);
+                    // If we are not currently reading (paused), close immediately
+                    // If we are reading, the callback in batchSegments/bufferReader will handle closure
+                    if (!isReading) {
+                        ret[index] = new Xsql.SQLParamQuad(blob.oid);
+                        self.closeBlob(blob, callback);
+                    }
                 });
             });
         }
@@ -1717,7 +1804,7 @@ Connection.prototype.closeBlob = function(blob, callback) {
     msg.pos = 0;
     msg.addInt(Const.op_close_blob);
     msg.addInt(blob.handle);
-    this._queueEvent(callback);
+    this._queueEvent(callback, true);
 };
 
 Connection.prototype.getSegment = function(blob, callback) {

package/lib/wire/const.js

@@ -435,11 +435,11 @@ const tpb = {
 };
 
 const transactionIsolation = {
-    ISOLATION_READ_UNCOMMITTED         : [tpb.isc_tpb_version3, tpb.isc_tpb_write, tpb.isc_tpb_wait, tpb.isc_tpb_read_committed, tpb.isc_tpb_rec_version],
-    ISOLATION_READ_COMMITTED           : [tpb.isc_tpb_version3, tpb.isc_tpb_write, tpb.isc_tpb_wait, tpb.isc_tpb_read_committed, tpb.isc_tpb_no_rec_version],
-    ISOLATION_REPEATABLE_READ          : [tpb.isc_tpb_version3, tpb.isc_tpb_write, tpb.isc_tpb_wait, tpb.isc_tpb_concurrency],
-    ISOLATION_SERIALIZABLE             : [tpb.isc_tpb_version3, tpb.isc_tpb_write, tpb.isc_tpb_wait, tpb.isc_tpb_consistency],
-    ISOLATION_READ_COMMITTED_READ_ONLY : [tpb.isc_tpb_version3, tpb.isc_tpb_read, tpb.isc_tpb_wait, tpb.isc_tpb_read_committed, tpb.isc_tpb_no_rec_version],
+    ISOLATION_READ_UNCOMMITTED         : [tpb.isc_tpb_read_committed, tpb.isc_tpb_rec_version],
+    ISOLATION_READ_COMMITTED           : [tpb.isc_tpb_read_committed, tpb.isc_tpb_no_rec_version],
+    ISOLATION_REPEATABLE_READ          : [tpb.isc_tpb_concurrency],
+    ISOLATION_SERIALIZABLE             : [tpb.isc_tpb_consistency],
+    ISOLATION_READ_COMMITTED_READ_ONLY : [tpb.isc_tpb_read_committed, tpb.isc_tpb_no_rec_version],
 };
 
 /*************************/

package/lib/wire/database.js

@@ -56,12 +56,12 @@ Database.prototype.detach = function(callback, force) {
     return self;
 };
 
-Database.prototype.transaction = function(isolation, callback) {
-    return this.startTransaction(isolation, callback);
+Database.prototype.transaction = function(options, callback) {
+    return this.startTransaction(options, callback);
 };
 
-Database.prototype.startTransaction = function(isolation, callback) {
-    this.connection.startTransaction(isolation, callback);
+Database.prototype.startTransaction = function(options, callback) {
+    this.connection.startTransaction(options, callback);
     return this;
 };
 

package/lib/wire/serialize.js

@@ -102,7 +102,7 @@ BlrWriter.prototype.addString = function (c, s, encoding) {
 };
 
 BlrWriter.prototype.addBuffer = function (b) {
-    this.addSmall(b.length);
+    this.addWord(b.length);
     this.ensure(b.length);
     b.copy(this.buffer, this.pos);
     this.pos += b.length;

package/lib/wire/socket.js

@@ -0,0 +1,100 @@
+const net = require("net");
+const zlib = require("zlib");
+
+/**
+ * Socket proxy.
+ */
+class Socket {
+    constructor(port, host) {
+        this._socket = net.createConnection(port, host);
+        this._socket.setNoDelay(true);
+        this.compressor = null;
+        this.compressorBuffer = [];
+        this.decompressor = null;
+        this.decompressorBuffer = [];
+        this.buffer = null;
+
+        return new Proxy(this._socket, this);
+    }
+
+    /**
+     * Decompress data when receive it if compression is enabled.
+     * Override on data event.
+     */
+    on(event, cb) {
+        if (event === 'data') {
+            const mainCb = cb;
+            cb = (data) => {
+                if (this.compress) {
+                    this.decompressor.write(data, () => {
+                        mainCb(Buffer.concat(this.decompressorBuffer));
+                        this.decompressorBuffer = []; // Reset buffer
+                    });
+                } else {
+                    mainCb(data);
+                }
+            };
+        }
+
+        this._socket.on(event, cb);
+    }
+
+    /**
+     * Compress data before sending to socket if compression is enabled.
+     */
+    write(data, defer = false) {
+        if (defer) {
+            this.buffer = Buffer.from(data);
+            return;
+        }
+
+        if (!defer && this.buffer) {
+            data = Buffer.concat([this.buffer, data]);
+            this.buffer = null;
+        }
+
+        if (this.compress) {
+            this.compressor.write(data, () => {
+                this._socket.write(Buffer.concat(this.compressorBuffer));
+                this.compressorBuffer = []; // Reset buffer
+            });
+        } else {
+            this._socket.write(data);
+        }
+    }
+
+    /**
+     * Enable compression/decompression on the fly.
+     */
+    enableCompression() {
+        this.compress = true;
+
+        // Create decompressor instance
+        this.decompressor = zlib.createInflate();
+        this.decompressor.on('data', (inflate) => {
+            this.decompressorBuffer.push(inflate);
+        });
+
+        // Create compressor instance
+        this.compressor = zlib.createDeflate({
+            flush: zlib.constants.Z_FULL_FLUSH,
+            finishFlush: zlib.constants.Z_SYNC_FLUSH
+        });
+        this.compressor.on('data', (deflate) => {
+            this.compressorBuffer.push(deflate);
+        });
+    }
+
+    /**
+     * Proxy trap.
+     */
+    get(target, field) {
+        if (field in this) {
+            return this[field].bind(this);
+        }
+
+        return target[field];
+    }
+}
+
+module.exports = Socket;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-firebird",
-    "version": "1.1.9",
+    "version": "1.1.10",
     "description": "Pure JavaScript and Asynchronous Firebird client for Node.js.",
     "keywords": [
         "firebird",
@@ -11,7 +11,7 @@
     "homepage": "https://github.com/hgourvest/node-firebird",
     "repository": {
         "type": "git",
-        "url": "https://github.com/hgourvest/node-firebird"
+        "url": "git+https://github.com/hgourvest/node-firebird.git"
     },
     "author": {
         "name": "Henri Gourvest",

package/.travis.yml

@@ -1,23 +0,0 @@
-language: node_js
-
-node_js:
-  - lts/*
-  - v10  
-
-notifications:
-  email:
-  - mapopa@gmail.com  
-
-env:
-  - FIREBIRD_DATA="/var/lib/firebird/2.5/data"
-
-before_install:
-  - sudo apt-get update -qq
-  - sudo DEBIAN_FRONTEND=noninteractive apt-get install -qq firebird2.5-superclassic 
-  - sudo gsec -modify SYSDBA -pw masterkey
-
-script:
-  - nyc npm test
-  
-after_script:
-  - nyc report --reporter=text-lcov | coveralls