fixparser 9.1.7-9d6b5ca3 → 9.1.7-a0927339

package/types/FIXParserBrowser.d.ts

@@ -0,0 +1,267 @@
+import { type IMessageStore, type IPlugin, MessageBuffer } from 'fixparser-common';
+import type { ProxyAgent } from 'proxy-agent';
+import {
+    type BaseOptions,
+    type ConnectionType,
+    FIXParserBase,
+    type Options as FIXParserOptions,
+    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';
+/**
+ * Browser-specific FIXParser options that extend the base options.
+ * @public
+ */
+export type Options = Pick<
+    FIXParserOptions,
+    | 'host'
+    | 'port'
+    | 'sender'
+    | 'target'
+    | 'heartbeatIntervalSeconds'
+    | 'fixVersion'
+    | 'messageStoreIn'
+    | 'messageStoreOut'
+    | 'logging'
+    | 'logOptions'
+    | 'onMessage'
+    | 'onOpen'
+    | 'onError'
+    | 'onClose'
+    | 'onReady'
+>;
+/**
+ * Browser-specific implementation of the FIXParser interface.
+ * This class provides WebSocket-based FIX communication capabilities for browser environments.
+ */
+declare class FIXParserBrowser implements IFIXParser {
+    static readonly version: Version;
+    readonly parserName: Parser;
+    readonly fixParserBase: FIXParserBase;
+    heartBeatIntervalId: ReturnType<typeof setInterval> | undefined;
+    socket: WebSocket | 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>;
+    connectionType: ConnectionType;
+    logger: Logger;
+    logging: boolean;
+    logOptions: LogOptions | undefined;
+    proxy?: ProxyAgent;
+    private onMessageCallbacks;
+    private onOpenCallbacks;
+    private onErrorCallbacks;
+    private onCloseCallbacks;
+    private onReadyCallbacks;
+    /**
+     * Constructor for initializing the FIXParserBrowser 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<FIXParserBrowser>>;
+        },
+    );
+    /**
+     * 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 FIX server using the specified options. The connection
+     * is made via the WebSocket protocol, and various callbacks can be provided to handle
+     * events like message reception, connection opening, errors, and closure.
+     *
+     * - Sets up logging with optional configurations.
+     * - Validates the license before proceeding with the connection.
+     * - Initializes connection parameters including sender, target, and heartbeat interval.
+     * - Establishes the connection over WebSocket by calling `connectWebsocket()`.
+     *
+     * @param {Options} [options={}] - The configuration options for the connection.
+     * @param {string} [options.host='localhost'] - The host address of the FIX server.
+     * @param {number} [options.port=9878] - The port number for the FIX server.
+     * @param {string} [options.sender='SENDER'] - The sender identifier for the connection.
+     * @param {string} [options.target='TARGET'] - The target identifier for the connection.
+     * @param {number} [options.heartbeatIntervalSeconds=DEFAULT_HEARTBEAT_SECONDS] - The heartbeat interval in seconds.
+     * @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 {function} [options.onMessage=this.onMessageCallback] - Callback for handling incoming messages.
+     * @param {function} [options.onOpen=this.onOpenCallback] - Callback for handling connection open event.
+     * @param {function} [options.onError=this.onErrorCallback] - Callback for handling errors.
+     * @param {function} [options.onClose=this.onCloseCallback] - Callback for handling connection close event.
+     * @param {function} [options.onReady=this.onReadyCallback] - Callback for handling ready event.
+     *
+     * @returns {void}
+     */
+    connect(options?: Options): void;
+    /**
+     * Establishes a WebSocket connection to the FIX server. This method configures event listeners
+     * for WebSocket events such as connection opening, closing, message reception, and logging the events.
+     *
+     * - Builds the WebSocket URL based on the provided host and port.
+     * - Sets up event listeners for `open`, `close`, and `message` events.
+     * - Logs connection status and relevant details such as `readyState` during connection and closure.
+     * - On receiving a message, it is parsed using `fixParserBase.parse()`, and each parsed message is processed and passed to the callback functions.
+     * - The `onOpenCallback`, `onCloseCallback`, `onMessageCallback` methods are invoked when corresponding events occur.
+     * - The heartbeat mechanism is stopped when the connection closes.
+     *
+     * @returns {void}
+     */
+    private connectWebsocket;
+    /**
+     * Get the next outgoing message sequence number.
+     *
+     * @returns The next outgoing message sequence number.
+     */
+    getNextTargetMsgSeqNum(): number;
+    /**
+     * Set the next outgoing message sequence number.
+     *
+     * @param nextMsgSeqNum - The next message sequence number.
+     * @returns The next outgoing message sequence number.
+     */
+    setNextTargetMsgSeqNum(nextMsgSeqNum: number): number;
+    /**
+     * Get current timestamp.
+     *
+     * @param dateObject - An instance of a Date class.
+     * @returns The current timestamp.
+     */
+    getTimestamp(dateObject?: Date): string;
+    /**
+     * Create an instance of a FIX Message.
+     *
+     * @param fields - An array of Fields.
+     * @returns A FIX Message class instance.
+     */
+    createMessage(...fields: Field[]): Message;
+    /**
+     * Parse a FIX message string into Message instance(s).
+     *
+     * @param data - FIX message string.
+     * @returns FIX Message class instance(s).
+     */
+    parse(data: string): Message[];
+    /**
+     * Send a FIX message.
+     *
+     * @param message - FIX Message class instance.
+     */
+    send(message: Message): void;
+    /**
+     * Get connection status.
+     *
+     * @returns Current connection status.
+     */
+    isConnected(): boolean;
+    /**
+     * Close current connection.
+     */
+    close(): void;
+    /**
+     * Stop heartbeat interval.
+     */
+    stopHeartbeat(): void;
+    /**
+     * Restart heartbeat interval.
+     */
+    restartHeartbeat(): void;
+    /**
+     * Start heartbeat interval.
+     *
+     * @param heartBeatInterval - Heartbeat interval in seconds.
+     * @param disableLog - Whether to disable heartbeat logs.
+     */
+    startHeartbeat(heartBeatInterval?: number, disableLog?: boolean): void;
+}
+export * from './fieldtypes';
+export { Logger } from './logger/Logger';
+export { LicenseManager } from './licensemanager/LicenseManager';
+export { MessageBuffer };
+export { Constants };
+export { Field };
+export { Message };
+export { FIXParserBrowser as 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, BaseOptions } from './FIXParserBase';
+export type { MessageError } from './message/Message';

package/types/FIXServer.d.ts

@@ -0,0 +1,342 @@
+import { type Server, type Socket } from 'node:net';
+import { type TlsOptions } from 'node:tls';
+import { type WebSocket, WebSocketServer } from 'ws';
+import { type IMessageStore, type IPlugin, MessageBuffer } from 'fixparser-common';
+import { FIXParser } from './FIXParser';
+import type { BaseOptions, ConnectionType, Options as FIXParserOptions, 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';
+/**
+ * Server-specific FIXParser options that extend the base options.
+ * @public
+ */
+type Options = Pick<
+    FIXParserOptions,
+    | 'host'
+    | 'port'
+    | 'protocol'
+    | 'sender'
+    | 'target'
+    | 'heartbeatIntervalSeconds'
+    | 'fixVersion'
+    | 'messageStoreIn'
+    | 'messageStoreOut'
+    | 'logging'
+    | 'logOptions'
+    | 'tlsOptions'
+    | 'tlsSkipStdInPipe'
+    | 'onMessage'
+    | 'onOpen'
+    | 'onError'
+    | 'onClose'
+    | 'onReady'
+>;
+/**
+ * Server implementation of the FIXParser interface.
+ * This class provides server-side FIX communication capabilities, supporting multiple protocols
+ * including TCP, TLS, and WebSocket. It handles incoming connections, message processing,
+ * and session management.
+ */
+declare class FIXServer implements IFIXParser {
+    static readonly version: Version;
+    readonly parserName: Parser;
+    readonly fixParser: FIXParser;
+    heartBeatIntervalId: ReturnType<typeof setInterval> | undefined;
+    socket: WebSocket | Socket | undefined;
+    connected: boolean;
+    host: string;
+    port: number;
+    protocol: Protocol;
+    sender: string;
+    target: string;
+    heartBeatInterval: number;
+    fixVersion: string;
+    messageStoreIn: IMessageStore<Message>;
+    messageStoreOut: IMessageStore<Message>;
+    requestedLogout: boolean;
+    connectionType: ConnectionType;
+    logger: Logger;
+    logging: boolean;
+    logOptions: LogOptions | undefined;
+    tlsOptions?: TlsOptions;
+    tlsSkipStdInPipe?: boolean;
+    server: Server | WebSocketServer | undefined;
+    isLoggedIn: boolean;
+    messageCounter: number;
+    private onMessageCallbacks;
+    private onOpenCallbacks;
+    private onErrorCallbacks;
+    private onCloseCallbacks;
+    private onReadyCallbacks;
+    /**
+     * Constructor for initializing an 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<FIXServer>>;
+        },
+    );
+    /**
+     * 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'];
+    /**
+     * Creates a FIX server that listens for incoming connections. This method sets up
+     * various configurations, including logging, connection options, and callbacks for
+     * events like message reception, connection opening, error handling, and closure.
+     *
+     * - Initializes logging based on the provided options.
+     * - Validates the license before proceeding with server creation.
+     * - Sets up connection parameters such as host, port, sender, and target identifiers.
+     * - Sets the heartbeat interval and FIX version.
+     * - Configures callback functions for handling messages, connection events, and errors.
+     * - Calls the `initialize()` method to begin server operation.
+     *
+     * @param {Options} [options={}] - The configuration options for the server.
+     * @param {string} [options.host=this.host] - The host address the server will bind to.
+     * @param {number} [options.port=this.port] - The port number the server will listen on.
+     * @param {string} [options.protocol=this.protocol] - The protocol to be used ('tcp', 'ssl-tcp', 'websocket', etc.).
+     * @param {string} [options.sender=this.sender] - The sender identifier for the server.
+     * @param {string} [options.target=this.target] - The target identifier for the server.
+     * @param {number} [options.heartbeatIntervalSeconds=DEFAULT_HEARTBEAT_SECONDS] - The heartbeat interval in seconds.
+     * @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 {function} [options.onMessage=this.onMessageCallback] - Callback function for handling incoming messages.
+     * @param {function} [options.onOpen=this.onOpenCallback] - Callback function for handling connection open event.
+     * @param {function} [options.onError=this.onErrorCallback] - Callback function for handling errors.
+     * @param {function} [options.onClose=this.onCloseCallback] - Callback function for handling connection close event.
+     * @param {function} [options.onReady=this.onReadyCallback] - Callback function for handling the ready event.
+     *
+     * @returns {void}
+     */
+    createServer(options?: Options): void;
+    /**
+     * Initializes the server by setting up the appropriate connection based on the specified protocol.
+     *
+     * - This method sets the `messageCounter` to zero, which tracks the number of messages sent.
+     * - Depending on the `protocol` (either 'tcp' or 'websocket'), it calls the appropriate server creation method.
+     * - If the protocol is invalid, an error is logged indicating the issue.
+     *
+     * @returns {void}
+     */
+    private initialize;
+    /**
+     * Creates and starts a TCP server to handle incoming connections.
+     * The server listens for incoming client connections on the specified `host` and `port`.
+     * For each connection, it sets up socket event listeners to manage data transmission,
+     * connection lifecycle (open, close, error), and communication processing.
+     *
+     * This method is used to create a standard TCP server and is invoked when the `protocol`
+     * is set to `'tcp'`.
+     *
+     * @returns {void}
+     *
+     * @throws {Error} Will throw an error if the server fails to start or if there is a problem
+     * with socket connection handling.
+     */
+    private setupTcpServer;
+    /**
+     * Sets up and starts a TCP/TLS server to handle incoming connections.
+     * The server is created using the `createTcpTlsServer` function and listens for TLS-TCP
+     * connections based on the provided `tlsOptions`. The method sets up the
+     * necessary event listeners to handle connection events, such as data reception,
+     * connection establishment, and errors.
+     *
+     * @returns {void}
+     *
+     * @throws {Error} Will throw an error if the server fails to start or if there is an issue
+     * with the socket connection or TLS setup.
+     */
+    private setupTcpTlsServer;
+    /**
+     * Sets up event listeners and data handling for the given socket.
+     * This function is used for both TCP and TLS-TCP connections to handle
+     * incoming data, connection lifecycle events (open, close, timeout, error),
+     * and manages communication state (such as heartbeat, message buffer, etc.).
+     *
+     * @param {Socket | TLSSocket} socket - The socket object representing the client connection.
+     * This can be a regular TCP socket (`net.Socket`) or a TLS socket (`TLSSocket`).
+     *
+     * @returns {void}
+     *
+     * @throws {Error} Will throw an error if there is an issue with socket events or data processing.
+     */
+    private setupSocket;
+    /**
+     * Creates a WebSocket server that listens for incoming connections and handles communication.
+     *
+     * - Sets up a WebSocket server with specified `host` and `port`.
+     * - Handles various WebSocket events: 'connection', 'message', 'close', 'error', and 'listening'.
+     * - Logs connection status, errors, and message reception using the logger.
+     * - Processes incoming messages and invokes the appropriate callbacks for message handling, connection open/close, and errors.
+     *
+     * @returns {void}
+     */
+    private createWebsocketServer;
+    /**
+     * Get the next outgoing message sequence number.
+     *
+     * @returns The next outgoing message sequence number.
+     */
+    getNextTargetMsgSeqNum(): number;
+    /**
+     * Set the next outgoing message sequence number.
+     *
+     * @param nextMsgSeqNum - The next message sequence number.
+     * @returns The next outgoing message sequence number.
+     */
+    setNextTargetMsgSeqNum(nextMsgSeqNum: number): number;
+    /**
+     * Get current timestamp.
+     *
+     * @param dateObject - An instance of a Date class.
+     * @returns The current timestamp.
+     */
+    getTimestamp(dateObject?: Date): string;
+    /**
+     * Create an instance of a FIX Message.
+     *
+     * @param fields - An array of Fields.
+     * @returns A FIX Message class instance.
+     */
+    createMessage(...fields: Field[]): Message;
+    /**
+     * Parse a FIX message string into Message instance(s).
+     *
+     * @param data - FIX message string.
+     * @returns FIX Message class instance(s).
+     */
+    parse(data: string): Message[];
+    /**
+     * Send a FIX message.
+     *
+     * @param message - FIX Message class instance.
+     */
+    send(message: Message): void;
+    /**
+     * Get connection status.
+     *
+     * @returns Current connection status.
+     */
+    isConnected(): boolean;
+    /**
+     * Resets the current session.
+     */
+    private resetSession;
+    /**
+     * Close current connection.
+     */
+    close(): void;
+    /**
+     * Destroys the server and closes the connection.
+     *
+     * - Stops the heartbeat mechanism to prevent any ongoing activity.
+     * - If the protocol is TCP, it destroys the socket and closes the server.
+     * - If the protocol is WebSocket, it closes all client connections and shuts down the server.
+     * - Logs the server destruction event.
+     *
+     * @returns {void}
+     */
+    destroy(): void;
+    /**
+     * Stop heartbeat interval.
+     */
+    stopHeartbeat(): void;
+    /**
+     * Restart heartbeat interval.
+     */
+    restartHeartbeat(): void;
+    /**
+     * Start heartbeat interval.
+     *
+     * @param heartBeatInterval - Heartbeat interval in seconds.
+     * @param disableLog - Whether to disable heartbeat logs.
+     */
+    startHeartbeat(heartBeatInterval?: number, disableLog?: boolean): void;
+}
+export * from './fieldtypes';
+export type { TlsOptions } from 'node:tls';
+export { Logger } from './logger/Logger';
+export { LicenseManager } from './licensemanager/LicenseManager';
+export { MessageBuffer };
+export { Constants };
+export { Field };
+export { Message };
+export { FIXServer };
+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';