jspurefix 5.2.0 → 5.3.0

package/src/store/session-id.ts

@@ -0,0 +1,32 @@
+import * as path from 'path'
+
+/**
+ * Identifies a FIX session for file naming and lookup.
+ * Format: {BeginString}-{SenderCompID}-{TargetCompID}
+ */
+export class SessionId {
+  constructor (
+    public readonly beginString: string,
+    public readonly senderCompID: string,
+    public readonly targetCompID: string
+  ) {}
+
+  /**
+   * Creates a file prefix for QuickFix-compatible file naming.
+   * Example: "FIX.4.4-SENDER-TARGET"
+   */
+  toFilePrefix (): string {
+    return `${this.beginString}-${this.senderCompID}-${this.targetCompID}`
+  }
+
+  /**
+   * Gets the full path for a specific file extension.
+   */
+  getFilePath (directory: string, extension: string): string {
+    return path.join(directory, `${this.toFilePrefix()}.${extension}`)
+  }
+
+  toString (): string {
+    return this.toFilePrefix()
+  }
+}

package/src/store/session-stream-provider.ts

@@ -0,0 +1,74 @@
+/**
+ * Provides stream access for session store operations.
+ * Allows abstraction of file I/O for testing with in-memory buffers.
+ */
+export interface ISessionStreamProvider {
+  /**
+   * Opens or creates a read-write buffer for the message body file.
+   * Must support random-access reads (by offset+length).
+   */
+  openBody (): void
+
+  /**
+   * Appends data to the body. Returns the offset at which data was written.
+   */
+  appendBody (data: Buffer): Promise<number>
+
+  /**
+   * Reads data from the body at the given offset and length.
+   */
+  readBody (offset: number, length: number): Promise<Buffer>
+
+  /**
+   * Gets the current body size (for calculating offsets).
+   */
+  getBodySize (): number
+
+  /**
+   * Appends a line to the header index file.
+   */
+  appendHeaderLine (line: string): Promise<void>
+
+  /**
+   * Reads all lines from the header index file.
+   * Returns empty array if no data exists.
+   */
+  readHeaderLines (): Promise<string[]>
+
+  /**
+   * Reads the sequence numbers string.
+   * Returns null if no data exists.
+   */
+  readSeqNums (): Promise<string | null>
+
+  /**
+   * Writes the sequence numbers string.
+   */
+  writeSeqNums (content: string): Promise<void>
+
+  /**
+   * Reads the session time string.
+   * Returns null if no data exists.
+   */
+  readSessionTime (): Promise<string | null>
+
+  /**
+   * Writes the session time string.
+   */
+  writeSessionTime (content: string): Promise<void>
+
+  /**
+   * Resets all streams/files for a new session.
+   */
+  reset (): Promise<void>
+
+  /**
+   * Flushes any pending writes.
+   */
+  flush (): Promise<void>
+
+  /**
+   * Disposes of all resources.
+   */
+  dispose (): Promise<void>
+}

package/src/store/store-config.ts

@@ -0,0 +1,15 @@
+/**
+ * Configuration for session message store.
+ * Add to session description JSON to enable persistent storage.
+ *
+ * Examples:
+ *   "store": { "type": "memory" }           — explicit in-memory (default)
+ *   "store": { "type": "file" }             — file store in ./store directory
+ *   "store": { "type": "file", "directory": "/var/fix/sessions" }
+ *
+ * Omitting the store block entirely uses in-memory storage.
+ */
+export interface StoreConfig {
+  readonly type: 'memory' | 'file'
+  readonly directory?: string
+}

package/src/transport/ascii/ascii-session.ts

@@ -2,22 +2,29 @@ import { MsgView } from '../../buffer'
 import { MsgTag, MsgType, SessionRejectReason } from '../../types'
 import { IJsFixConfig } from '../../config'
 import { FixSession } from '../session/fix-session'
-import { FixMsgAsciiStoreResend, FixMsgMemoryStore, IFixMsgStore, IFixMsgStoreRecord } from '../../store'
+import {
+  FixMsgAsciiStoreResend, FixMsgMemoryStore, FixMsgStoreRecord,
+  IFixMsgStore, IFixMsgStoreRecord,
+  IFixSessionStore, IFixSessionStoreFactory,
+  MemorySessionStoreFactory, FileSessionStoreFactory, SessionId
+} from '../../store'
 import { SessionState } from '../tcp'
 import { TickAction } from '../tick-action'
 import { IMsgApplication } from '../msg-application'
 import { SegmentType } from '../../buffer/segment/segment-type'
 import { SessionSequenceCoordinator } from '../session/session-sequence-coordinator'
-import { MemorySequenceStore } from '../session/session-sequence-store'
 import { DefaultFixClock } from '../session/fix-clock'
 import { ResendActionType } from '../session/resend-request-manager'
 import { AsciiMsgTransmitter } from './ascii-msg-transmitter'
