node-firebird 0.9.9 → 1.1.0

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

@@ -0,0 +1,78 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-16.04, ubuntu-18.04, windows-2019, macos-10.15]
+        node-version: [10.x, 12.x, 14.x, 15.x]
+
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        fetch-depth: 10
+
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - name: Firebird install (Linux)
+      if: matrix.os == 'ubuntu-16.04' || matrix.os == 'ubuntu-18.04'
+      run: |
+        if [ `lsb_release -rs` = '16.04' ]
+        then
+            sudo apt-get install libtommath0
+        else
+            sudo apt-get install libtommath1
+            sudo ln -s /usr/lib/x86_64-linux-gnu/libtommath.so.1 /usr/lib/x86_64-linux-gnu/libtommath.so.0
+        fi
+        wget -nv -O Firebird-3.0.7.33374-0.amd64.tar.gz "https://github.com/FirebirdSQL/firebird/releases/download/R3_0_7/Firebird-3.0.7.33374-0.amd64.tar.gz"
+        tar xzvf Firebird-3.0.7.33374-0.amd64.tar.gz
+        (cd Firebird-3.0.7.33374-0.amd64; sudo ./install.sh -silent)
+        sudo usermod -a -G firebird `whoami`
+
+    - name: Firebird install (MacOS)
+      if: matrix.os == 'macos-10.15'
+      run: |
+        wget -nv -O Firebird-3.0.7-33374-x86_64.pkg "https://github.com/FirebirdSQL/firebird/releases/download/R3_0_7/Firebird-3.0.7-33374-x86_64.pkg"
+        sudo installer -verbose -pkg "Firebird-3.0.7-33374-x86_64.pkg" -target /
+        
+    - name: Firebird install (Windows)
+      if: matrix.os == 'windows-2019'
+      shell: cmd
+      run: |
+        set FB_ZIP=Firebird-3.0.7.33374-1_x64.zip
+        powershell Invoke-WebRequest "https://github.com/FirebirdSQL/firebird/releases/download/R3_0_7/$env:FB_ZIP" -OutFile "$env:FB_ZIP"
+        7z x -oC:\Firebird %FB_ZIP%
+
+    - name: Build
+      shell: bash
+      run: |
+        npm ci         
+
+    - name: Test (Linux)
+      if: matrix.os == 'ubuntu-16.04' || matrix.os == 'ubuntu-18.04'
+      run: |
+        sg firebird -c "npx nyc npm test"
+
+    - name: Test (MacOS)
+      if: matrix.os == 'macos-10.15'
+      run: |
+        sudo mkdir `pwd`/tmp-node-fb
+        sudo chmod 777 `pwd`/tmp-node-fb
+        export ISC_USER=sysdba
+        export ISC_PASSWORD=masterkey
+        export NODE_FB_TEST_TMP_DIR=`pwd`/tmp-node-fb
+        npx nyc npm test
+
+    - name: Test (Windows)
+      if: matrix.os == 'windows-2019'
+      shell: cmd
+      run: |
+        set PATH=C:\Firebird;%PATH%
+        call npx nyc npm test

package/README.md

@@ -66,7 +66,9 @@ options.password = 'masterkey';
 options.lowercase_keys = false; // set to true to lowercase keys
 options.role = null;            // default
 options.pageSize = 4096;        // default when creating database
-
+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
 ```
 
 ### Classic
@@ -183,7 +185,7 @@ Firebird.attach(options, function(err, db) {
 });
 ```
 
-### Reading Blobs (Aasynchronous)
+### Reading Blobs (Asynchronous)
 
 ```js
 Firebird.attach(options, function(err, db) {
@@ -222,6 +224,73 @@ Firebird.attach(options, function(err, db) {
 });
 ```
 
