node-firebird 2.3.3 → 2.4.0

package/lib/wire/serialize.js

@@ -1,79 +1,64 @@
-
-const { encodeDecimal64, decodeDecimal64, encodeDecimal128, decodeDecimal128 } = require('../ieee754-decimal');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitSet = exports.XdrReader = exports.XdrWriter = exports.BlrReader = exports.BlrWriter = void 0;
+const ieee754_decimal_1 = require("../ieee754-decimal");
 function align(n) {
     return (n + 3) & ~3;
 }
-
 /***************************************
  *
  *   BLR Writer
  *
  ***************************************/
-
-const
-    MAX_STRING_SIZE = 255;
-
+const MAX_STRING_SIZE = 255;
 class BlrWriter {
     constructor(size) {
         this.buffer = Buffer.alloc(size || 32);
         this.pos = 0;
     }
-
     ensure(len) {
         var newlen = this.buffer.length;
-
         while (newlen < this.pos + len)
-            newlen *= 2
-
+            newlen *= 2;
         if (this.buffer.length >= newlen)
             return;
-
         var b = Buffer.alloc(newlen);
         this.buffer.copy(b);
-        delete(this.buffer);
         this.buffer = b;
     }
-
     addByte(b) {
         this.ensure(1);
         this.buffer.writeUInt8(b, this.pos);
         this.pos++;
     }
-
     addShort(b) {
         this.ensure(1);
         this.buffer.writeInt8(b, this.pos);
         this.pos++;
     }
-
     addSmall(b) {
         this.ensure(2);
         this.buffer.writeInt16LE(b, this.pos);
         this.pos += 2;
     }
-
     addWord(b) {
         this.ensure(2);
         this.buffer.writeUInt16LE(b, this.pos);
         this.pos += 2;
     }
-
     addInt32(b) {
         this.ensure(4);
         this.buffer.writeUInt32LE(b, this.pos);
         this.pos += 4;
     }
-
     addByteInt32(c, b) {
         this.addByte(c);
         this.ensure(4);
         this.buffer.writeUInt32LE(b, this.pos);
         this.pos += 4;
     }
-
     addNumeric(c, v) {
-        if (v < 256){
+        if (v < 256) {
             this.ensure(3);
             this.buffer.writeUInt8(c, this.pos);
             this.pos++;
@@ -83,7 +68,6 @@ class BlrWriter {
             this.pos++;
             return;
         }
-
         this.ensure(6);
         this.buffer.writeUInt8(c, this.pos);
         this.pos++;
@@ -92,7 +76,6 @@ class BlrWriter {
         this.buffer.writeInt32BE(v, this.pos);
         this.pos += 4;
     }
-
     addBytes(b) {
         this.ensure(b.length);
         for (var i = 0, length = b.length; i < length; i++) {
@@ -100,86 +83,70 @@ class BlrWriter {
             this.pos++;
         }
     }
-
     addString(c, s, encoding) {
         this.addByte(c);
-
         var len = Buffer.byteLength(s, encoding);
         if (len > MAX_STRING_SIZE)
             throw new Error('blr string is too big');
-
         this.ensure(len + 1);
         this.buffer.writeUInt8(len, this.pos);
         this.pos++;
         this.buffer.write(s, this.pos, len, encoding);
         this.pos += len;
     }
-
     addBuffer(b) {
         this.addWord(b.length);
         this.ensure(b.length);
         b.copy(this.buffer, this.pos);
         this.pos += b.length;
     }
-
     addString2(c, s, encoding) {
         this.addByte(c);
-
         var len = Buffer.byteLength(s, encoding);
-        if (len > MAX_STRING_SIZE* MAX_STRING_SIZE)
+        if (len > MAX_STRING_SIZE * MAX_STRING_SIZE)
             throw new Error('blr string is too big');
-
         this.ensure(len + 2);
         this.buffer.writeUInt16LE(len, this.pos);
         this.pos += 2;
         this.buffer.write(s, this.pos, len, encoding);
         this.pos += len;
     }
-
     addMultiblockPart(c, s, encoding) {
         var buff = Buffer.from(s, encoding);
         var remaining = buff.length;
         var step = 0;
-
         while (remaining > 0) {
             var toWrite = Math.min(remaining, 254);
-
             this.addByte(c);
             this.addByte(toWrite + 1);
             this.addByte(step);
-
             this.ensure(toWrite);
             buff.copy(this.buffer, this.pos, step * 254, (step * 254) + toWrite);
-
             step++;
             remaining -= toWrite;
             this.pos += toWrite;
         }
     }
 }
-
+exports.BlrWriter = BlrWriter;
 /***************************************
  *
  *   BLR Reader
  *
  ***************************************/
-
 class BlrReader {
     constructor(buffer) {
         this.buffer = buffer;
         this.pos = 0;
     }
-
     readByteCode() {
         return this.buffer.readUInt8(this.pos++);
     }
-
     readInt32() {
         var value = this.buffer.readUInt32LE(this.pos);
         this.pos += 4;
         return value;
     }
-
     readInt() {
         var len = this.buffer.readUInt16LE(this.pos);
         this.pos += 2;
@@ -192,89 +159,71 @@ class BlrReader {
                 value = this.buffer.readInt16LE(this.pos);
                 break;
             case 4:
-                value = this.buffer.readInt32LE(this.pos)
+                value = this.buffer.readInt32LE(this.pos);
         }
         this.pos += len;
         return value;
     }
-
     readString(encoding) {
         var len = this.buffer.readUInt16LE(this.pos);
         var str;
-
         this.pos += 2;
         if (len <= 0)
             return '';
-
         str = this.buffer.toString(encoding, this.pos, this.pos + len);
         this.pos += len;
         return str;
     }
-
     readSegment() {
         var ret, tmp;
         var len = this.buffer.readUInt16LE(this.pos);
-
         this.pos += 2;
-
         while (len > 0) {
-
             if (ret) {
                 tmp = ret;
                 ret = Buffer.alloc(tmp.length + len);
                 tmp.copy(ret);
                 this.buffer.copy(ret, tmp.length, this.pos, this.pos + len);
-            } else {
+            }
+            else {
                 ret = Buffer.alloc(len);
                 this.buffer.copy(ret, 0, this.pos, this.pos + len);
             }
-
             this.pos += len;
-
             if (this.pos === this.buffer.length)
                 break;
-
             len = this.buffer.readUInt16LE(this.pos);
             this.pos += 2;
         }
-
         return ret ? ret : Buffer.alloc(0);
     }
 }
-
+exports.BlrReader = BlrReader;
 /***************************************
  *
  *   XDR Writer
  *
  ***************************************/
-
 class XdrWriter {
     constructor(size) {
         this.buffer = Buffer.alloc(size || 32);
         this.pos = 0;
     }
-
     ensure(len) {
         var newlen = this.buffer.length;
-
         while (newlen < this.pos + len)
-            newlen *= 2
-
+            newlen *= 2;
         if (this.buffer.length >= newlen)
             return;
-
         var b = Buffer.alloc(newlen);
         this.buffer.copy(b);
-        delete(this.buffer);
         this.buffer = b;
     }
-
     addInt(value) {
         this.ensure(4);
         this.buffer.writeInt32BE(value, this.pos);
         this.pos += 4;
     }
-
     addInt64(value) {
         this.ensure(8);
         // Note: precision is limited to Number.MAX_SAFE_INTEGER (±2^53-1).
@@ -283,47 +232,37 @@ class XdrWriter {
         this.buffer.writeBigInt64BE(BigInt(Math.trunc(value)), this.pos);
         this.pos += 8;
     }
-
     addInt128(value) {
         this.ensure(16);
-
         const bigValue = BigInt(value);
-
         const high = bigValue >> BigInt(64);
         const low = bigValue & BigInt("0xFFFFFFFFFFFFFFFF");
-
         this.buffer.writeBigUInt64BE(high, this.pos);
         this.pos += 8;
         this.buffer.writeBigUInt64BE(low, this.pos);
         this.pos += 8;
     }
-
     addDecFloat16(value) {
         // DECFLOAT(16) - IEEE 754 Decimal64 - 8 bytes
         // Full IEEE 754-2008 Decimal64 implementation
         this.ensure(8);
-        
-        const encoded = encodeDecimal64(value);
+        const encoded = (0, ieee754_decimal_1.encodeDecimal64)(value);
         encoded.copy(this.buffer, this.pos, 0, 8);
         this.pos += 8;
     }
-
     addDecFloat34(value) {
         // DECFLOAT(34) - IEEE 754 Decimal128 - 16 bytes
         // Full IEEE 754-2008 Decimal128 implementation
         this.ensure(16);
-        
-        const encoded = encodeDecimal128(value);
+        const encoded = (0, ieee754_decimal_1.encodeDecimal128)(value);
         encoded.copy(this.buffer, this.pos, 0, 16);
         this.pos += 16;
     }
-
     addUInt(value) {
         this.ensure(4);
         this.buffer.writeUInt32BE(value, this.pos);
         this.pos += 4;
     }
-
     addString(s, encoding) {
         var len = Buffer.byteLength(s, encoding);
         var alen = align(len);
@@ -331,36 +270,42 @@ class XdrWriter {
         this.buffer.writeInt32BE(len, this.pos);
         this.pos += 4;
         this.buffer.write(s, this.pos, len, encoding);
+        this.buffer.fill(0, this.pos + len, this.pos + alen);
         this.pos += alen;
     }
-
     addText(s, encoding) {
         var len = Buffer.byteLength(s, encoding);
         var alen = align(len);
         this.ensure(alen);
         this.buffer.write(s, this.pos, len, encoding);
+        this.buffer.fill(0, this.pos + len, this.pos + alen);
+        this.pos += alen;
+    }
+    addParamBuffer(b) {
+        var len = b.length;
+        var alen = align(len);
+        this.ensure(alen);
+        b.copy(this.buffer, this.pos);
+        this.buffer.fill(0, this.pos + len, this.pos + alen);
         this.pos += alen;
     }
-
     addBlr(blr) {
         var alen = align(blr.pos);
         this.ensure(alen + 4);
         this.buffer.writeInt32BE(blr.pos, this.pos);
         this.pos += 4;
-        blr.buffer.copy(this.buffer, this.pos);
+        blr.buffer.copy(this.buffer, this.pos, 0, blr.pos);
+        this.buffer.fill(0, this.pos + blr.pos, this.pos + alen);
         this.pos += alen;
     }
-
     getData() {
         return this.buffer.slice(0, this.pos);
     }
-
     addDouble(value) {
         this.ensure(8);
         this.buffer.writeDoubleBE(value, this.pos);
         this.pos += 8;
     }
-
     addQuad(quad) {
         this.ensure(8);
         var b = this.buffer;
@@ -369,46 +314,39 @@ class XdrWriter {
         b.writeInt32BE(quad.low, this.pos);
         this.pos += 4;
     }
-
     addBuffer(buffer) {
         this.ensure(buffer.length);
         buffer.copy(this.buffer, this.pos, 0, buffer.length);
         this.pos += buffer.length;
     }
-
     addAlignment(len) {
         var alen = (4 - len) & 3;
-
         this.ensure(alen);
         this.buffer.write('ffffff', this.pos, alen, 'hex');
         this.pos += alen;
     }
 }
-
+exports.XdrWriter = XdrWriter;
 /***************************************
  *
  *   XDR Reader
  *
  ***************************************/
-
 class XdrReader {
     constructor(buffer) {
         this.buffer = buffer;
         this.pos = 0;
     }
-
     readInt() {
         var r = this.buffer.readInt32BE(this.pos);
         this.pos += 4;
         return r;
     }
-
     readUInt() {
         var r = this.buffer.readUInt32BE(this.pos);
         this.pos += 4;
         return r;
     }
-
     readInt64() {
         // Note: precision is limited to Number.MAX_SAFE_INTEGER (±2^53-1).
         // Values outside this range lose precision, which matches the previous
@@ -417,62 +355,50 @@ class XdrReader {
         this.pos += 8;
         return result;
     }
-
     readInt128() {
-        var high = this.buffer.readBigUInt64BE(this.pos)
-        this.pos += 8
-
-        var low = this.buffer.readBigUInt64BE(this.pos)
-        this.pos += 8
-
-        return (BigInt(high) << BigInt(64)) + BigInt(low)
-    }
-
+        var high = this.buffer.readBigUInt64BE(this.pos);
+        this.pos += 8;
+        var low = this.buffer.readBigUInt64BE(this.pos);
+        this.pos += 8;
+        return (BigInt(high) << BigInt(64)) + BigInt(low);
+    }
     readDecFloat16() {
         // DECFLOAT(16) - IEEE 754 Decimal64 - 8 bytes
         // Full IEEE 754-2008 Decimal64 implementation
         const buf = this.buffer.slice(this.pos, this.pos + 8);
         this.pos += 8;
-        
-        return decodeDecimal64(buf);
+        return (0, ieee754_decimal_1.decodeDecimal64)(buf);
     }
-
     readDecFloat34() {
         // DECFLOAT(34) - IEEE 754 Decimal128 - 16 bytes
         // Full IEEE 754-2008 Decimal128 implementation
         const buf = this.buffer.slice(this.pos, this.pos + 16);
         this.pos += 16;
-        
-        return decodeDecimal128(buf);
+        return (0, ieee754_decimal_1.decodeDecimal128)(buf);
     }
-
     readShort() {
         var r = this.buffer.readInt16BE(this.pos);
         this.pos += 2;
         return r;
     }
-
     readQuad() {
         var b = this.buffer;
         var high = b.readInt32BE(this.pos);
         this.pos += 4;
         var low = b.readInt32BE(this.pos);
         this.pos += 4;
-        return {low: low, high: high}
+        return { low: low, high: high };
     }
-
     readFloat() {
         var r = this.buffer.readFloatBE(this.pos);
         this.pos += 4;
         return r;
     }
-
     readDouble() {
         var r = this.buffer.readDoubleBE(this.pos);
         this.pos += 8;
         return r;
     }
-
     readArray() {
         var len = this.readInt();
         if (!len)
@@ -481,39 +407,32 @@ class XdrReader {
         this.pos += align(len);
         return r;
     }
-
     readBuffer(len, toAlign = true) {
         if (!arguments.length) {
             len = this.readInt();
         }
-
         if (len !== null && len !== undefined) {
-
-            if (len <= 0){
+            if (len <= 0) {
                 return Buffer.alloc(0);
             }
-
             var r = this.buffer.slice(this.pos, this.pos + len);
             this.pos += toAlign ? align(len) : len;
             return r;
         }
     }
-
     readString(encoding) {
         var len = this.readInt();
         return this.readText(len, encoding);
     }
-
     readText(len, encoding) {
         if (len <= 0)
             return '';
-
         var r = this.buffer.toString(encoding, this.pos, this.pos + len);
         this.pos += align(len);
         return r;
     }
 }
-
+exports.XdrReader = XdrReader;
 /***************************************
  *
  *   BitSet
@@ -523,17 +442,13 @@ var WORD_LOG = 5;
 var BUFFER_BITS = 8;
 var BIT_ON = 1;
 var BIT_OFF = 0;
-
 class BitSet {
     constructor(buffer) {
         this.data = [];
-
         if (buffer) {
             this.scale(buffer.length * BUFFER_BITS);
-
             for (var i = 0; i < buffer.length; i++) {
                 var n = buffer[i];
-
                 for (var j = 0; j < BUFFER_BITS; j++) {
                     var k = i * BUFFER_BITS + j;
                     this.data[k >>> WORD_LOG] |= (n >> j & BIT_ON) << k;
@@ -541,48 +456,34 @@ class BitSet {
             }
         }
     }
-
     scale(index) {
         var l = index >>> WORD_LOG;
-
         for (var i = this.data.length; l >= i; l--) {
             this.data.push(BIT_OFF);
         }
     }
-
     set(index, value) {
         let pos = index >>> 3;
-
         for (let i = this.data.length; pos >= i; pos--) {
             this.data.push(BIT_OFF);
         }
-
         pos = index >>> 3;
-
         if (value === undefined || value) {
             this.data[pos] |= (1 << (index % BUFFER_BITS));
-        } else {
+        }
+        else {
             this.data[pos] &= ~(1 << (index % BUFFER_BITS));
         }
     }
-
     get(index) {
         var n = index >>> WORD_LOG;
-
         if (n >= this.data.length) {
             return BIT_OFF;
         }
-
         return (this.data[n] >>> index) & BIT_ON;
     }
-
     toBuffer() {
         return Buffer.from(this.data);
     }
 }
-
-exports.BlrWriter = BlrWriter;
-exports.BlrReader = BlrReader;
-exports.XdrWriter = XdrWriter;
-exports.XdrReader = XdrReader;
 exports.BitSet = BitSet;

package/lib/wire/service.d.ts

@@ -0,0 +1,66 @@
+import Events from 'events';
+import stream from 'stream';
+import { BlrReader } from './serialize';
+/***************************************
+ *
+ *   Service Manager
+ *
+ ***************************************/
+declare class ServiceManager extends Events.EventEmitter {
+    static ShutdownMode: {
+        NORMAL: number;
+        MULTI: number;
+        SINGLE: number;
+        FULL: number;
+    };
+    static ShutdownKind: {
+        FORCED: number;
+        DENY_TRANSACTION: number;
+        DENY_ATTACHMENT: number;
+    };
+    connection: any;
+    constructor(connection: any);
+    _createOutputStream(optread: string | null | undefined, buffersize: number | null | undefined, callback: (err: any, stream?: stream.Readable) => void): void;
+    _infosmapping: Record<string | number, string>;
+    _processcapabilities(blr: BlrReader, res: any): void;
+    _processdbinfo(blr: BlrReader, res: any): void;
+    _processquery(buffer: Buffer, callback: (err: any, res?: any) => void): void;
+    detach(callback?: (err?: any, obj?: any) => void, force?: boolean): this;
+    backup(options: any, callback: (err: any, stream?: stream.Readable) => void): void;
+    nbackup(options: any, callback: (err: any, stream?: stream.Readable) => void): void;
+    restore(options: any, callback: (err: any, stream?: stream.Readable) => void): void;
+    nrestore(options: any, callback: (err: any, stream?: stream.Readable) => void): void;
+    _fixpropertie(options: any, callback: (err: any, stream?: stream.Readable) => void): void;
+    setDialect(db: string, dialect: number, callback: any): void;
+    setSweepinterval(db: string, sweepinterval: number, callback: any): void;
+    setCachebuffer(db: string, nbpages: number, callback: any): void;
+    BringOnline(db: string, callback: any): void;
+    Shutdown(db: string, kind: number, delay: number, mode?: any, callback?: any): void;
+    setShadow(db: string, val: boolean, callback: any): void;
+    setForcewrite(db: string, val: boolean, callback: any): void;
+    setReservespace(db: string, val: boolean, callback: any): void;
+    setReadonlyMode(db: string, callback: any): void;
+    setReadwriteMode(db: string, callback: any): void;
+    validate(options: any, callback: (err: any, stream?: stream.Readable) => void): void;
+    commit(db: string, transactid: number, callback: any): void;
+    rollback(db: string, transactid: number, callback: any): void;
+    recover(db: string, transactid: number, callback: any): void;
+    getStats(options: any, callback: (err: any, stream?: stream.Readable) => void): void;
+    getLog(options: any, callback: (err: any, stream?: stream.Readable) => void): void;
+    getUsers(username: string | null, callback: any): void;
+    addUser(username: string, password: string, options: any, callback: any): void;
+    editUser(username: string, options: any, callback: any): void;
+    removeUser(username: string, rolename: string | null, callback: any): void;
+    getFbserverInfos(infos: any, options: any, callback: any): void;
+    startTrace(options: any, callback: any): void;
+    suspendTrace(options: any, callback: any): void;
+    resumeTrace(options: any, callback: any): void;
+    stopTrace(options: any, callback: any): void;
+    getTraceList(options: any, callback: any): void;
+    readline(options: any, callback: any): void;
+    readeof(options: any, callback: any): void;
+    hasRunningAction(options: any, callback: any): void;
+    readusers(options: any, callback: any): void;
+    readlimbo(options: any, callback: any): void;
+}
+export = ServiceManager;