fixparser-common 9.2.2 → 9.2.3-175e9b8c

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fixparser-common",
-    "version": "9.2.2",
+    "version": "9.2.3-175e9b8c",
     "description": "FIXParser shared codebase",
     "files": [
         "./build/",

package/types/ILogTransporter.d.ts

@@ -0,0 +1,35 @@
+import type { LogMessage } from './LogMessage';
+/**
+ * A LogTransporter interface for external log storage solutions.
+ * @example
+ * const consoleTransport = new ConsoleLogTransport({ format: 'console' as ConsoleFormat });
+ * const logger = new Logger({ name: 'TestLogger', level: 'info', transport: consoleTransport });
+ *
+ * const message: LogMessage = { level: 'info', message: 'This is an info message' };
+ * logger.log(message);
+ */
+export interface ILogTransporter {
+    /**
+     * Initializes the transporter with necessary configuration options.
+     * @param config The configuration object for the transporter (e.g. connection info, credentials).
+     */
+    configure(config: Record<string, any>): void;
+    /**
+     * Sends a log message to the external service or storage.
+     * @param log The log message to be sent.
+     */
+    send(log: LogMessage): Promise<void>;
+    /**
+     * Flushes any pending log messages if the transporter uses buffering, and closes any open connections if needed.
+     */
+    flush(): Promise<void>;
+    /**
+     * Closes the transporter, cleaning up resources (e.g. closing connections).
+     */
+    close(): Promise<void>;
+    /**
+     * Returns the current status of the transporter (e.g., connected, closed, etc.).
+     * This can be useful for diagnostic purposes.
+     */
+    status(): string;
+}

package/types/IMessage.d.ts

@@ -0,0 +1,4 @@
+export interface IMessage {
+    messageSequence: number;
+    encode: (separator: string) => string;
+}

package/types/IMessageStore.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The `IMessageStore` interface defines the contract for a generic message store.
+ * This store is used for storing, retrieving, updating, and removing items of type `T`.
+ * It provides methods to add, retrieve, update, and remove items, along with checking
+ * the store's size, capacity, and performing batch operations.
+ *
+ * @interface IMessageStore
+ */
+export interface IMessageStore<T> {
+    /**
+     * Adds an item of type `T` to the message store.
+     *
+     * @param {T} item - The item to add to the store.
+     *
+     * @returns {void}
+     */
+    add(item: T): void;
+    /**
+     * Retrieves an item of type `T` from the store by its sequence number (or any other identifier).
+     *
+     * @param {number} msgSequence - The sequence number of the item to retrieve.
+     *
+     * @returns {T | undefined} - The item if found, otherwise `undefined`.
+     */
+    getByMsgSequence(msgSequence: number): T | undefined;
+    /**
+     * Removes an item of type `T` from the store by its sequence number.
+     *
+     * @param {number} msgSequence - The sequence number of the item to remove.
+     *
+     * @returns {void}
+     */
+    remove(msgSequence: number): void;
+    /**
+     * Updates an item of type `T` in the store.
+     *
+     * @param {number} msgSequence - The sequence number of the item to update.
+     * @param {T} item - The updated item.
+     *
+     * @returns {boolean} - Returns `true` if the item was updated successfully, `false` otherwise.
+     */
+    update(msgSequence: number, item: T): boolean;
+    /**
+     * Retrieves all items of type `T` from the store.
+     *
+     * @returns {T[]} - An array of all items in the store.
+     */
+    getAll(): T[];
+    /**
+     * Checks if an item with a given sequence number exists in the store.
+     *
+     * @param {number} msgSequence - The sequence number of the item to check.
+     * @returns {boolean} - `true` if the item exists, `false` otherwise.
+     */
+    exists(msgSequence: number): boolean;
+    /**
+     * Returns the current number of items stored in the message store.
+     *
+     * @returns {number} - The number of items in the store.
+     */
+    size(): number;
+    /**
+     * Resizes the message store's capacity.
+     *
+     * @param {number} newCapacity - The new maximum capacity for the store.
+     * @returns {void}
+     */
+    resize(newCapacity: number): void;
+    /**
+     * Clears all items from the store, removing them permanently.
+     *
+     * @returns {void}
+     */
+    clear(): void;
+    /**
+     * Returns the maximum capacity of the message store. This indicates how many items
+     * the store can hold before it reaches its limit.
+     *
+     * @returns {number} - The maximum capacity of the store.
+     */
+    getCapacity(): number;
+    /**
+     * Set the next message sequence number.
+     *
+     * @param nextMsgSeqNum - The next message sequence number.
+     * @returns {number} - The next message sequence number.
+     */
+    setNextMsgSeqNum(nextMsgSeqNum: number): number;
+    /**
+     * Get the next message sequence number.
+     *
+     * @returns {number} - The next message sequence number.
+     */
+    getNextMsgSeqNum(): number;
+}

package/types/IPlugin.d.ts

@@ -0,0 +1,3 @@
+export interface IPlugin<T> {
+    register(target: T): Promise<void>;
+}

package/types/Level.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Logger output level options.
+ *
+ * - 'info': General informational messages that highlight the progress or state of the application.
+ * - 'warn': Warnings about potential issues that don’t necessarily disrupt the program’s functionality.
+ * - 'error': Critical issues that indicate something has gone wrong and may require attention.
+ * - 'silent': No log messages are displayed or recorded, effectively suppressing all output.
+ *
+ * @public
+ */
+export type Level = 'info' | 'warn' | 'error' | 'silent';

package/types/LogMessage.d.ts

@@ -0,0 +1,7 @@
+import type { Level } from './Level';
+export type LogMessage = {
+    level: Level;
+    message: string;
+    fix?: string;
+    [key: string]: unknown;
+};

package/types/MessageBuffer.d.ts

@@ -0,0 +1,104 @@
+import type { IMessageStore } from './IMessageStore';
+/**
+ * A buffer that stores items of type `T` up to a specified maximum size.
+ * Implements the IMessageStore interface for generic types.
+ */
+export declare class MessageBuffer<T> implements IMessageStore<T> {
+    /**
+     * A number representing the next expected message sequence number.
+     * @private
+     */
+    private nextMsgSeqNum;
+    /**
+     * An array holding the items in the buffer.
+     * @private
+     */
+    private buffer;
+    /**
+     * The maximum capacity of the buffer.
+     * @private
+     */
+    private maxBufferSize;
+    constructor(maxBufferSize?: number);
+    /**
+     * Adds a new item to the buffer.
+     * If the buffer is full, the oldest item is removed to make space for the new one.
+     *
+     * @param {T} item - The item to add to the buffer.
+     * @returns {void}
+     */
+    add(item: T): void;
+    /**
+     * Retrieves an item from the buffer by its sequence number (or any other identifier).
+     *
+     * @param {number} msgSequence - The sequence number of the item to retrieve.
+     * @returns {T | undefined} The item if found, or `undefined` if not found.
+     */
+    getByMsgSequence(msgSequence: number): T | undefined;
+    /**
+     * Removes an item from the buffer by its sequence number.
+     *
+     * @param {number} msgSequence - The sequence number of the item to remove.
+     * @returns {void}
+     */
+    remove(msgSequence: number): void;
+    /**
+     * Updates an item in the buffer.
+     *
+     * @param {number} msgSequence - The sequence number of the item to update.
+     * @param {T} item - The updated item.
+     * @returns {boolean} - Returns `true` if the item was updated successfully, `false` otherwise.
+     */
+    update(msgSequence: number, item: T): boolean;
+    /**
+     * Retrieves all items from the buffer.
+     *
+     * @returns {T[]} - An array of all items in the buffer.
+     */
+    getAll(): T[];
+    /**
+     * Checks if an item with a given sequence number exists in the buffer.
+     *
+     * @param {number} msgSequence - The sequence number of the item to check.
+     * @returns {boolean} - `true` if the item exists, `false` otherwise.
+     */
+    exists(msgSequence: number): boolean;
+    /**
+     * Gets the current size of the buffer (the number of items it contains).
+     *
+     * @returns {number} The number of items currently in the buffer.
+     */
+    size(): number;
+    /**
+     * Resizes the buffer's capacity.
+     *
+     * @param {number} newCapacity - The new maximum capacity for the buffer.
+     * @returns {void}
+     */
+    resize(newCapacity: number): void;
+    /**
+     * Clears all items from the buffer.
+     *
+     * @returns {void}
+     */
+    clear(): void;
+    /**
+     * Gets the maximum capacity of the buffer.
+     *
+     * @returns {number} The maximum number of items the buffer can hold.
+     */
+    getCapacity(): number;
+    /**
+     * Set the next message sequence number.
+     *
+     * @param nextMsgSeqNum - The next message sequence number.
+     * @returns {number} - The next message sequence number.
+     */
+    setNextMsgSeqNum(nextMsgSeqNum: number): number;
+    /**
+     * Get the next message sequence number.
+     *
+     * @returns {number} - The next message sequence number.
+     */
+    getNextMsgSeqNum(): number;
+}

package/types/index.d.ts

@@ -0,0 +1,8 @@
+export { ILogTransporter } from './ILogTransporter';
+export type { IMessage } from './IMessage';
+export type { IMessageStore } from './IMessageStore';
+export type { IPlugin } from './IPlugin';
+export { Level } from './Level';
+export { LogMessage } from './LogMessage';
+export { MessageBuffer } from './MessageBuffer';
+export { uuidv4 } from './uuidv4';

package/types/uuidv4.d.ts

@@ -0,0 +1 @@
+export declare const uuidv4: () => string;