node-firebird 2.3.4 → 2.4.1

package/lib/index.d.ts

@@ -1,338 +1,37 @@
-// Type definitions for node-firebird
-// Project: node-firebird
-// Definitions by: Marco Warm <https://github.com/MarcusCalidus>
-
-declare module 'node-firebird' {
-    type DatabaseCallback = (err: any, db: Database) => void;
-    type TransactionCallback = (err: any, transaction: Transaction) => void;
-    type QueryCallback = (err: any, result: any[]) => void;
-    type SimpleCallback = (err: any) => void;
-    type SequentialCallback = (row: any, index: number, next?: (err?: any) => void) => void | Promise<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_COMMITTED: 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_COMMITTED_READ_ONLY: number[];
-
-    export type Isolation = number[];
-
-    export type TransactionOptions = {
-        autoCommit?: boolean;
-        autoUndo?: boolean;
-        isolation?: Isolation;
-        ignoreLimbo?: boolean;
-        readOnly?: boolean;
-        wait?: boolean;
-        waitTimeout?: number;
-    };
-
-    export type QueryOptions = {
-        timeout: number;
-    }
-
-    export interface Database {
-        detach(callback?: SimpleCallback): Database;
-        transaction(options: TransactionOptions|Isolation|TransactionCallback, callback?: TransactionCallback): Database;
-        query(query: string, params: any[], callback: QueryCallback, options?: QueryOptions): Database;
-        execute(query: string, params: any[], callback: QueryCallback, options?: QueryOptions): Database;
-        sequentially(query: string, params: any[], rowCallback: SequentialCallback, callback: SimpleCallback, options?: QueryOptions | boolean): Database;
-        drop(callback: SimpleCallback): void;
-        escape(value: any): string;
-        attachEvent(callback: any): this;
-    }
-
-    export interface Transaction {
-        query(query: string, params: any[], callback: QueryCallback, options?: QueryOptions): void;
-        execute(query: string, params: any[], callback: QueryCallback, options?: QueryOptions): void;
-        sequentially(query: string, params: any[], rowCallback: SequentialCallback, callback: SimpleCallback, options?: QueryOptions | boolean): Database;
-        commit(callback?: SimpleCallback): void;
-        commitRetaining(callback?: SimpleCallback): void;
-        rollback(callback?: SimpleCallback): void;
-        rollbackRetaining(callback?: SimpleCallback): void;
-    }
-
-    export type SupportedCharacterSet = |
-        'NONE' |
-        'CP943C' |
-        'DOS737' |
-        'DOS775' |
-        'DOS858' |
-        'DOS862' |
-        'DOS864' |
-        'DOS866' |
-        'DOS869' |
-        'GB18030' |
-        'GBK' |
-        'ISO8859_1' |
-        'ISO8859_2' |
-        'ISO8859_3' |
-        'ISO8859_4' |
-        'ISO8859_5' |
-        'ISO8859_6' |
-        'ISO8859_7' |
-        'ISO8859_8' |
-        'ISO8859_9' |
-        'ISO8859_13' |
-        'KOI8R' |
-        'KOI8U' |
-        'TIS620' |
-        'UTF8' |
-        'WIN1251' |
-        'WIN1252' |
-        'WIN1253' |
-        'WIN1254' |        
-        'WIN1255' |
-        'WIN1256' |
-        'WIN1257' |
-        'WIN1258' |
-        'WIN_1258';
-
-    export interface Options {
-        host?: string;
-        port?: number;
-        database?: string;
-        user?: string;
-        password?: string;
-        lowercase_keys?: boolean;
-        role?: string;
-        pageSize?: number;
-        retryConnectionInterval?: number;
-        encoding?: SupportedCharacterSet;
-        blobAsText?: boolean; // only affects for blob subtype 1
-        /**
-         * Segment size in bytes used when WRITING blobs (op_batch_segments).
-         * Default 1024, max 65535. Use 65535 to minimize round-trips on
-         * remote/high-latency connections.
-         */
-        blobChunkSize?: number;
-        /**
-         * Buffer size in bytes requested per op_get_segment when READING
-         * blobs. Default 1024, max 65535. Use 65535 to minimize round-trips
-         * on remote/high-latency connections (~64x fewer round-trips).
-         */
-        blobReadChunkSize?: number;
-        wireCrypt?: number; // WIRE_CRYPT_DISABLE or WIRE_CRYPT_ENABLE
-        wireCompression?: boolean;
-        pluginName?: string;
-        dbCryptConfig?: string; // Database encryption key callback config (base64: prefix for base64, or plain string)
-        /**
-         * Timeout in milliseconds for a single pool.get() attach operation.
-         * If attach() does not complete within this time the slot is freed,
-         * the caller receives an error, and any late-arriving connection is
-         * safely discarded. Set to 0 or omit to disable (default: no timeout).
-         *
-         * Recommended value: 5000–10000 ms depending on network latency and
-         * expected Firebird server response time under load.
-         */
-        connectTimeout?: number;
-    }
-
-    export interface SvcMgrOptions extends Options {
-        manager: true; // Attach to ServiceManager
-    }
-
-    export interface ConnectionPool {
-        get(callback: DatabaseCallback): 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 create(options: Options, callback: DatabaseCallback): void;
-    export function attachOrCreate(options: Options, callback: DatabaseCallback): void;
-    export function pool(max: number, options: Options): ConnectionPool;
-    export function drop(options: Options, callback: SimpleCallback): void;
-
-    interface ReadableOptions {
-        optread?: 'byline' | 'buffer'; // default 'byline'
-        buffersize?: number; // default 'byline': 2048, 'buffer': 8192
-        timeout?: number;
-    }
-
-    export interface BackupOptions extends ReadableOptions {
-        database?: string;
-        files: string | { filename: string, sizefile: string }[];
-        factor?: number; // If backing up to a physical tape device, this switch lets you specify the tape's blocking factor
-        verbose?: boolean;
-        ignorechecksums?: boolean;
-        ignorelimbo?: boolean;
-        metadataonly?: boolean;
-        nogarbasecollect?: boolean;
-        olddescriptions?: boolean;
-        nontransportable?: boolean;
-        convert?: boolean;
-        expand?: boolean;
-        notriggers?: boolean;
-    }
-
-    export interface NBackupOptions extends ReadableOptions {
-        database?: string;
-        file: string;
-        level?: number; // nb day for incremental
-        notriggers?: boolean;
-        direct?: 'on' | 'off'; // default 'on'
-    }
-
-    export interface RestoreOptions extends ReadableOptions {
-        database?: string;
-        files: string | string[];
-        verbose?: boolean;
-        cachebuffers?: number; // default 2048, gbak -buffers
-        pagesize?: boolean; // default 4096
-        readonly?: boolean; // default false
-        deactivateindexes?: boolean; // default false
-        noshadow?: boolean; // default false
-        novalidity?: boolean; // default false
-        individualcommit?: boolean; // default true
-        replace?: boolean; // default false
-        create?: boolean; // default true
-        useallspace?: boolean; // default false
-        metadataonly?: boolean; // default false
-        fixfssdata?: string; // default null
-        fixfssmetadata?: string; // default null
-    }
-
-    export interface NRestoreOptions extends ReadableOptions {
-        database?: string;
-        files: string | string[];
-    }
-
-    export interface ValidateOptions extends ReadableOptions {
-        database?: string;
-        checkdb?: boolean;
-        ignorechecksums?: boolean;
-        killshadows?: boolean;
-        mend?: boolean;
-        validate?: boolean;
-        full?: boolean;
-        sweep?: boolean;
-        listlimbo?: boolean;
-        icu?: boolean;
-    }
-
-    export interface StatsOptions extends ReadableOptions {
-        database?: string;
-        record?: boolean;
-        nocreation?: boolean;
-        tables?: boolean;
-        pages?: boolean;
-        header?: boolean;
-        indexes?: boolean;
-        tablesystem?: boolean;
-        encryption?: boolean;
-        objects?: string; // space-separated list of object index,table,systemtable
-    }
-
-    interface UserInfo {
-        userid: number;
-        groupid: number;
-        username: string;
-        firstname: string;
-        middlename: string;
-        lastname: string
-        admin: number;
-        rolename?: string;
-        groupname?: string;
-    }
-
-    export interface ServerInfo {
-        result: number;
-        dbinfo?: { database: any[], nbattachment: number, nbdatabase: number };
-        fbconfig?: any;
-        svcversion?: number;
-        fbversion?: string;
-        fbimplementation?: string;
-        fbcapatibilities: string[];
-        pathsecuritydb?: string;
-        fbenv?: string;
-        fbenvlock?: string;
-        fbenvmsg?: string;
-        limbotrans?: number[];
-        fbusers?: UserInfo[]
-    }
-
-    export interface ServerInfoReq {
-        dbinfo?: boolean;
-        fbconfig?: boolean;
-        svcversion?: boolean;
-        fbversion?: boolean;
-        fbimplementation?: boolean;
-        fbcapatibilities?: boolean;
-        pathsecuritydb?: boolean;
-        fbenv?: boolean;
-        fbenvlock?: boolean;
-        fbenvmsg?: boolean;
-        limbotrans?: boolean;
-    }
-
-    export interface TraceOptions extends ReadableOptions {
-        configfile?: string; // startTrace uses it
-        tracename?: string; // startTrace uses it
-        traceid?: number; // suspendTrace, stopTrace, and resumeTrace use it
-    }
-
-    type ServiceManagerCallback = (err: any, svc: ServiceManager) => void;
-    // @ts-ignore
-    type ReadableCallback = (err: any, reader: NodeJS.ReadableStream) => void;
-    type InfoCallback = (err: any, info: ServerInfo) => void;
-    type LineCallback = (err: any, data: { result: number, line: string }) => void;
-
-    export enum ShutdownMode { NORMAL = 0, MULTI = 1, SINGLE = 2, FULL = 3 }
-    export enum ShutdownKind { FORCED = 0, DENY_TRANSACTION = 1, DENY_ATTACHMENT = 2 }
-
-    export interface ServiceManager {
-        detach(callback?: SimpleCallback, force?: boolean): void;
-        backup(options: BackupOptions, callback: ReadableCallback): void;
-        nbackup(options: BackupOptions, callback: ReadableCallback): void;
-        restore(options: NRestoreOptions, callback: ReadableCallback): void;
-        nrestore(options: any, callback: Function): void;
-        setDialect(db: string, dialect: 1 | 3, callback: ReadableCallback): void;
-        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
-        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;
-        recover(db: string, transactid: number, callback: ReadableCallback): void;
-        getStats(options: StatsOptions, callback: ReadableCallback): void;
-        getLog(options: ReadableOptions, callback: ReadableCallback): void;
-        getUsers(username: string | null, callback: InfoCallback): void;
-        addUser(username: string, password: string, info: UserInfo, callback: ReadableCallback): void;
-        editUser(username: string, info: UserInfo, callback: ReadableCallback): void;
-        removeUser(username: string, rolename: string | null, callback: ReadableCallback): void;
-        getFbserverInfos(infos: ServerInfoReq, options: { buffersize?: number, timeout?: number }, callback: InfoCallback): void; // if infos is empty all options are asked to the service
-        startTrace(options: TraceOptions, callback: ReadableCallback): void;
-        suspendTrace(options: TraceOptions, callback: ReadableCallback): void;
-        resumeTrace(options: TraceOptions, callback: ReadableCallback): void;
-        stopTrace(options: TraceOptions, callback: ReadableCallback): void;
-        getTraceList(options: ReadableOptions, callback: ReadableCallback): void;
-        readline(options: ReadableOptions, callback: LineCallback): void;
-        readeof(options: ReadableOptions, callback: LineCallback): void;
-        hasRunningAction(options: ReadableOptions, callback: ReadableCallback): void;
-        readusers(options: ReadableOptions, callback: ReadableCallback): void;
-        readlimbo(options: ReadableOptions, callback: ReadableCallback): void;
-    }
-}
+import Connection from './wire/connection';
+import { escape as escapeValue } from './utils';
+import type { Options, SvcMgrOptions, DatabaseCallback, ServiceManagerCallback, SimpleCallback, ConnectionPool } from './types';
+export * from './types';
+export { GDSCode } from './gdscodes';
+export declare const AUTH_PLUGIN_LEGACY: string;
+export declare const AUTH_PLUGIN_SRP: string;
+export declare const AUTH_PLUGIN_SRP256: string;
+export declare const AUTH_PLUGIN_SRP384: string;
+export declare const AUTH_PLUGIN_SRP512: string;
+export declare const WIRE_CRYPT_DISABLE: number;
+export declare const WIRE_CRYPT_ENABLE: number;
+/** A transaction sees changes done by uncommitted transactions. */
+export declare const ISOLATION_READ_UNCOMMITTED: number[];
+/** A transaction sees only data committed before the statement has been executed. */
+export declare const ISOLATION_READ_COMMITTED: number[];
+/** A transaction sees during its lifetime only data committed before the transaction has been started. */
+export declare 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 declare const ISOLATION_SERIALIZABLE: number[];
+export declare const ISOLATION_READ_COMMITTED_READ_ONLY: number[];
+export declare const escape: typeof 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 declare let connection: Connection | undefined;
+export declare function attach(options: Options, callback: DatabaseCallback): void;
+export declare function attach(options: SvcMgrOptions, callback: ServiceManagerCallback): void;
+export declare function drop(options: Options, callback: SimpleCallback): void;
+export declare function create(options: Options, callback: DatabaseCallback): void;
+export declare function attachOrCreate(options: Options, callback: DatabaseCallback): void;
+export declare function pool(max: number, options: Options): ConnectionPool;

package/lib/index.js

@@ -1,128 +1,139 @@
-const Const = require('./wire/const');
-const {doError, doCallback} = require('./callback');
-const Connection = require('./wire/connection');
-const Pool = require('./pool');
-const {escape} = require('./utils');
-
-if (typeof(setImmediate) === 'undefined') {
-    global.setImmediate = function(cb) {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connection = exports.escape = exports.ISOLATION_READ_COMMITTED_READ_ONLY = exports.ISOLATION_SERIALIZABLE = exports.ISOLATION_REPEATABLE_READ = exports.ISOLATION_READ_COMMITTED = exports.ISOLATION_READ_UNCOMMITTED = exports.WIRE_CRYPT_ENABLE = exports.WIRE_CRYPT_DISABLE = exports.AUTH_PLUGIN_SRP512 = exports.AUTH_PLUGIN_SRP384 = exports.AUTH_PLUGIN_SRP256 = exports.AUTH_PLUGIN_SRP = exports.AUTH_PLUGIN_LEGACY = exports.GDSCode = void 0;
+exports.attach = attach;
+exports.drop = drop;
+exports.create = create;
+exports.attachOrCreate = attachOrCreate;
+exports.pool = pool;
+const const_1 = __importDefault(require("./wire/const"));
+const callback_1 = require("./callback");
+const connection_1 = __importDefault(require("./wire/connection"));
+const pool_1 = __importDefault(require("./pool"));
+const utils_1 = require("./utils");
+__exportStar(require("./types"), exports);
+var gdscodes_1 = require("./gdscodes");
+Object.defineProperty(exports, "GDSCode", { enumerable: true, get: function () { return gdscodes_1.GDSCode; } });
+if (typeof (setImmediate) === 'undefined') {
+    global.setImmediate = function (cb) {
         process.nextTick(cb);
     };
 }
-
-exports.AUTH_PLUGIN_LEGACY = Const.AUTH_PLUGIN_LEGACY;
-exports.AUTH_PLUGIN_SRP = Const.AUTH_PLUGIN_SRP;
-exports.AUTH_PLUGIN_SRP256 = Const.AUTH_PLUGIN_SRP256;
-
-exports.WIRE_CRYPT_DISABLE = Const.WIRE_CRYPT_DISABLE;
-exports.WIRE_CRYPT_ENABLE = Const.WIRE_CRYPT_ENABLE;
-
-exports.ISOLATION_READ_UNCOMMITTED = Const.ISOLATION_READ_UNCOMMITTED;
-exports.ISOLATION_READ_COMMITTED = Const.ISOLATION_READ_COMMITTED;
-exports.ISOLATION_REPEATABLE_READ = Const.ISOLATION_REPEATABLE_READ;
-exports.ISOLATION_SERIALIZABLE = Const.ISOLATION_SERIALIZABLE;
-exports.ISOLATION_READ_COMMITTED_READ_ONLY = Const.ISOLATION_READ_COMMITTED_READ_ONLY;
-
-exports.escape = escape;
-
-exports.attach = function(options, callback) {
-    var host = options.host || Const.DEFAULT_HOST;
-    var port = options.port || Const.DEFAULT_PORT;
+exports.AUTH_PLUGIN_LEGACY = const_1.default.AUTH_PLUGIN_LEGACY;
+exports.AUTH_PLUGIN_SRP = const_1.default.AUTH_PLUGIN_SRP;
+exports.AUTH_PLUGIN_SRP256 = const_1.default.AUTH_PLUGIN_SRP256;
+exports.AUTH_PLUGIN_SRP384 = const_1.default.AUTH_PLUGIN_SRP384;
+exports.AUTH_PLUGIN_SRP512 = const_1.default.AUTH_PLUGIN_SRP512;
+exports.WIRE_CRYPT_DISABLE = const_1.default.WIRE_CRYPT_DISABLE;
+exports.WIRE_CRYPT_ENABLE = const_1.default.WIRE_CRYPT_ENABLE;
+/** A transaction sees changes done by uncommitted transactions. */
+exports.ISOLATION_READ_UNCOMMITTED = const_1.default.ISOLATION_READ_UNCOMMITTED;
+/** A transaction sees only data committed before the statement has been executed. */
+exports.ISOLATION_READ_COMMITTED = const_1.default.ISOLATION_READ_COMMITTED;
+/** A transaction sees during its lifetime only data committed before the transaction has been started. */
+exports.ISOLATION_REPEATABLE_READ = const_1.default.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.
+ */
+exports.ISOLATION_SERIALIZABLE = const_1.default.ISOLATION_SERIALIZABLE;
+exports.ISOLATION_READ_COMMITTED_READ_ONLY = const_1.default.ISOLATION_READ_COMMITTED_READ_ONLY;
+exports.escape = utils_1.escape;
+function attach(options, callback) {
+    var host = options.host || const_1.default.DEFAULT_HOST;
+    var port = options.port || const_1.default.DEFAULT_PORT;
     var manager = options.manager || false;
-    var cnx = this.connection = new Connection(host, port, function(err) {
-
+    var cnx = exports.connection = new connection_1.default(host, port, function (err) {
         if (err) {
-            doError(err, callback);
+            (0, callback_1.doError)(err, callback);
             return;
         }
-
-        cnx.connect(options, function(err) {
+        cnx.connect(options, function (err) {
             if (err) {
-                doError(err, callback);
-            } else {
+                (0, callback_1.doError)(err, callback);
+            }
+            else {
                 if (manager)
                     cnx.svcattach(options, callback);
                 else
                     cnx.attach(options, callback);
             }
         });
-
     }, options);
-};
-
-exports.drop = function(options, callback) {
-	exports.attach(options, function(err, db) {
-		if (err) {
-			callback({ error: err, message: "Drop error" });
-			return;
-		}
-
-		db.drop(callback);
-	});
-};
-
-exports.create = function(options, callback) {
-    var host = options.host || Const.DEFAULT_HOST;
-    var port = options.port || Const.DEFAULT_PORT;
-    var cnx = this.connection = new Connection(host, port, function(err) {
-
+}
+function drop(options, callback) {
+    attach(options, function (err, db) {
+        if (err) {
+            callback({ error: err, message: "Drop error" });
+            return;
+        }
+        db.drop(callback);
+    });
+}
+function create(options, callback) {
+    var host = options.host || const_1.default.DEFAULT_HOST;
+    var port = options.port || const_1.default.DEFAULT_PORT;
+    var cnx = exports.connection = new connection_1.default(host, port, function (err) {
         var self = cnx;
-
         if (err) {
-            callback({ error: err, message: "Connect error" });
+            callback({ error: err, message: "Connect error" }, undefined);
             return;
         }
-
-        cnx.connect(options, function(err) {
+        cnx.connect(options, function (err) {
             if (err) {
-                self.db.emit('error', err);
-                doError(err, callback);
+                if (self.db)
+                    self.db.emit('error', err);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-
             cnx.createDatabase(options, callback);
         });
     }, options);
-};
-
-exports.attachOrCreate = function(options, callback) {
-
-    var host = options.host || Const.DEFAULT_HOST;
-    var port = options.port || Const.DEFAULT_PORT;
-
-    var cnx = this.connection = new Connection(host, port, function(err) {
-
+}
+function attachOrCreate(options, callback) {
+    var host = options.host || const_1.default.DEFAULT_HOST;
+    var port = options.port || const_1.default.DEFAULT_PORT;
+    var cnx = exports.connection = new connection_1.default(host, port, function (err) {
         var self = cnx;
-
         if (err) {
-            callback({ error: err, message: "Connect error" });
+            callback({ error: err, message: "Connect error" }, undefined);
             return;
         }
-
-        cnx.connect(options, function(err) {
-
+        cnx.connect(options, function (err) {
             if (err) {
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-
-            cnx.attach(options, function(err, ret) {
-
+            cnx.attach(options, function (err, ret) {
                 if (!err) {
                     if (self.db)
                         self.db.emit('connect', ret);
-                    doCallback(ret, callback);
+                    (0, callback_1.doCallback)(ret, callback);
                     return;
                 }
-
                 cnx.createDatabase(options, callback);
             });
         });
-
     }, options);
-};
-
+}
 // Pooling
-exports.pool = function(max, options) {
-	return new Pool(exports.attach, max, Object.assign({}, options, { isPool: true }));
-};
+function pool(max, options) {
+    return new pool_1.default(attach, max, Object.assign({}, options, { isPool: true }));
+}

package/lib/messages.d.ts

@@ -0,0 +1,6 @@
+import type { FbStatusItem } from './callback';
+export declare const msgNumber: (facility: number, code: number) => number;
+export declare const getCode: (code: number) => number;
+export declare const getFacility: (code: number) => number;
+export declare const getClass: (code: number) => number;
+export declare const lookupMessages: (status: FbStatusItem[], messageFile: string, callback: (text?: string) => void) => void;