+### Reading Multiples Blobs (Asynchronous)
+```js
+Firebird.attach(options, (err, db) => {
+    if (err)
+        throw err;
+
+    db.transaction(Firebird.ISOLATION_READ_COMMITED, (err, transaction) => {
+        if (err) {
+            throw err;
+        }
+
+        transaction.query('SELECT FIRST 10 * FROM JOB', (err, result) => {
+            if (err) {
+                transaction.rollback();
+                return;
+            }
+
+            const arrBlob = [];
+            for (const item of result) {
+                const fields = Object.keys(item);
+                for (const key of fields) {
+                    if (typeof item[key] === 'function') {
+                        item[key] = new Promise((resolve, reject) => {
+                            // the same transaction is used (better performance)
+                            // this is optional
+                            item[key](transaction, (error, name, event, row) => {
+                                if (error) {
+                                    return reject(error);
+                                }
+
+                                // reading data
+                                let value = '';
+                                event.on('data', (chunk) => {
+                                    value += chunk.toString('binary');
+                                });
+                                event.on('end', () => {
+                                    resolve({ value, column: name, row });
+                                });
+                            });
+                        });
+                        arrBlob.push(item[key]);
+                    }
+                }
+            }
+
+            Promise.all(arrBlob).then((blobs) => {
+                for (const blob of blobs) {
+                    result[blob.row][blob.column] = blob.value;
+                }
+
+                transaction.commit((err) => {
+                    if (err) {
+                        transaction.rollback();
+                        return;
+                    }
+
+                    db.detach();
+                    console.log(result);
+                });
+            }).catch((err) => {
+                transaction.rollback();
+            });
+        });
+    });
+});
+```
+
 ### Streaming a big data
 
 ```js
@@ -513,7 +582,7 @@ This is why you should use **Firebird 2.5** server at least.
 ### Firebird 3.0 Support
 
 Firebird new wire protocol is not supported yet so
-for Firebird 3.0 you need to add the following in firebird.conf according to Firebird documentation
+for Firebird 3.0 you need to add the following in firebird.conf according to Firebird 3 release notes
 <https://firebirdsql.org/file/documentation/release_notes/html/en/3_0/rnfb30-security-new-authentication.html>
 
 ```bash