+import { ILooseObject } from '../../collections/collection'
 
 export abstract class AsciiSession extends FixSession {
   public heartbeat: boolean = true
   protected store: IFixMsgStore | null = null
   protected resender: FixMsgAsciiStoreResend
   protected readonly coordinator: SessionSequenceCoordinator
+  protected readonly sessionStore: IFixSessionStore
+  protected readonly sessionId: SessionId
 
   protected constructor (public readonly config: IJsFixConfig) {
     super(config)
@@ -26,9 +33,18 @@ export abstract class AsciiSession extends FixSession {
     this.store = new FixMsgMemoryStore(this.config.description.SenderCompId, this.config)
     this.resender = new FixMsgAsciiStoreResend(this.store, this.config)
 
-    const sequenceStore = new MemorySequenceStore()
+    // Create session store from factory.
+    // Priority: programmatic config > JSON store config > default in-memory
+    const storeFactory = config.sessionStoreFactory ?? AsciiSession.createStoreFactory(config.description.store)
+    this.sessionId = new SessionId(
+      config.description.BeginString,
+      config.description.SenderCompId,
+      config.description.TargetCompID
+    )
+    this.sessionStore = storeFactory.create(this.sessionId)
+
     const clock = new DefaultFixClock()
-    this.coordinator = new SessionSequenceCoordinator(sequenceStore, clock)
+    this.coordinator = new SessionSequenceCoordinator(this.sessionStore, clock)
     const lastReceivedSeqNum = config.description.LastReceivedSeqNum ?? 0
     this.coordinator.initializeFromConfig(undefined, lastReceivedSeqNum + 1)
   }
@@ -67,6 +83,14 @@ export abstract class AsciiSession extends FixSession {
             this.coordinator.onMessageReceived(seqNo, true)
             return true
           }
+          // Check if this is a delayed message that fills a pending gap range.
+          const pendingRequests = this.coordinator.pendingResendRequests
+          const inPendingGapRange = pendingRequests.some(p => seqNo >= p.begin && seqNo <= p.end)
+          if (inPendingGapRange) {
+            this.sessionLogger.info(`accepting delayed message seq ${seqNo} (in pending gap range)`)
+            this.coordinator.onMessageReceived(seqNo, false)
+            return true
+          }
           // serious problem ... drop immediately
           this.sessionLogger.warning(`terminate as seqDelta (${seqDelta}) < 0 lastSeq = ${lastSeq} seqNo = ${seqNo}`)
           this.stop()
@@ -106,8 +130,10 @@ export abstract class AsciiSession extends FixSession {
             }
           }
 
-          // Gap message is not forwarded to application — wait for resend to fill
-          // (C# accepts and forwards, but that's a PR 3D behaviour change)
+          // Accept the current message — don't block waiting for gap fill.
+          // The gap will be filled by the resend response, but this message is valid.
+          ret = true
+          state.lastPeerMsgSeqNum = seqNo
           this.coordinator.onMessageReceived(seqNo, false)
         } else {
           ret = true
@@ -250,9 +276,32 @@ export abstract class AsciiSession extends FixSession {
     this.sessionLogger.info('coordinator reset transient state for reconnect')
   }
 
+  protected override txOnEncoded (msgType: string, data: string, hdr: ILooseObject): void {
+    super.txOnEncoded(msgType, data, hdr)
+    // Store the encoded message in the session store for recovery/resend
+    const seqNum = hdr?.MsgSeqNum as number | undefined
+    if (seqNum != null) {
+      const record = new FixMsgStoreRecord(msgType, new Date(), seqNum, undefined, data)
+      this.sessionStore.put(record).catch((e: Error) => {
+        // Never block sends on store errors
+        this.sessionLogger.warning(`failed to store message seq=${seqNum}: ${e.message}`)
+      })
+    }
+  }
+
   private static readonly MaxLogonRetries = 100
   private static readonly MaxTimeoutRecoveryAttempts = 0
 
+  private static createStoreFactory (storeConfig?: { type: string, directory?: string }): IFixSessionStoreFactory {
+    if (!storeConfig) return new MemorySessionStoreFactory()
+    switch (storeConfig.type?.toLowerCase()) {
+      case 'file':
+        return new FileSessionStoreFactory(storeConfig.directory ?? 'store')
+      default:
+        return new MemorySessionStoreFactory()
+    }
+  }
+
   private handleLogonRejected (text: string | null): void {
     if (!this.coordinator.onLogonRejectedForSequence(AsciiSession.MaxLogonRetries)) {
       this.sessionLogger.warning(`max logon retries (${AsciiSession.MaxLogonRetries}) exceeded, giving up. Text='${text}'`)
@@ -488,6 +537,8 @@ export abstract class AsciiSession extends FixSession {
     const action: TickAction = sessionState.calcAction(new Date())
     const application: IMsgApplication | null = this.transport.config.description.application ?? null
     const logger = this.sessionLogger
+    // Clean up timed-out resend requests
+    this.coordinator.tick()
 
     switch (action) {
       case TickAction.Nothing: {

package/src/transport/session/session-description.ts

@@ -1,4 +1,5 @@
 import { IMsgApplication } from '../msg-application'
+import { StoreConfig } from '../../store/store-config'
 
 export interface IDynamicSessionParams {
   readonly Name: string
@@ -18,4 +19,5 @@ export interface ISessionDescription extends IDynamicSessionParams {
   LastSentSeqNum?: number
   readonly LastReceivedSeqNum?: number
   readonly BodyLengthChars?: number
+  readonly store?: StoreConfig
 }