fixparser 9.1.7-def37df3 → 9.1.7-edd9ee17

package/build/cjs/FIXParser.js

@@ -194611,7 +194611,7 @@ var missingOrEmpty = (value) => {
 };
 var LicenseManager = class _LicenseManager {
   /** Release information for version checking */
-  static #RELEASE_INFORMATION = "MTc1MDI4NzU3MzcxMw==";
+  static #RELEASE_INFORMATION = "MTc1MDE5NTYzNzE2MA==";
   /** Current license key */
   static #licenseKey;
   /** Whether to use distributed key */
@@ -241038,7 +241038,7 @@ var timestamp = (dateObject, logger) => {
 // src/util/util.ts
 var version = {
   version: "0.0.0",
-  build: "2025-06-18T22:59:33.713Z"
+  build: "2025-06-17T21:27:17.160Z"
 };
 var parseFixVersion = (version2) => {
   return FIX_VERSIONS[version2] ?? version2;

package/build/cjs/FIXParserBrowser.js

@@ -190981,7 +190981,7 @@ var missingOrEmpty = (value) => {
 };
 var LicenseManager = class _LicenseManager {
   /** Release information for version checking */
-  static #RELEASE_INFORMATION = "MTc1MDI4NzU3MzcxMw==";
+  static #RELEASE_INFORMATION = "MTc1MDE5NTYzNzE2MA==";
   /** Current license key */
   static #licenseKey;
   /** Whether to use distributed key */
@@ -237408,7 +237408,7 @@ var timestamp = (dateObject, logger) => {
 // src/util/util.ts
 var version = {
   version: "0.0.0",
-  build: "2025-06-18T22:59:33.713Z"
+  build: "2025-06-17T21:27:17.160Z"
 };
 var parseFixVersion = (version2) => {
   return FIX_VERSIONS[version2] ?? version2;

package/build/cjs/FIXServer.js

@@ -194616,7 +194616,7 @@ var missingOrEmpty = (value) => {
 };
 var LicenseManager = class _LicenseManager {
   /** Release information for version checking */
-  static #RELEASE_INFORMATION = "MTc1MDI4NzU3MzcxMw==";
+  static #RELEASE_INFORMATION = "MTc1MDE5NTYzNzE2MA==";
   /** Current license key */
   static #licenseKey;
   /** Whether to use distributed key */
@@ -241043,7 +241043,7 @@ var timestamp = (dateObject, logger) => {
 // src/util/util.ts
 var version = {
   version: "0.0.0",
-  build: "2025-06-18T22:59:33.713Z"
+  build: "2025-06-17T21:27:17.160Z"
 };
 var parseFixVersion = (version2) => {
   return FIX_VERSIONS[version2] ?? version2;

package/build/esm/FIXParser.mjs

@@ -193905,7 +193905,7 @@ var missingOrEmpty = (value) => {
 };
 var LicenseManager = class _LicenseManager {
   /** Release information for version checking */
-  static #RELEASE_INFORMATION = "MTc1MDI4NzU3MzcxMw==";
+  static #RELEASE_INFORMATION = "MTc1MDE5NTYzNzE2MA==";
   /** Current license key */
   static #licenseKey;
   /** Whether to use distributed key */
@@ -240332,7 +240332,7 @@ var timestamp = (dateObject, logger) => {
 // src/util/util.ts
 var version = {
   version: "0.0.0",
-  build: "2025-06-18T22:59:33.713Z"
+  build: "2025-06-17T21:27:17.160Z"
 };
 var parseFixVersion = (version2) => {
   return FIX_VERSIONS[version2] ?? version2;

package/build/esm/FIXParserBrowser.mjs

@@ -190258,7 +190258,7 @@ var missingOrEmpty = (value) => {
 };
 var LicenseManager = class _LicenseManager {
   /** Release information for version checking */
-  static #RELEASE_INFORMATION = "MTc1MDI4NzU3MzcxMw==";
+  static #RELEASE_INFORMATION = "MTc1MDE5NTYzNzE2MA==";
   /** Current license key */
   static #licenseKey;
   /** Whether to use distributed key */
@@ -236685,7 +236685,7 @@ var timestamp = (dateObject, logger) => {
 // src/util/util.ts
 var version = {
   version: "0.0.0",
-  build: "2025-06-18T22:59:33.713Z"
+  build: "2025-06-17T21:27:17.160Z"
 };
 var parseFixVersion = (version2) => {
   return FIX_VERSIONS[version2] ?? version2;

package/build/esm/FIXServer.mjs

@@ -193910,7 +193910,7 @@ var missingOrEmpty = (value) => {
 };
 var LicenseManager = class _LicenseManager {
   /** Release information for version checking */
-  static #RELEASE_INFORMATION = "MTc1MDI4NzU3MzcxMw==";
+  static #RELEASE_INFORMATION = "MTc1MDE5NTYzNzE2MA==";
   /** Current license key */
   static #licenseKey;
   /** Whether to use distributed key */
@@ -240337,7 +240337,7 @@ var timestamp = (dateObject, logger) => {
 // src/util/util.ts
 var version = {
   version: "0.0.0",
-  build: "2025-06-18T22:59:33.713Z"
+  build: "2025-06-17T21:27:17.160Z"
 };
 var parseFixVersion = (version2) => {
   return FIX_VERSIONS[version2] ?? version2;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fixparser",
-    "version": "9.1.7-def37df3",
+    "version": "9.1.7-edd9ee17",
     "description": "FIX.Latest / 5.0 SP2 Parser / AI Agent Trading",
     "files": [
         "./build/",

package/types/FIXParser.d.ts

@@ -0,0 +1,307 @@
+import { Socket } from 'node:net';
+import { type ConnectionOptions, type TLSSocket } from 'node:tls';
+import { WebSocket } from 'ws';
+import { type IMessageStore, type IPlugin, MessageBuffer } from 'fixparser-common';
+import type { ProxyAgent } from 'proxy-agent';
+import { type BaseOptions, type ConnectionType, FIXParserBase, type Options, type Protocol } from './FIXParserBase';
+import type { IFIXParser } from './IFIXParser';
+import { Field } from './fields/Field';
+import * as Constants from './fieldtypes';
+import { type LogOptions, Logger } from './logger/Logger';
+import { Message } from './message/Message';
+import { type Parser, type Version } from './util/util';
+/**
+ * FIXParser class.
+ * @public
+ */
+declare class FIXParser implements IFIXParser {
+    static readonly version: Version;
+    readonly parserName: Parser;
+    readonly fixParserBase: FIXParserBase;
+    heartBeatIntervalId: ReturnType<typeof setInterval> | undefined;
+    socket: Socket | WebSocket | TLSSocket | undefined;
+    connected: boolean;
+    host: string | undefined;
+    port: number | undefined;
+    protocol: Protocol | undefined;
+    sender: string | undefined;
+    target: string | undefined;
+    heartBeatInterval: number;
+    fixVersion: string;
+    messageStoreIn: IMessageStore<Message>;
+    messageStoreOut: IMessageStore<Message>;
+    requestedLogout: boolean;
+    connectionType: ConnectionType;
+    logger: Logger;
+    logging: boolean;
+    logOptions: LogOptions | undefined;
+    proxy?: ProxyAgent;
+    tlsOptions?: ConnectionOptions;
+    tlsSkipStdInPipe?: boolean;
+    tlsTimeout: number | undefined;
+    tlsEncoding: BufferEncoding;
+    private onMessageCallbacks;
+    private onOpenCallbacks;
+    private onErrorCallbacks;
+    private onCloseCallbacks;
+    private onReadyCallbacks;
+    /**
+     * Constructor for initializing the FIXParser instance with the provided options.
+     *
+     * @param {BaseOptions} [options={ logging: true, logOptions: undefined, fixVersion: DEFAULT_FIX_VERSION, skipValidation: false }] - The options to configure the instance.
+     * @param {boolean} [options.logging=true] - Whether logging is enabled (defaults to `true`).
+     * @param {LogOptions} [options.logOptions=undefined] - Options to customize logging behavior.
+     * @param {string} [options.fixVersion=DEFAULT_FIX_VERSION] - The FIX protocol version to use (defaults to `DEFAULT_FIX_VERSION`).
+     * @param {boolean} [options.skipValidation=false] - Whether to skip validation of FIX messages (defaults to `false`).
+     */
+    constructor(
+        options?: BaseOptions & {
+            plugins?: Array<IPlugin<FIXParser>>;
+        },
+    );
+    /**
+     * Registers a callback function to be invoked when a FIX message is received.
+     * Multiple callbacks can be registered, and all will be triggered in the order they were added.
+     *
+     * @param {Options['onMessage']} callback - The callback function to handle incoming FIX messages.
+     */
+    addOnMessageCallback(callback: Options['onMessage']): void;
+    /**
+     * Registers a callback function to be invoked when the FIX connection is successfully established.
+     * Multiple callbacks can be registered, and all will be triggered in the order they were added.
+     *
+     * @param {Options['onOpen']} callback - The callback function to handle connection opening.
+     */
+    addOnOpenCallback(callback: Options['onOpen']): void;
+    /**
+     * Registers a callback function to be invoked when a FIX connection error occurs.
+     * Multiple callbacks can be registered, and all will be triggered in the order they were added.
+     *
+     * @param {Options['onError']} callback - The callback function to handle connection errors.
+     */
+    addOnErrorCallback(callback: Options['onError']): void;
+    /**
+     * Registers a callback function to be invoked when the FIX connection is closed.
+     * Multiple callbacks can be registered, and all will be triggered in the order they were added.
+     *
+     * @param {Options['onClose']} callback - The callback function to handle connection closure.
+     */
+    addOnCloseCallback(callback: Options['onClose']): void;
+    /**
+     * Registers a callback function to be invoked when the FIX connection is ready for use.
+     * Multiple callbacks can be registered, and all will be triggered in the order they were added.
+     *
+     * @param {Options['onReady']} callback - The callback function to handle connection readiness.
+     */
+    addOnReadyCallback(callback: Options['onReady']): void;
+    private triggerOnMessage;
+    private triggerOnOpen;
+    private triggerOnError;
+    private triggerOnClose;
+    private triggerOnReady;
+    /**
+     * Callback function that is invoked when a FIX message is received.
+     *
+     * @param {Message} message - The received FIX message.
+     */
+    onMessageCallback: Options['onMessage'];
+    /**
+     * Callback function that is invoked when the FIX connection is established.
+     */
+    onOpenCallback: Options['onOpen'];
+    /**
+     * Callback function that is invoked when a FIX connection error occurs.
+     *
+     * @param {Error} error - The error that occurred.
+     */
+    onErrorCallback: Options['onError'];
+    /**
+     * Callback function that is invoked when the FIX connection is closed.
+     */
+    onCloseCallback: Options['onClose'];
+    /**
+     * Callback function that is invoked when the FIX connection is ready for use.
+     */
+    onReadyCallback: Options['onReady'];
+    /**
+     * Establishes a connection to a specified host and port using the given options and protocol type.
+     * The method supports multiple connection protocols, including TCP, SSL/TCP, and WebSocket. It handles the
+     * initialization of connection parameters, logging, and license validation before attempting to connect.
+     *
+     * - **TCP** (`tcp`): Connects using a basic TCP connection.
+     * - **Secure TCP** (`ssl-tcp`, `tls-tcp`): Connects using a secure TLS/SSL connection.
+     * - **WebSocket** (`websocket`): Establishes a WebSocket connection.
+     *
+     * The connection will invoke the appropriate callback functions for each connection event:
+     * - `onMessage`: Called when a new message is received.
+     * - `onOpen`: Called when the connection is successfully established.
+     * - `onError`: Called when an error occurs.
+     * - `onClose`: Called when the connection is closed.
+     * - `onReady`: Called after a short delay once the connection is ready.
+     *
+     * @param {Options} [options={}] - Connection options for setting up the connection.
+     * @param {string} [options.host='localhost'] - Host to connect to.
+     * @param {number} [options.port=9878] - Port to connect to.
+     * @param {string} [options.protocol='tcp'] - Protocol to use for the connection ('tcp', 'ssl-tcp', 'tls-tcp', 'websocket').
+     * @param {string} [options.sender='SENDER'] - Sender ID for the FIX connection.
+     * @param {string} [options.target='TARGET'] - Target ID for the FIX connection.
+     * @param {number} [options.heartbeatIntervalSeconds=DEFAULT_HEARTBEAT_SECONDS] - Interval in seconds for sending heartbeat messages.
+     * @param {string} [options.messageStoreIn=new MessageBuffer()] - Optional custom message buffer for incoming messages.
+     * @param {string} [options.messageStoreOut=new MessageBuffer()] - Optional custom message buffer for outgoing messages.
+     * @param {string | Buffer | undefined} [options.tlsKey] - Optional TLS private key for secure connections.
+     * @param {string | Buffer | undefined} [options.tlsCert] - Optional TLS certificate for secure connections.
+     * @param {boolean} [options.tlsUseSNI=false] - Whether to use Server Name Indication (SNI) for secure connections.
+     * @param {boolean} [options.tlsSkipStdInPipe=false] - Whether to skip piping stdin for secure connections.
+     * @param {any} [options.proxy=null] - Optional proxy configuration for WebSocket connections.
+     * @param {Function} [options.onMessage=this.onMessageCallback] - Callback function to handle incoming messages.
+     * @param {Function} [options.onOpen=this.onOpenCallback] - Callback function to handle connection opening.
+     * @param {Function} [options.onError=this.onErrorCallback] - Callback function to handle errors.
+     * @param {Function} [options.onClose=this.onCloseCallback] - Callback function to handle connection closing.
+     * @param {Function} [options.onReady=this.onReadyCallback] - Callback function to handle connection readiness.
+     * @param {number} [options.tlsTimeout=this.tlsTimeout] - TLS timeout in milliseconds.
+     * @param {BufferEncoding} [options.tlsEncoding=this.tlsEncoding] - TLS encoding.
+     *
+     * @returns {void}
+     */
+    connect(options?: Options): void;
+    /**
+     * Establishes a TCP connection to the specified host and port, sets up the socket for communication,
+     * and handles various socket events such as 'data', 'close', 'ready', 'timeout', and 'error'.
+     *
+     * - Upon successful connection, the socket is ready to receive and process messages.
+     * - Incoming messages are parsed and processed through a message buffer and the provided callback.
+     * - Handles error scenarios such as timeout and connection errors, with appropriate cleanup and notifications.
+     *
+     * @returns {void}
+     */
+    private connectTcp;
+    /**
+     * Establishes a secure TCP (TLS) connection to the specified host and port with optional TLS certificates and keys.
+     * Configures the socket for secure communication and handles various socket events such as 'data', 'close', 'timeout', and 'error'.
+     *
+     * - Supports server-side SSL/TLS authentication with optional key and certificate.
+     * - Enables Server Name Indication (SNI) for secure connections if `tlsUseSNI` is true.
+     * - Handles input piping from `stdin` if `tlsSkipStdInPipe` is false.
+     * - Provides error handling for connection and timeouts, with appropriate cleanup and notifications.
+     *
+     * @returns {void}
+     */
+    private connectTlsTcp;
+    private addTcpListeners;
+    private addTlsListener;
+    private disconnectTlsTcp;
+    /**
+     * Establishes a WebSocket connection to the specified host and port, with optional proxy support.
+     * Configures the socket for communication and handles various WebSocket events such as 'message', 'open', and 'close'.
+     *
+     * - If the connection string does not include `ws://` or `wss://`, it prepends `ws://` to the host and port.
+     * - Optionally uses a proxy if `proxy` is provided.
+     * - Handles incoming messages, processes them, and invokes appropriate callbacks.
+     * - Handles WebSocket open and close events, managing connection state and triggering callbacks.
+     *
+     * @returns {void}
+     */
+    private connectWebsocket;
+    /**
+     * Get the next outgoing message sequence number.
+     *
+     * @returns {number} The next outgoing message sequence number.
+     */
+    getNextTargetMsgSeqNum(): number;
+    /**
+     * Set the next outgoing message sequence number.
+     *
+     * @param {number} nextMsgSeqNum - The next message sequence number.
+     * @returns {number} The next outgoing message sequence number.
+     */
+    setNextTargetMsgSeqNum(nextMsgSeqNum: number): number;
+    /**
+     * Get the next incoming message sequence number.
+     *
+     * @returns {number} The next incoming message sequence number.
+     */
+    getNextSenderMsgSeqNum(): number;
+    /**
+     * Set the next incoming message sequence number.
+     *
+     * @param {number} nextMsgSeqNum - The next message sequence number.
+     * @returns {number} The next incoming message sequence number.
+     */
+    setNextSenderMsgSeqNum(nextMsgSeqNum: number): number;
+    /**
+     * Get current timestamp.
+     *
+     * @param {Date} [dateObject=new Date()] - An instance of a Date class.
+     * @returns {string} The current timestamp.
+     */
+    getTimestamp(dateObject?: Date): string;
+    /**
+     * Create an instance of a FIX Message.
+     *
+     * @param {...Field} fields - An array of Fields.
+     * @returns {Message} A FIX Message class instance.
+     */
+    createMessage(...fields: Field[]): Message;
+    /**
+     * Parse a FIX message string into Message instance(s).
+     *
+     * @param {string} data - FIX message string.
+     * @returns {Message[]} FIX Message class instance(s).
+     */
+    parse(data: string): Message[];
+    /**
+     * Send a FIX message.
+     *
+     * @param {Message} message - FIX Message class instance.
+     * @returns {void}
+     */
+    send(message: Message): void;
+    /**
+     * Get connection status.
+     *
+     * @returns {boolean} Current connection status.
+     */
+    isConnected(): boolean;
+    /**
+     * Close current connection.
+     *
+     * @returns {void}
+     */
+    close(): void;
+    /**
+     * Stop heartbeat interval.
+     *
+     * @returns {void}
+     */
+    stopHeartbeat(): void;
+    /**
+     * Restart heartbeat interval.
+     *
+     * @returns {void}
+     */
+    restartHeartbeat(): void;
+    /**
+     * Start heartbeat interval.
+     *
+     * @param {number} [heartBeatInterval=this.heartBeatInterval] - Heartbeat interval in seconds.
+     * @param {boolean} [disableLog] - Whether to disable heartbeat logs.
+     * @returns {void}
+     */
+    startHeartbeat(heartBeatInterval?: number, disableLog?: boolean): void;
+}
+export * from './fieldtypes';
+export type { ConnectionOptions };
+export { Logger } from './logger/Logger';
+export { LicenseManager } from './licensemanager/LicenseManager';
+export { MessageBuffer };
+export { Constants };
+export { Field };
+export { Message };
+export { FIXParser };
+export type { IFIXParser };
+export type { LogMessage, Level, ILogTransporter } from 'fixparser-common';
+export type { FIXValue } from './util/util';
+export type { LogOptions, Format } from './logger/Logger';
+export type { IMessageStore } from 'fixparser-common';
+export type { Protocol, Options, BaseOptions } from './FIXParserBase';
+export type { MessageError } from './message/Message';

package/types/FIXParserBase.d.ts

@@ -0,0 +1,124 @@
+import type { ConnectionOptions, KeyObject, TlsOptions } from 'node:tls';
+import type { ProxyAgent } from 'proxy-agent';
+import type { IMessageStore } from 'fixparser-common';
+import { Enums as EnumsCache } from './enums/Enums';
+import { Fields as FieldsCache } from './fields/Fields';
+import type { LogOptions } from './logger/Logger';
+import { Message } from './message/Message';
+/**
+ * Connection transport type.
+ * @public
+ */
+export type Protocol = 'tcp' | 'ssl-tcp' | 'tls-tcp' | 'websocket';
+/**
+ * Type of connection (client or server).
+ * @public
+ */
+export type ConnectionType = 'acceptor' | 'initiator';
+/**
+ * Represents the configuration options for initializing the instance.
+ *
+ * @typedef {Object} BaseOptions
+ * @property {boolean} [skipValidation=false] - Whether to skip validation of FIX messages. Defaults to `false`.
+ * @property {string} [fixVersion="FIXT.1.1"] - The FIX protocol version to use. Defaults to `"FIXT.1.1"`, which is typically used by the BeginString tag (tag 8).
+ * @property {boolean} [logging=true] - Whether to enable or disable logging. Defaults to `true`.
+ * @property {LogOptions} [logOptions] - Options for customizing logging behavior. If not provided, no specific log configuration is applied.
+ */
+export type BaseOptions = {
+    skipValidation?: boolean;
+    fixVersion?: string;
+    logging?: boolean;
+    logOptions?: LogOptions;
+};
+/**
+ * FIXParser initialization options.
+ * @public
+ */
+export type Options = {
+    host?: string;
+    port?: number;
+    protocol?: Protocol;
+    sender?: string;
+    target?: string;
+    heartbeatIntervalSeconds?: number;
+    fixVersion?: string;
+    messageStoreIn?: IMessageStore<Message>;
+    messageStoreOut?: IMessageStore<Message>;
+    tlsSkipStdInPipe?: boolean;
+    tlsOptions?: ConnectionOptions | TlsOptions;
+    tlsTimeout?: number;
+    tlsEncoding?: BufferEncoding;
+    logging?: boolean;
+    logOptions?: LogOptions;
+    proxy?: ProxyAgent;
+    skipValidation?: boolean;
+    onReady?: () => void;
+    onMessage?: (message: Message) => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onError?: (error?: Error) => void;
+};
+/**
+ * Base class responsible for parsing and processing FIX messages.
+ *
+ * This class handles parsing of FIX messages, processing message fields and tags,
+ * and performing validation on specific fields such as the body length, checksum,
+ * and protocol version. It provides methods to process raw message data, extract
+ * tag-value pairs, and validate the structure and content of FIX messages.
+ */
+export declare class FIXParserBase {
+    fixVersion: string;
+    message: Message | undefined;
+    messageTags: string[];
+    messageString: string;
+    fields: FieldsCache;
+    enums: EnumsCache;
+    proxy?: ProxyAgent;
+    tlsKey?: string | Buffer | Array<string | Buffer | KeyObject>;
+    tlsCert?: string | Buffer | Array<string | Buffer>;
+    tlsUseSNI?: boolean;
+    tlsSkipStdInPipe?: boolean;
+    skipValidation?: boolean;
+    /**
+     * Processes the message string by searching for a specific pattern and replacing occurrences
+     * of a delimiter with a special character (SOH). It then sets the processed string into the
+     * message object and splits the string into tags for further processing.
+     *
+     * - Uses a regular expression to find specific patterns in the message string.
+     * - Replaces occurrences of the matched pattern with a delimiter (SOH).
+     * - Sets the processed message string into the `message` object and splits it into `messageTags`.
+     * - If the message format is invalid, the method resets the `message` and clears the `messageTags`.
+     *
+     * @returns {void}
+     */
+    processMessage(): void;
+    /**
+     * Processes the fields of the message by iterating over the tags and values, extracting
+     * the tag-value pairs, and performing validation or other processing for specific fields.
+     *
+     * - Each tag-value pair is extracted from `messageTags` and converted into a `Field` object.
+     * - The field is processed by both `fields.processField()` and `enums.processEnum()` methods.
+     * - Special handling is applied to certain fields such as `BeginString`, `BodyLength`, and `CheckSum`.
+     * - Validates the body length and checksum for the message, and updates the `fixVersion` based on the `BeginString` field.
+     * - Adds each processed field to the `message` object for further processing or storage.
+     *
+     * @returns {void}
+     */
+    processFields(): void;
+    /**
+     * Parses a string of data into an array of `Message` objects by splitting the input data
+     * into individual FIX messages and processing each message's fields and tags.
+     *
+     * The data is split using a regular expression to identify FIX message boundaries, specifically
+     * looking for the `8=FIX` marker. Each resulting message string is processed, and its fields
+     * are extracted and validated.
+     *
+     * - If the message string contains the `SOH` character, it is directly processed and split into tags.
+     * - If `SOH` is absent, the message is processed using the `processMessage()` method.
+     * - After processing, each `Message` object is populated with fields and added to the result array.
+     *
+     * @param {string} data - The raw data string containing one or more FIX messages.
+     * @returns {Message[]} An array of `Message` objects parsed from the input string.
+     */
+    parse(data: string): Message[];
+}