node-firebird 2.11.0 → 2.13.0

package/lib/wire/xsqlvar.d.ts

@@ -1,4 +1,47 @@
+import type { TextCodec } from './codepages';
 import type { XdrReader, XdrWriter, BlrWriter } from './serialize';
+import type { RecordCounts } from '../types';
+export declare function getFirebirdCharsetWidth(charset?: string): number;
+/**
+ * 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.
+ */
+export declare function resolveTextEncoding(options?: any): BufferEncoding;
+/**
+ * Codec for the CONNECTION charset when it is a codepage Node cannot
+ * handle natively (WIN1251, ISO8859_7, KOI8R, …); null on the native
+ * path (UTF8/latin1/ascii) and for unknown charsets. With a codec
+ * connection charset the server transliterates all text to that
+ * codepage, so every text column, parameter, SQL string and text blob
+ * goes through the codec (issues #319/#301).
+ */
+export declare function resolveTextCodec(options?: any): TextCodec | null;
+interface TextState {
+    key: string | undefined;
+    codec: TextCodec | null;
+    enc: BufferEncoding;
+    width: number;
+}
+/**
+ * Per-connection text handling, resolved once and memoized on the
+ * long-lived options object: the decode loop calls this per CELL, and
+ * recomputing uppercased names + map lookups a million times per large
+ * fetch is pure waste. Invalidated if options.encoding ever changes.
+ */
+export declare function resolveTextState(options?: any): TextState;
+/**
+ * Encode text in the CONNECTION charset — the byte form the server
+ * expects for parameters, SQL statement text and text-blob content.
+ */
+export declare function encodeConnectionText(options: any, value: string): Buffer;
+/**
+ * Decode connection-charset bytes to text (the read counterpart of
+ * encodeConnectionText — used for text blobs).
+ */
+export declare function decodeConnectionText(options: any, buffer: Buffer): string;
 /**
  * Common shape of all SQLVar descriptor objects.  The metadata properties
  * are populated externally (in connection.ts) from the op_prepare_statement
@@ -18,6 +61,9 @@ export declare abstract class SQLVarBase {
     owner?: string;
     charSetId?: number;
     collationId?: number;
+    /** Original declared byte length when scaleOutputLengths widened
+     *  `length` for the fetch capacity check (issue #422). */
+    nativeLength?: number;
     abstract decode(data: XdrReader, lowerV13: boolean, options?: any): any;
     abstract calcBlr(blr: BlrWriter): void;
 }
