node-firebird 2.3.4 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-firebird",
-    "version": "2.3.4",
+    "version": "2.4.0",
     "description": "Pure JavaScript and Asynchronous Firebird client for Node.js.",
     "keywords": [
         "firebird",
@@ -21,18 +21,26 @@
         "Popa Marius Adrian <mapopa@gmail.com>",
         "Peter Širka <petersirka@gmail.com>"
     ],
-    "main": "./lib",
+    "main": "./lib/index.js",
     "types": "./lib/index.d.ts",
+    "files": [
+        "lib",
+        "src"
+    ],
     "license": "MPL-2.0",
     "scripts": {
+        "build": "tsc -p tsconfig.json && node -e \"require('fs').copyFileSync('src/firebird.msg','lib/firebird.msg')\"",
+        "prepare": "npm run build",
+        "pretest": "npm run build",
+        "typecheck": "tsc -p tsconfig.test.json",
         "test": "vitest run",
         "lint": "oxlint"
     },
-    "dependencies": {
-    },
     "devDependencies": {
+        "@types/node": "^26.1.1",
         "coveralls-next": "^6.0.1",
         "oxlint": "^0.15.11",
+        "typescript": "^7.0.2",
         "vitest": "^4.0.18"
     }
 }

package/src/callback.ts

@@ -0,0 +1,55 @@
+/** A single Firebird status-vector entry (gds code plus optional parameters). */
+export interface FbStatusItem {
+    gdscode: number;
+    params?: any[];
+}
+
+/** Error-like object produced by the wire protocol layer. */
+export interface FbStatusObject {
+    status?: FbStatusItem[];
+    message?: string;
+    sqlcode?: number;
+}
+
+/** An Error enriched with the Firebird gds code and its parameters. */
+export interface FbError extends Error {
+    gdscode?: number;
+    gdsparams?: any[];
+}
+
+export type SimpleCallback = (err?: any) => void;
+export type Callback<T = any> = (err?: any, result?: T) => void;
+
+export function doError(obj: any, callback?: (...args: any[]) => void): void {
+    if (callback)
+        callback(obj)
+}
+
+function isError(obj: any): obj is FbStatusObject {
+    return Boolean(
+        obj != null && typeof obj === "object" && !Array.isArray(obj) && obj.status
+    );
+}
+
+export function doCallback<T>(obj: T, callback?: Callback<T>): void {
+
+    if (!callback)
+        return;
+
+    if (obj instanceof Error) {
+        callback(obj);
+        return;
+    }
+
+    if (isError(obj)) {
+        var error: FbError = new Error(obj.message);
+        var status = obj.status && obj.status.length && obj.status[0] || {} as FbStatusItem;
+        error.gdscode = status.gdscode; // main error gds code
+        error.gdsparams = status.params; // parameters (constraint name, table, etc.)
+        callback(error);
+        return;
+    }
+
+    callback(undefined, obj);
+
+}

package/{poc/node_modules/node-firebird/lib/gdscodes.js → src/gdscodes.ts}

@@ -1522,10 +1522,10 @@ const GDSCode = {
     FBSVCMGR_SWITCH_UNKNOWN: 336986118
 };
 