@@ -522,6 +591,21 @@ WireCrypt = Disabled
 UserManager = Legacy_UserManager
 ```
 
+Firebird 4 wire protocol is not supported yet so
+for Firebird 4.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 = Disabled
+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>
+
+
+
 ## Contributors
 
 - Henri Gourvest, <https://github.com/hgourvest>

package/lib/index.d.ts

@@ -9,9 +9,23 @@ declare module 'node-firebird' {
     type SimpleCallback = (err: any) => void;
     type SequentialCallback = (row: any, index: number) => void;
 
+    export const AUTH_PLUGIN_LEGACY: string;
+    export const AUTH_PLUGIN_SRP: string;
+    export const AUTH_PLUGIN_SRP256: string;
+
+    export const WIRE_CRYPT_ENABLE: number;
+    export const WIRE_CRYPT_DISABLE: number;
+
+    /** A transaction sees changes done by uncommitted transactions. */
     export const ISOLATION_READ_UNCOMMITTED: number[];
+    /** A transaction sees only data committed before the statement has been executed. */
     export const ISOLATION_READ_COMMITED: number[];
+    /** A transaction sees during its lifetime only data committed before the transaction has been started. */
     export const ISOLATION_REPEATABLE_READ: number[];
+    /**
+     * This is the strictest isolation level, which enforces transaction serialization.
+     * Data accessed in the context of a serializable transaction cannot be accessed by any other transaction.
+     */
     export const ISOLATION_SERIALIZABLE: number[];
     export const ISOLATION_READ_COMMITED_READ_ONLY: number[];
 
@@ -37,6 +51,37 @@ declare module 'node-firebird' {
         rollbackRetaining(callback?: SimpleCallback): void;
     }
 
+    export type SupportedCharacterSet = |
+        'NONE' |
+        'CP943C' |
+        'DOS737' |
+        'DOS775' |
+        'DOS858' |
+        'DOS862' |
+        'DOS864' |
+        'DOS866' |
+        'DOS869' |
+        'GB18030' |
+        'GBK' |
+        'ISO8859_2' |
+        'ISO8859_3' |
+        'ISO8859_4' |
+        'ISO8859_5' |
+        'ISO8859_6' |
+        'ISO8859_7' |
+        'ISO8859_8' |
+        'ISO8859_9' |
+        'ISO8859_13' |
+        'KOI8R' |
+        'KOI8U' |
+        'TIS620' |
+        'UTF8' |
+        'WIN1255' |
+        'WIN1256' |
+        'WIN1257' |
+        'WIN1258' |
+        'WIN_1258';
+
     export interface Options {
         host?: string;
         port?: number;
@@ -46,6 +91,9 @@ declare module 'node-firebird' {
         lowercase_keys?: boolean;
         role?: string;
         pageSize?: number;
+        retryConnectionInterval?: number;
+        encoding?: SupportedCharacterSet;
+        blobAsText?: boolean; // only affects for blob subtype 1
     }
 
     export interface SvcMgrOptions extends Options {
@@ -54,12 +102,12 @@ declare module 'node-firebird' {
 
     export interface ConnectionPool {
         get(callback: DatabaseCallback): void;
-        destroy(): void;
+        destroy(callback?: SimpleCallback): void;
     }
 
     export function attach(options: Options, callback: DatabaseCallback): void;
     export function attach(options: SvcMgrOptions, callback: ServiceManagerCallback): void;
-    export function escape(value: any, protocolVersion: number /*PROTOCOL_VERSION13*/): string;
+    export function escape(value: any, protocolVersion?: number /*PROTOCOL_VERSION13*/): string;
     export function create(options: Options, callback: DatabaseCallback): void;
     export function attachOrCreate(options: Options, callback: DatabaseCallback): void;
     export function pool(max: number, options: Options): ConnectionPool;
@@ -207,18 +255,18 @@ declare module 'node-firebird' {
         backup(options: BackupOptions, callback: ReadableCallback): void;
         nbackup(options: BackupOptions, callback: ReadableCallback): void;
         restore(options: NRestoreOptions, callback: ReadableCallback): void;
-        nrestore(options, callback): void;
+        nrestore(options: any, callback: Function): void;
         setDialect(db: string, dialect: 1 | 3, callback: ReadableCallback): void;
-        setSweepinterval(db: string, interval: number, callback): void; // gfix -h INTERVAL
-        setCachebuffer(db: string, nbpages, callback: ReadableCallback): void; // gfix -b NBPAGES
+        setSweepinterval(db: string, interval: number, callback: Function): void; // gfix -h INTERVAL
+        setCachebuffer(db: string, nbpages: any, callback: ReadableCallback): void; // gfix -b NBPAGES
         BringOnline(db: string, callback: ReadableCallback): void; // gfix -o
         Shutdown(db: string, kind: ShutdownKind, delay: number, mode: ShutdownMode, callback: ReadableCallback): void; // server version >= 2.0
         Shutdown(db: string, kind: ShutdownKind, delay: number, callback: ReadableCallback): void; // server version < 2.0
         setShadow(db: string, val: boolean, callback: ReadableCallback): void;
         setForcewrite(db: string, val: boolean, callback: ReadableCallback): void; // gfix -write
         setReservespace(db: string, val: boolean, callback: ReadableCallback): void; // true: gfix -use reserve, false: gfix -use full
-        setReadonlyMode(db: string, callback: ReadableCallback): void; //  gfix -mode read_only 
-        setReadwriteMode(db: string, callback: ReadableCallback): void; //  gfix -mode read_write 
+        setReadonlyMode(db: string, callback: ReadableCallback): void; //  gfix -mode read_only
+        setReadwriteMode(db: string, callback: ReadableCallback): void; //  gfix -mode read_write
         validate(options: ValidateOptions, callback: ReadableCallback): void; // gfix -validate
         commit(db: string, transactid: number, callback: ReadableCallback): void; // gfix -commit
         rollback(db: string, transactid: number, callback: ReadableCallback): void;