@@ -41,7 +87,23 @@ export interface ColumnKey {
  * decoder and by fetchBlobSyncRow, which must agree on where each column
  * landed in the row.
  */
-export declare function computeColumnKeys(output: SQLVarBase[], nestTables: boolean | string | undefined, lowercaseKeys: boolean | undefined): ColumnKey[];
+export declare function computeColumnKeys(output: SQLVarBase[], nestTables: boolean | string | undefined, lowercaseKeys: boolean | undefined, transform?: (key: string) => string): ColumnKey[];
+/** transformKeys option value: the built-in 'camel', or a custom mapper. */
+export type KeyTransform = 'camel' | ((key: string) => string);
+/** FIRST_NAME → firstName (the transformKeys: 'camel' built-in). */
+export declare function camelizeKey(key: string): string;
+/**
+ * Resolve the effective transformKeys value (per-query wins over the
+ * connection option) into a callable mapper, or undefined when off.
+ * A custom mapper is guarded like the typeCast hook: a throw inside the
+ * row-decode loop would be mistaken for an incomplete packet and desync
+ * the response queue, so failures fall back to the untransformed key.
+ */
+export declare function resolveKeyTransform(queryOptions: {
+    transformKeys?: KeyTransform;
+} | undefined, connectionOptions: {
+    transformKeys?: KeyTransform;
+} | undefined): ((key: string) => string) | undefined;
 /**
  * Resolve the effective nestTables value: the per-query option wins over
  * the connection option. The decoder and fetchBlobSyncRow both use this —
@@ -60,6 +122,50 @@ export declare function resolveNestTables(queryOptions: {
  * cell by ColumnKey must resolve it through here.
  */
 export declare function nestCell(row: any, table: string | undefined): any;
+/** Human-readable names for the SQL_* wire type codes. */
+export declare const SQL_TYPE_NAMES: Record<number, string>;
+/**
+ * Public column-metadata shape for one output descriptor: the vocabulary
+ * both the typeCast hook and withMeta `fields` deliver. Keep the two in
+ * lockstep by building both through here.
+ */
+export declare function describeField(meta: Partial<SQLVarBase>): {
+    type: number;
+    typeName: string;
+    subType: number | undefined;
+    scale: number | undefined;
+    length: number | undefined;
+    nullable: boolean | undefined;
+    field: string | undefined;
+    relation: string | undefined;
+    relationAlias: string | undefined;
+    relationSchema: string | undefined;
+    alias: string | undefined;
+};
+/**
+ * Map a statement's output descriptors to the column-metadata array
+ * delivered in withMeta results ({ rows, fields, ... }).
+ */
+export declare function describeFields(output: SQLVarBase[]): {
+    type: number;
+    typeName: string;
+    subType: number | undefined;
+    scale: number | undefined;
+    length: number | undefined;
+    nullable: boolean | undefined;
+    field: string | undefined;
+    relation: string | undefined;
+    relationAlias: string | undefined;
+    relationSchema: string | undefined;
+    alias: string | undefined;
+}[];
+/**
+ * Parse the op_info_sql response buffer of a Const.RECORDS_INFO request
+ * into per-verb row counts. The buffer holds an isc_info_sql_records
+ * cluster (2-byte total length, then nested isc_info_req_*_count items,
+ * each 2-byte length + little-endian integer) terminated by isc_info_end.
+ */
+export declare function parseRecordCounts(buffer: Buffer | undefined): RecordCounts;
 export declare class SQLVarText extends SQLVarBase {
     decode(data: XdrReader, lowerV13: boolean, options?: any): string | Buffer<ArrayBufferLike> | null | undefined;
     calcBlr(blr: BlrWriter): void;
@@ -217,7 +323,17 @@ export declare class SQLParamDate {
 }
 export declare class SQLParamBool {
     value: any;
-    constructor(value: any);
+    /**
+     * Encode as a real BOOLEAN (blr_bool + xdr opaque byte) instead of the
+     * legacy blr_short 0/1. Set when the DESCRIBED parameter type is
+     * SQL_BOOLEAN: Firebird refuses smallint→BOOLEAN conversion
+     * ("conversion error from string", issue #122), and conversely BOOLEAN
+     * does not convert to numbers — so smallint targets keep the legacy
+     * form for compatibility.
+     */
+    asBoolean: boolean;
+    constructor(value: any, asBoolean?: boolean);
     encode(data: XdrWriter): void;
     calcBlr(blr: BlrWriter): void;
 }
+export {};

package/lib/wire/xsqlvar.js

@@ -3,12 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLParamBool = exports.SQLParamDate = exports.SQLParamQuad = exports.SQLParamBuffer = exports.SQLParamString = exports.SQLParamDouble = exports.SQLParamDecFloat34 = exports.SQLParamDecFloat16 = exports.SQLParamInt128 = exports.SQLParamInt64 = exports.SQLParamInt = exports.SQLVarBoolean = exports.SQLVarTimeStampTzEx = exports.SQLVarTimeStampTz = exports.SQLVarTimeTzEx = exports.SQLVarTimeTz = exports.SQLVarTimeStamp = exports.SQLVarTime = exports.SQLVarDate = exports.SQLVarDouble = exports.SQLVarFloat = exports.SQLVarDecFloat34 = exports.SQLVarDecFloat16 = exports.SQLVarInt128 = exports.SQLVarInt64 = exports.SQLVarShort = exports.SQLVarInt = exports.SQLVarArray = exports.SQLVarBlob = exports.SQLVarQuad = exports.SQLVarString = exports.SQLVarNull = exports.SQLVarText = exports.SQLVarBase = void 0;
+exports.SQLParamBool = exports.SQLParamDate = exports.SQLParamQuad = exports.SQLParamBuffer = exports.SQLParamString = exports.SQLParamDouble = exports.SQLParamDecFloat34 = exports.SQLParamDecFloat16 = exports.SQLParamInt128 = exports.SQLParamInt64 = exports.SQLParamInt = exports.SQLVarBoolean = exports.SQLVarTimeStampTzEx = exports.SQLVarTimeStampTz = exports.SQLVarTimeTzEx = exports.SQLVarTimeTz = exports.SQLVarTimeStamp = exports.SQLVarTime = exports.SQLVarDate = exports.SQLVarDouble = exports.SQLVarFloat = exports.SQLVarDecFloat34 = exports.SQLVarDecFloat16 = exports.SQLVarInt128 = exports.SQLVarInt64 = exports.SQLVarShort = exports.SQLVarInt = exports.SQLVarArray = exports.SQLVarBlob = exports.SQLVarQuad = exports.SQLVarString = exports.SQLVarNull = exports.SQLVarText = exports.SQL_TYPE_NAMES = exports.SQLVarBase = void 0;
+exports.getFirebirdCharsetWidth = getFirebirdCharsetWidth;
+exports.resolveTextEncoding = resolveTextEncoding;
+exports.resolveTextCodec = resolveTextCodec;
+exports.resolveTextState = resolveTextState;
+exports.encodeConnectionText = encodeConnectionText;
+exports.decodeConnectionText = decodeConnectionText;
 exports.computeColumnKeys = computeColumnKeys;
+exports.camelizeKey = camelizeKey;
+exports.resolveKeyTransform = resolveKeyTransform;
 exports.resolveNestTables = resolveNestTables;
 exports.nestCell = nestCell;
+exports.describeField = describeField;
+exports.describeFields = describeFields;
+exports.parseRecordCounts = parseRecordCounts;
 exports.encodeDateTimeParts = encodeDateTimeParts;
 const const_1 = __importDefault(require("./const"));
+const serialize_1 = require("./serialize");
+const codepages_1 = require("./codepages");
 /***************************************
  *
  *   SQLVar
@@ -16,6 +29,7 @@ const const_1 = __importDefault(require("./const"));
  ***************************************/
 const ScaleDivisor = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000];
 const DateOffset = 40587, TimeCoeff = 86400000, MsPerMinute = 60000;
+const EMPTY_BUFFER = Buffer.alloc(0);
 /**
  * Maps Firebird character-set names (upper-case) to the Node.js Buffer
  * encoding string used by Buffer.toString() / Buffer.from().
@@ -40,8 +54,16 @@ const FirebirdToNodeEncoding = Object.freeze({
 const FirebirdCharsetWidths = {
     'UTF8': 4,
     'UNICODE_FSS': 3,
-    'SJIS': 2,
-    'EUCJ': 2
+    // real Firebird names — the bare 'SJIS'/'EUCJ' keys never matched a
+    // valid encoding option and silently resolved to width 1
+    'SJIS_0208': 2,
+    'EUCJ_0208': 2,
+    'KSC_5601': 2,
+    'BIG_5': 2,
+    'GB_2312': 2,
+    'GBK': 2,
+    'CP943C': 2,
+    'GB18030': 4,
 };
 function getFirebirdCharsetWidth(charset) {
     if (!charset)
@@ -62,6 +84,67 @@ function resolveTextEncoding(options) {
         : const_1.default.DEFAULT_ENCODING;
     return (FirebirdToNodeEncoding[encoding] || const_1.default.DEFAULT_ENCODING.toLowerCase());
 }
+/**
+ * Codec for the CONNECTION charset when it is a codepage Node cannot
+ * handle natively (WIN1251, ISO8859_7, KOI8R, …); null on the native
+ * path (UTF8/latin1/ascii) and for unknown charsets. With a codec
+ * connection charset the server transliterates all text to that
+ * codepage, so every text column, parameter, SQL string and text blob
+ * goes through the codec (issues #319/#301).
+ */
+function resolveTextCodec(options) {
+    return resolveTextState(options).codec;
+}
+/**
+ * Per-connection text handling, resolved once and memoized on the
+ * long-lived options object: the decode loop calls this per CELL, and
+ * recomputing uppercased names + map lookups a million times per large
+ * fetch is pure waste. Invalidated if options.encoding ever changes.
+ */
+function resolveTextState(options) {
+    const key = options && options.encoding;
+    if (options && options.__textState && options.__textState.key === key) {
+        return options.__textState;
+    }
+    const encoding = (key || const_1.default.DEFAULT_ENCODING).toUpperCase();
+    const state = {
+        key,
+        codec: FirebirdToNodeEncoding[encoding] ? null : (0, codepages_1.getCodec)(encoding),
+        enc: (FirebirdToNodeEncoding[encoding] || const_1.default.DEFAULT_ENCODING.toLowerCase()),
+        width: getFirebirdCharsetWidth(encoding),
+    };
+    if (options) {
+        options.__textState = state;
+    }
+    return state;
+}
+/**
+ * Encode text in the CONNECTION charset — the byte form the server
+ * expects for parameters, SQL statement text and text-blob content.
+ */
+function encodeConnectionText(options, value) {
+    const state = resolveTextState(options);
+    if (state.codec) {
+        return state.codec.encode(value);
+    }
+    if (state.enc === 'ascii') {
+        // Node's 'ascii' encoding masks high bits (0xE4 → 'd') — replace
+        // non-ASCII with '?' instead, matching the codec policy
+        value = value.replace(/[^\x00-\x7F]/g, '?');
+    }
+    return Buffer.from(value, state.enc);
+}
+/**
+ * Decode connection-charset bytes to text (the read counterpart of
+ * encodeConnectionText — used for text blobs).
+ */
+function decodeConnectionText(options, buffer) {
+    const codec = resolveTextCodec(options);
+    if (codec) {
+        return codec.decode(buffer);
+    }
+    return buffer.toString(resolveTextEncoding(options));
+}
 //------------------------------------------------------
 /**
  * Common shape of all SQLVar descriptor objects.  The metadata properties
@@ -84,12 +167,15 @@ exports.SQLVarBase = SQLVarBase;
  * decoder and by fetchBlobSyncRow, which must agree on where each column
  * landed in the row.
  */
-function computeColumnKeys(output, nestTables, lowercaseKeys) {
+function computeColumnKeys(output, nestTables, lowercaseKeys, transform) {
     return output.map((column) => {
         let key = column.alias || '';
         if (lowercaseKeys) {
             key = key.toLowerCase();
         }
+        if (transform) {
+            key = transform(key);
+        }
         if (nestTables !== true && typeof nestTables !== 'string') {
             return { key };
         }
@@ -97,12 +183,63 @@ function computeColumnKeys(output, nestTables, lowercaseKeys) {
         if (lowercaseKeys) {
             table = table.toLowerCase();
         }
+        if (transform) {
+            table = transform(table);
+        }
         if (nestTables === true) {
             return { table, key };
         }
         return { key: table + nestTables + key };
     });
 }
+/** FIRST_NAME → firstName (the transformKeys: 'camel' built-in). */
+function camelizeKey(key) {
+    const parts = String(key).toLowerCase().split('_');
+    let out = parts[0] || '';
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        if (part) {
+            out += part.charAt(0).toUpperCase() + part.slice(1);
+        }
+    }
+    return out;
+}
+/**
+ * Resolve the effective transformKeys value (per-query wins over the
+ * connection option) into a callable mapper, or undefined when off.
+ * A custom mapper is guarded like the typeCast hook: a throw inside the
+ * row-decode loop would be mistaken for an incomplete packet and desync
+ * the response queue, so failures fall back to the untransformed key.
+ */
+function resolveKeyTransform(queryOptions, connectionOptions) {
+    const value = resolveQueryOption('transformKeys', queryOptions, connectionOptions);
+    if (value === 'camel') {
+        return camelizeKey;
+    }
+    if (typeof value !== 'function') {
+        return undefined;
+    }
+    return (key) => {
+        try {
+            return String(value(key));
+        }
+        catch (err) {
+            console.warn('[node-firebird] transformKeys mapper threw for key "%s": %s — using the untransformed key', key, err && err.message);
+            return key;
+        }
+    };
+}
+/**
+ * Shared precedence rule for per-query-overridable connection options:
+ * the per-query value wins whenever it is present (even if falsy), the
+ * connection option applies otherwise.
+ */
+function resolveQueryOption(name, queryOptions, connectionOptions) {
+    if (queryOptions && queryOptions[name] !== undefined) {
+        return queryOptions[name];
+    }
+    return connectionOptions ? connectionOptions[name] : undefined;
+}
 /**
  * Resolve the effective nestTables value: the per-query option wins over
  * the connection option. The decoder and fetchBlobSyncRow both use this —
@@ -110,10 +247,7 @@ function computeColumnKeys(output, nestTables, lowercaseKeys) {
  * up in the wrong place.
  */
 function resolveNestTables(queryOptions, connectionOptions) {
-    if (queryOptions && queryOptions.nestTables !== undefined) {
-        return queryOptions.nestTables;
-    }
-    return connectionOptions && connectionOptions.nestTables;
+    return resolveQueryOption('nestTables', queryOptions, connectionOptions);
 }
 /**
  * The object a column's value lives in: the row itself, or — when the
@@ -128,26 +262,119 @@ function nestCell(row, table) {
     return row[table] || (row[table] = {});
 }
 //------------------------------------------------------
+/** Human-readable names for the SQL_* wire type codes. */
+exports.SQL_TYPE_NAMES = {
+    [const_1.default.SQL_TEXT]: 'TEXT',
+    [const_1.default.SQL_VARYING]: 'VARYING',
+    [const_1.default.SQL_SHORT]: 'SHORT',
+    [const_1.default.SQL_LONG]: 'LONG',
+    [const_1.default.SQL_FLOAT]: 'FLOAT',
+    [const_1.default.SQL_DOUBLE]: 'DOUBLE',
+    [const_1.default.SQL_D_FLOAT]: 'D_FLOAT',
+    [const_1.default.SQL_TIMESTAMP]: 'TIMESTAMP',
+    [const_1.default.SQL_BLOB]: 'BLOB',
+    [const_1.default.SQL_ARRAY]: 'ARRAY',
+    [const_1.default.SQL_QUAD]: 'QUAD',
+    [const_1.default.SQL_TYPE_TIME]: 'TIME',
+    [const_1.default.SQL_TYPE_DATE]: 'DATE',
+    [const_1.default.SQL_INT64]: 'INT64',
+    [const_1.default.SQL_INT128]: 'INT128',
+    [const_1.default.SQL_TIMESTAMP_TZ]: 'TIMESTAMP_TZ',
+    [const_1.default.SQL_TIMESTAMP_TZ_EX]: 'TIMESTAMP_TZ_EX',
+    [const_1.default.SQL_TIME_TZ]: 'TIME_TZ',
+    [const_1.default.SQL_TIME_TZ_EX]: 'TIME_TZ_EX',
+    [const_1.default.SQL_DEC16]: 'DEC16',
+    [const_1.default.SQL_DEC34]: 'DEC34',
+    [const_1.default.SQL_BOOLEAN]: 'BOOLEAN',
+    [const_1.default.SQL_NULL]: 'NULL',
+};
+/**
+ * Public column-metadata shape for one output descriptor: the vocabulary
+ * both the typeCast hook and withMeta `fields` deliver. Keep the two in
+ * lockstep by building both through here.
+ */
+function describeField(meta) {
+    return {
+        type: meta.type,
+        typeName: exports.SQL_TYPE_NAMES[meta.type] || 'UNKNOWN',
+        subType: meta.subType,
+        scale: meta.scale,
+        // report the column's true declared length, not the widened fetch
+        // buffer (see scaleOutputLengths)
+        length: meta.nativeLength !== undefined ? meta.nativeLength : meta.length,
+        nullable: meta.nullable,
+        field: meta.field,
+        relation: meta.relation,
+        relationAlias: meta.relationAlias,
+        relationSchema: meta.relationSchema,
+        alias: meta.alias,
+    };
+}
+/**
+ * Map a statement's output descriptors to the column-metadata array
+ * delivered in withMeta results ({ rows, fields, ... }).
+ */
+function describeFields(output) {
+    return (output || []).map(describeField);
+}
+/**
+ * Parse the op_info_sql response buffer of a Const.RECORDS_INFO request
+ * into per-verb row counts. The buffer holds an isc_info_sql_records
+ * cluster (2-byte total length, then nested isc_info_req_*_count items,
+ * each 2-byte length + little-endian integer) terminated by isc_info_end.
+ */
+function parseRecordCounts(buffer) {
+    const counts = { selectCount: 0, insertCount: 0, updateCount: 0, deleteCount: 0 };
+    if (!buffer || !buffer.length) {
+        return counts;
+    }
+    // this runs inside a response callback — a malformed/truncated buffer
+    // must yield partial counts, never a throw
+    try {
+        const br = new serialize_1.BlrReader(buffer);
+        while (br.pos < br.buffer.length) {
+            const item = br.readByteCode();
+            if (item === const_1.default.isc_info_end || item === const_1.default.isc_info_truncated) {
+                break;
+            }
+            if (item === const_1.default.isc_info_sql_records) {
+                br.pos += 2; // skip the cluster's total length; nested items follow
+                continue;
+            }
+            switch (item) {
+                case const_1.default.isc_info_req_select_count:
+                    counts.selectCount = br.readInt() || 0;
+                    break;
+                case const_1.default.isc_info_req_insert_count:
+                    counts.insertCount = br.readInt() || 0;
+                    break;
+                case const_1.default.isc_info_req_update_count:
+                    counts.updateCount = br.readInt() || 0;
+                    break;
+                case const_1.default.isc_info_req_delete_count:
+                    counts.deleteCount = br.readInt() || 0;
+                    break;
+                default:
+                    // unknown item: its 2-byte length prefix tells us how far to skip
+                    br.pos += 2 + br.buffer.readUInt16LE(br.pos);
+            }
+        }
+    }
+    catch (e) {
+        // fall through with whatever was parsed so far
+    }
+    return counts;
+}
+//------------------------------------------------------
 class SQLVarText extends SQLVarBase {
     decode(data, lowerV13, options) {
         let ret;
-        const textEncoding = resolveTextEncoding(options);
-        if (this.subType > 1) {
-            // ToDo: with column charset
-            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, textEncoding);
-            const encoding = options && options.encoding ? options.encoding : 'UTF8';
-            const width = getFirebirdCharsetWidth(encoding);
-            const charLength = Math.floor(this.length / width);
+        if (this.subType > 1 || this.subType === 0) {
+            const state = resolveTextState(options);
+            ret = state.codec
+                ? state.codec.decode(data.readBuffer(this.length) || EMPTY_BUFFER)
+                : data.readText(this.length, state.enc);
+            const charLength = Math.floor(this.length / state.width);
             if (ret.length > charLength) {
                 ret = ret.substring(0, charLength);
             }
@@ -174,14 +401,11 @@ exports.SQLVarNull = SQLVarNull;
 class SQLVarString extends SQLVarBase {
     decode(data, lowerV13, options) {
         let ret;
-        const textEncoding = resolveTextEncoding(options);
-        if (this.subType > 1) {
-            // ToDo: with column charset
-            ret = data.readString(textEncoding);
-        }
-        else if (this.subType === 0) {
-            // without charset definition
-            ret = data.readString(textEncoding);
+        if (this.subType > 1 || this.subType === 0) {
+            const state = resolveTextState(options);
+            ret = state.codec
+                ? state.codec.decode(data.readArray() || EMPTY_BUFFER)
+                : data.readString(state.enc);
         }
         else {
             ret = data.readBuffer();
@@ -716,10 +940,19 @@ class SQLParamDate {
 exports.SQLParamDate = SQLParamDate;
 //------------------------------------------------------
 class SQLParamBool {
-    constructor(value) {
+    constructor(value, asBoolean = false) {
         this.value = value;
+        this.asBoolean = asBoolean;
     }
     encode(data) {
+        if (this.asBoolean) {
+            // xdr_datum sends booleans as 1 opaque value byte + 3 pad bytes
+            // (NOT a big-endian int: the value byte comes FIRST — addInt(1)
+            // would decode server-side as false). Matches the batch encoder.
+            data.addBuffer(Buffer.from([this.value ? 1 : 0]));
+            data.addAlignment(1);
+            return;
+        }
         if (this.value != null) {
             data.addInt(this.value ? 1 : 0);
         }
@@ -729,6 +962,10 @@ class SQLParamBool {
         }
     }
     calcBlr(blr) {
+        if (this.asBoolean) {
+            blr.addByte(const_1.default.blr_bool);
+            return;
+        }
         blr.addByte(const_1.default.blr_short);
         blr.addShort(0);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-firebird",
-    "version": "2.11.0",
+    "version": "2.13.0",
     "description": "Pure JavaScript and Asynchronous Firebird client for Node.js.",
     "keywords": [
         "firebird",
@@ -23,6 +23,24 @@
     ],
     "main": "./lib/index.js",
     "types": "./lib/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/index.d.ts",
+            "import": "./lib/index.js",
+            "require": "./lib/index.js"
+        },
+        "./lib/firebird.msg": "./lib/firebird.msg",
+        "./lib/firebird.msg.json": "./lib/firebird.msg.json",
+        "./lib/*.js": {
+            "types": "./lib/*.d.ts",
+            "default": "./lib/*.js"
+        },
+        "./lib/*": {
+            "types": "./lib/*.d.ts",
+            "default": "./lib/*.js"
+        },
+        "./package.json": "./package.json"
+    },
     "files": [
         "lib",
         "src"