-+function makeEnum(_enum) {
-    for (k in _enum)
++function makeEnum(_enum: any) {
+    for (var k in _enum)
         _enum[_enum[k]] = k;
     Object.freeze(_enum);
 }(GDSCode);
 
-module.exports = { GDSCode };
+export { GDSCode };

package/{poc/node_modules/node-firebird/lib/ieee754-decimal.js → src/ieee754-decimal.ts}

@@ -41,7 +41,7 @@ const DECIMAL128_SNAN_HIGH = 0x7E00000000000000n;
  * @param {number|string|BigInt} value - The value to encode
  * @returns {Buffer} - 8-byte buffer containing the Decimal64 encoding
  */
-function encodeDecimal64(value) {
+export function encodeDecimal64(value: number | string | bigint | Buffer | null | undefined): Buffer {
     // Handle special cases
     if (value === null || value === undefined) {
         return Buffer.alloc(8);
@@ -156,7 +156,7 @@ function encodeDecimal64(value) {
  * @param {Buffer} buffer - 8-byte buffer containing the Decimal64 encoding
  * @returns {string|number} - Decoded value as string or special value
  */
-function decodeDecimal64(buffer) {
+export function decodeDecimal64(buffer: Buffer): string | number {
     if (buffer.length !== 8) {
         throw new Error('Decimal64 buffer must be 8 bytes');
     }
@@ -240,7 +240,7 @@ function decodeDecimal64(buffer) {
  * @param {number|string|BigInt} value - The value to encode
  * @returns {Buffer} - 16-byte buffer containing the Decimal128 encoding
  */
-function encodeDecimal128(value) {
+export function encodeDecimal128(value: number | string | bigint | Buffer | null | undefined): Buffer {
     // Handle special cases
     if (value === null || value === undefined) {
         return Buffer.alloc(16);
@@ -366,7 +366,7 @@ function encodeDecimal128(value) {
  * @param {Buffer} buffer - 16-byte buffer containing the Decimal128 encoding
  * @returns {string|number} - Decoded value as string or special value
  */
-function decodeDecimal128(buffer) {
+export function decodeDecimal128(buffer: Buffer): string | number {
     if (buffer.length !== 16) {
         throw new Error('Decimal128 buffer must be 16 bytes');
     }
@@ -454,7 +454,7 @@ function decodeDecimal128(buffer) {
  * @param {number} size - Buffer size in bytes
  * @returns {Buffer}
  */
-function bigIntToBuffer(value, size) {
+function bigIntToBuffer(value: bigint, size: number): Buffer {
     const buf = Buffer.alloc(size);
     let val = BigInt(value.toString());
     for (let i = size - 1; i >= 0; i--) {
@@ -469,7 +469,7 @@ function bigIntToBuffer(value, size) {
  * @param {Buffer} buffer
  * @returns {BigInt}
  */
-function bufferToBigInt(buffer) {
+function bufferToBigInt(buffer: Buffer): bigint {
     let result = 0n;
     for (let i = 0; i < buffer.length; i++) {
         result = (result << 8n) | BigInt(buffer[i]);
@@ -484,17 +484,10 @@ function bufferToBigInt(buffer) {
  * @param {number} offset
  * @param {number} size
  */
-function bufferWriteBigInt(buffer, value, offset, size) {
+function bufferWriteBigInt(buffer: Buffer, value: bigint, offset: number, size: number): void {
     let val = BigInt(value.toString());
     for (let i = offset + size - 1; i >= offset; i--) {
         buffer[i] = Number(val & 0xFFn);
         val >>= 8n;
     }
 }
-
-module.exports = {
-    encodeDecimal64,
-    decodeDecimal64,
-    encodeDecimal128,
-    decodeDecimal128
-};

package/src/index.ts

@@ -0,0 +1,157 @@
+import Const from './wire/const';
+import { doError, doCallback } from './callback';
+import Connection from './wire/connection';
+import Pool from './pool';
+import { escape as escapeValue } from './utils';
+import type {
+    Options,
+    SvcMgrOptions,
+    DatabaseCallback,
+    ServiceManagerCallback,
+    SimpleCallback,
+    ConnectionPool,
+} from './types';
+
+export * from './types';
+export { GDSCode } from './gdscodes';
+
+if (typeof(setImmediate) === 'undefined') {
+    (global as any).setImmediate = function(cb: () => void) {
+        process.nextTick(cb);
+    };
+}
+
+export const AUTH_PLUGIN_LEGACY: string = Const.AUTH_PLUGIN_LEGACY;
+export const AUTH_PLUGIN_SRP: string = Const.AUTH_PLUGIN_SRP;
+export const AUTH_PLUGIN_SRP256: string = Const.AUTH_PLUGIN_SRP256;
+export const AUTH_PLUGIN_SRP384: string = Const.AUTH_PLUGIN_SRP384;
+export const AUTH_PLUGIN_SRP512: string = Const.AUTH_PLUGIN_SRP512;
+
+export const WIRE_CRYPT_DISABLE: number = Const.WIRE_CRYPT_DISABLE;
+export const WIRE_CRYPT_ENABLE: number = Const.WIRE_CRYPT_ENABLE;
+
+/** A transaction sees changes done by uncommitted transactions. */
+export const ISOLATION_READ_UNCOMMITTED: number[] = Const.ISOLATION_READ_UNCOMMITTED;
+/** A transaction sees only data committed before the statement has been executed. */
+export const ISOLATION_READ_COMMITTED: number[] = Const.ISOLATION_READ_COMMITTED;
+/** A transaction sees during its lifetime only data committed before the transaction has been started. */
+export const ISOLATION_REPEATABLE_READ: number[] = Const.ISOLATION_REPEATABLE_READ;
+/**
+ * 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[] = Const.ISOLATION_SERIALIZABLE;
+export const ISOLATION_READ_COMMITTED_READ_ONLY: number[] = Const.ISOLATION_READ_COMMITTED_READ_ONLY;
+
+export const escape = escapeValue;
+
+/**
+ * The most recent Connection created by attach()/create()/attachOrCreate().
+ * Kept for backwards compatibility with the previous CommonJS module where
+ * the connection was stored on the module object itself.
+ */
+export let connection: Connection | undefined;
+
+export function attach(options: Options, callback: DatabaseCallback): void;
+export function attach(options: SvcMgrOptions, callback: ServiceManagerCallback): void;
+export function attach(options: any, callback: any): void {
+    var host = options.host || Const.DEFAULT_HOST;
+    var port = options.port || Const.DEFAULT_PORT;
+    var manager = options.manager || false;
+    var cnx = connection = new Connection(host, port, function(err: any) {
+
+        if (err) {
+            doError(err, callback);
+            return;
+        }
+
+        cnx.connect(options, function(err: any) {
+            if (err) {
+                doError(err, callback);
+            } else {
+                if (manager)
+                    cnx.svcattach(options, callback);
+                else
+                    cnx.attach(options, callback);
+            }
+        });
+
+    }, options);
+}
+
+export function drop(options: Options, callback: SimpleCallback): void {
+	attach(options, function(err: any, db: any) {
+		if (err) {
+			callback({ error: err, message: "Drop error" });
+			return;
+		}
+
+		db.drop(callback);
+	});
+}
+
+export function create(options: Options, callback: DatabaseCallback): void {
+    var host = options.host || Const.DEFAULT_HOST;
+    var port = options.port || Const.DEFAULT_PORT;
+    var cnx = connection = new Connection(host, port, function(err: any) {
+
+        var self = cnx;
+
+        if (err) {
+            callback({ error: err, message: "Connect error" }, undefined as any);
+            return;
+        }
+
+        cnx.connect(options, function(err: any) {
+            if (err) {
+                if (self.db) self.db.emit('error', err);
+                doError(err, callback);
+                return;
+            }
+
+            cnx.createDatabase(options, callback);
+        });
+    }, options);
+}
+
+export function attachOrCreate(options: Options, callback: DatabaseCallback): void {
+
+    var host = options.host || Const.DEFAULT_HOST;
+    var port = options.port || Const.DEFAULT_PORT;
+
+    var cnx = connection = new Connection(host, port, function(err: any) {
+
+        var self = cnx;
+
+        if (err) {
+            callback({ error: err, message: "Connect error" }, undefined as any);
+            return;
+        }
+
+        cnx.connect(options, function(err: any) {
+
+            if (err) {
+                doError(err, callback);
+                return;
+            }
+
+            cnx.attach(options, function(err: any, ret: any) {
+
+                if (!err) {
+                    if (self.db)
+                        self.db.emit('connect', ret);
+                    doCallback(ret, callback);
+                    return;
+                }
+
+                cnx.createDatabase(options, callback);
+            });
+        });
+
+    }, options);
+}
+
+// Pooling
+export function pool(max: number, options: Options): ConnectionPool {
+	return new Pool(attach, max, Object.assign({}, options, { isPool: true }));
+}

package/{poc/node_modules/node-firebird/lib/messages.js → src/messages.ts}

@@ -1,162 +1,163 @@
-var fs = require('fs');
-
-const
-    //ISC_MASK   = 0x14000000, // Defines the code as a valid ISC code
-    FAC_MASK   = 0x00FF0000, // Specifies the facility where the code is located
-    CODE_MASK  = 0x0000FFFF, // Specifies the code in the message file
-    CLASS_MASK = 0xF0000000; // Defines the code as warning, error, info, or other
-
-var msgNumber = exports.msgNumber = function(facility, code) {
-    return (facility * 10000 + code);
-};
-
-var getCode = exports.getCode = function(code) {
-    return (code & CODE_MASK)
-};
-
-var getFacility = exports.getFacility =  function(code) {
-    return (code & FAC_MASK) >> 16;
-};
-
-exports.getClass = function(code) {
-    return (code & CLASS_MASK) >> 28;
-};
-
-exports.lookupMessages = function(status, messageFile, callback){
-
-    var handle;
-    var bucket_size;
-    var top_tree;
-    var levels;
-    var buffer;
-
-    function lookup(item, callback) {
-
-        var code = msgNumber(getFacility(item.gdscode), getCode(item.gdscode));
-
-        function readIndex(stackSize, position) {
-
-            function readNode(from) {
-                var ret = {};
-                ret.code = buffer.readUInt32LE(from);
-                ret.seek = buffer.readUInt32LE(from + 4);
-                return ret;
-            }
-
-            fs.read(handle, buffer, 0, bucket_size, position, function(err, bufferSize) {
-
-                if (bufferSize <= 0) {
-                    callback();
-                    return;
-                }
-
-                if (stackSize === levels) {
-                    search();
-                    return;
-                }
-
-                var from = 0;
-                var node = readNode(from);
-
-                while (true) {
-
-                    if (node.code >= code)
-                    {
-                        readIndex(stackSize + 1, node.seek);
-                        break;
-                    }
-
-                    from += 8;
-                    if (from >= bufferSize)
-                    {
-                        callback();
-                        break;
-                    }
-
-                    node = readNode(from);
-                }
-            });
-        }
-
-        function search() {
-
-            function readRec(from) {
-
-                function align(v) {
-                    return (v + 3) & ~3;
-                }
-
-                var ret = {};
-                ret.code = buffer.readUInt32LE(from);
-                ret.length = buffer.readUInt16LE(from + 4);
-
-                if (ret.code == code){
-                    from += 8;
-                    ret.text = buffer.toString(undefined, from, from + ret.length);
-                } else
-                    ret.seek = from + align(8 + ret.length, 4);
-
-                return ret;
-            }
-
-            var rec = readRec(0);
-
-            while (rec.seek) {
-                if (rec.seek >= buffer.length)
-                    break;
-                else
-                    rec = readRec(rec.seek);
-            }
-
-            var str = rec.text;
-            if (item.params) {
-                for (var i = 0; i < item.params.length; i++)
-                    str = str.replace('@' + String(i+1), item.params[i]);
-            }
-
-            callback(str);
-        }
-
-        readIndex(1, top_tree);
-    }
-
-    fs.open(messageFile, 'r', function(err, h) {
-
-        if (!h) {
-            callback();
-            return;
-        }
-
-        buffer = Buffer.alloc(14);
-        fs.read(h, buffer, 0, 14, 0, function(){
-
-            handle = h;
-            bucket_size = buffer.readUInt16LE(2);
-            top_tree = buffer.readUInt32LE(4);
-            levels = buffer.readUInt16LE(12);
-            buffer = Buffer.alloc(bucket_size);
-
-            var i = 0;
-            var text;
-
-            function loop() {
-                lookup(status[i], function(line) {
-                    if (text)
-                        text = text + ', ' + line
-                    else
-                        text = line;
-
-                    if (i === status.length - 1) {
-                        fs.closeSync(handle);
-                        callback(text);
-                    } else {
-                        i++;
-                        loop();
-                    }
-                });
-            }
-
-            loop(0);
-        });
-    });
-};
+import fs from 'fs';
+import type { FbStatusItem } from './callback';
+
+const
+    //ISC_MASK   = 0x14000000, // Defines the code as a valid ISC code
+    FAC_MASK   = 0x00FF0000, // Specifies the facility where the code is located
+    CODE_MASK  = 0x0000FFFF, // Specifies the code in the message file
+    CLASS_MASK = 0xF0000000; // Defines the code as warning, error, info, or other
+
+export const msgNumber = function(facility: number, code: number): number {
+    return (facility * 10000 + code);
+};
+
+export const getCode = function(code: number): number {
+    return (code & CODE_MASK)
+};
+
+export const getFacility = function(code: number): number {
+    return (code & FAC_MASK) >> 16;
+};
+
+export const getClass = function(code: number): number {
+    return (code & CLASS_MASK) >> 28;
+};
+
+export const lookupMessages = function(status: FbStatusItem[], messageFile: string, callback: (text?: string) => void): void {
+
+    var handle: number;
+    var bucket_size: number;
+    var top_tree: number;
+    var levels: number;
+    var buffer: Buffer;
+
+    function lookup(item: FbStatusItem, callback: (text?: string) => void) {
+
+        var code = msgNumber(getFacility(item.gdscode), getCode(item.gdscode));
+
+        function readIndex(stackSize: number, position: number) {
+
+            function readNode(from: number) {
+                var ret: any = {};
+                ret.code = buffer.readUInt32LE(from);
+                ret.seek = buffer.readUInt32LE(from + 4);
+                return ret;
+            }
+
+            fs.read(handle, buffer, 0, bucket_size, position, function(err, bufferSize) {
+
+                if (bufferSize <= 0) {
+                    callback();
+                    return;
+                }
+
+                if (stackSize === levels) {
+                    search();
+                    return;
+                }
+
+                var from = 0;
+                var node = readNode(from);
+
+                while (true) {
+
+                    if (node.code >= code)
+                    {
+                        readIndex(stackSize + 1, node.seek);
+                        break;
+                    }
+
+                    from += 8;
+                    if (from >= bufferSize)
+                    {
+                        callback();
+                        break;
+                    }
+
+                    node = readNode(from);
+                }
+            });
+        }
+
+        function search() {
+
+            function readRec(from: number) {
+
+                function align(v: number) {
+                    return (v + 3) & ~3;
+                }
+
+                var ret: any = {};
+                ret.code = buffer.readUInt32LE(from);
+                ret.length = buffer.readUInt16LE(from + 4);
+
+                if (ret.code == code){
+                    from += 8;
+                    ret.text = buffer.toString(undefined, from, from + ret.length);
+                } else
+                    ret.seek = from + align(8 + ret.length);
+
+                return ret;
+            }
+
+            var rec = readRec(0);
+
+            while (rec.seek) {
+                if (rec.seek >= buffer.length)
+                    break;
+                else
+                    rec = readRec(rec.seek);
+            }
+
+            var str = rec.text;
+            if (item.params) {
+                for (var i = 0; i < item.params.length; i++)
+                    str = str.replace('@' + String(i+1), item.params[i]);
+            }
+
+            callback(str);
+        }
+
+        readIndex(1, top_tree);
+    }
+
+    fs.open(messageFile, 'r', function(err, h) {
+
+        if (!h) {
+            callback();
+            return;
+        }
+
+        buffer = Buffer.alloc(14);
+        fs.read(h, buffer, 0, 14, 0, function(){
+
+            handle = h;
+            bucket_size = buffer.readUInt16LE(2);
+            top_tree = buffer.readUInt32LE(4);
+            levels = buffer.readUInt16LE(12);
+            buffer = Buffer.alloc(bucket_size);
+
+            var i = 0;
+            var text;
+
+            function loop() {
+                lookup(status[i], function(line) {
+                    if (text)
+                        text = text + ', ' + line
+                    else
+                        text = line;
+
+                    if (i === status.length - 1) {
+                        fs.closeSync(handle);
+                        callback(text);
+                    } else {
+                        i++;
+                        loop();
+                    }
+                });
+            }
+
+            loop();
+        });
+    });
+};