jspurefix 5.1.0 → 5.3.0

package/src/store/memory-session-store.ts

@@ -0,0 +1,102 @@
+import { IFixSessionStore } from './fix-session-store'
+import { SessionId } from './session-id'
+import { IFixMsgStoreRecord } from './fix-msg-store-record'
+
+/**
+ * In-memory session store for testing and development.
+ * Not persistent - all data lost on dispose.
+ */
+export class MemorySessionStore implements IFixSessionStore {
+  private readonly messages: Map<number, IFixMsgStoreRecord> = new Map()
+  private senderSeqNumValue: number = 1
+  private targetSeqNumValue: number = 1
+  private creationTimeValue: Date = new Date()
+
+  constructor (public readonly sessionId: SessionId) {}
+
+  // Sequence Numbers
+
+  get senderSeqNum (): number {
+    return this.senderSeqNumValue
+  }
+
+  set senderSeqNum (value: number) {
+    this.senderSeqNumValue = value
+  }
+
+  get targetSeqNum (): number {
+    return this.targetSeqNumValue
+  }
+
+  set targetSeqNum (value: number) {
+    this.targetSeqNumValue = value
+  }
+
+  async setSenderSeqNum (value: number): Promise<void> {
+    this.senderSeqNumValue = value
+  }
+
+  async setTargetSeqNum (value: number): Promise<void> {
+    this.targetSeqNumValue = value
+  }
+
+  async nextSenderSeqNum (): Promise<number> {
+    return ++this.senderSeqNumValue
+  }
+
+  async nextTargetSeqNum (): Promise<number> {
+    return ++this.targetSeqNumValue
+  }
+
+  // Session
+
+  get creationTime (): Date {
+    return this.creationTimeValue
+  }
+
+  async reset (): Promise<void> {
+    this.senderSeqNumValue = 1
+    this.targetSeqNumValue = 1
+    this.creationTimeValue = new Date()
+    this.messages.clear()
+  }
+
+  // Message Operations
+
+  async put (record: IFixMsgStoreRecord): Promise<void> {
+    this.messages.set(record.seqNum, record.clone())
+  }
+
+  async get (seqNum: number): Promise<IFixMsgStoreRecord | null> {
+    const record = this.messages.get(seqNum)
+    return record ? record.clone() : null
+  }
+
+  async getRange (fromSeqNum: number, toSeqNum: number): Promise<IFixMsgStoreRecord[]> {
+    const results: IFixMsgStoreRecord[] = []
+    const keys = Array.from(this.messages.keys())
+      .filter(k => k >= fromSeqNum && k <= toSeqNum)
+      .sort((a, b) => a - b)
+    for (const seq of keys) {
+      const record = this.messages.get(seq)
+      if (record) {
+        results.push(record.clone())
+      }
+    }
+    return results
+  }
+
+  // Lifecycle
+
+  async initialize (): Promise<void> {
+    // No-op for memory store
+  }
+
+  async flush (): Promise<void> {
+    // No-op for memory store
+  }
+
+  async dispose (): Promise<void> {
+    // No-op for memory store
+  }
+}

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

@@ -0,0 +1,97 @@
+import { ISessionStreamProvider } from './session-stream-provider'
+
+/**
+ * In-memory implementation of ISessionStreamProvider for testing.
+ * Stores all data in buffers and strings for inspection.
+ */
+export class MemorySessionStreamProvider implements ISessionStreamProvider {
+  private bodyBuffer: Buffer = Buffer.alloc(0)
+  private headerLines: string[] = []
+  private seqNumsContent: string | null = null
+  private sessionTimeContent: string | null = null
+
+  // Inspection methods for tests
+
+  getBodyBytes (): Buffer {
+    return Buffer.from(this.bodyBuffer)
+  }
+
+  getBodyString (): string {
+    return this.bodyBuffer.toString('utf8')
+  }
+
+  getHeaderString (): string {
+    return this.headerLines.join('\n')
+  }
+
+  getHeaderLinesSnapshot (): string[] {
+    return [...this.headerLines]
+  }
+
+  getSeqNumsContent (): string | null {
+    return this.seqNumsContent
+  }
+
+  getSessionTimeContent (): string | null {
+    return this.sessionTimeContent
+  }
+
+  // ISessionStreamProvider implementation
+
+  openBody (): void {
+    // No-op for memory provider, body is always available
+  }
+
+  async appendBody (data: Buffer): Promise<number> {
+    const offset = this.bodyBuffer.length
+    this.bodyBuffer = Buffer.concat([this.bodyBuffer, data])
+    return offset
+  }
+
+  async readBody (offset: number, length: number): Promise<Buffer> {
+    return this.bodyBuffer.subarray(offset, offset + length)
+  }
+
+  getBodySize (): number {
+    return this.bodyBuffer.length
+  }
+
+  async appendHeaderLine (line: string): Promise<void> {
+    this.headerLines.push(line)
+  }
+
+  async readHeaderLines (): Promise<string[]> {
+    return [...this.headerLines]
+  }
+
+  async readSeqNums (): Promise<string | null> {
+    return this.seqNumsContent
+  }
+
+  async writeSeqNums (content: string): Promise<void> {
+    this.seqNumsContent = content
+  }
+
+  async readSessionTime (): Promise<string | null> {
+    return this.sessionTimeContent
+  }
+
+  async writeSessionTime (content: string): Promise<void> {
+    this.sessionTimeContent = content
+  }
+
+  async reset (): Promise<void> {
+    this.bodyBuffer = Buffer.alloc(0)
+    this.headerLines = []
+    this.seqNumsContent = null
+    this.sessionTimeContent = null
+  }
+
+  async flush (): Promise<void> {
+    // No-op for memory provider
+  }
+
+  async dispose (): Promise<void> {
+    // No-op for memory provider
+  }
+}

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,16 +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 { 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)
@@ -19,6 +32,21 @@ export abstract class AsciiSession extends FixSession {
     this.requestLogonType = MsgType.Logon
     this.store = new FixMsgMemoryStore(this.config.description.SenderCompId, this.config)
     this.resender = new FixMsgAsciiStoreResend(this.store, this.config)
+
+    // 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(this.sessionStore, clock)
+    const lastReceivedSeqNum = config.description.LastReceivedSeqNum ?? 0
+    this.coordinator.initializeFromConfig(undefined, lastReceivedSeqNum + 1)
   }
 
   private checkSeqNo (msgType: string, view: MsgView): boolean {
@@ -27,6 +55,19 @@ export abstract class AsciiSession extends FixSession {
         return true
       }
 
+      case MsgType.Logon: {
+        // If peer sends ResetSeqNumFlag=Y, accept any sequence number.
+        // PeerLogon handles the full sequence reset.
+        if (view.getTyped(MsgTag.ResetSeqNumFlag) === true) {
+          this.sessionLogger.info('logon with ResetSeqNumFlag=Y, accepting regardless of sequence')
+          const seqNo = view.getTyped(MsgTag.MsgSeqNum) as number
+          this.sessionState.lastPeerMsgSeqNum = seqNo
+          this.coordinator.onMessageReceived(seqNo, false)
+          return true
+        }
+      }
+      // falls through
+
       default: {
         const state = this.sessionState
         const lastSeq: number = state.lastPeerMsgSeqNum
@@ -34,11 +75,28 @@ export abstract class AsciiSession extends FixSession {
         let ret: boolean = false
         const seqDelta: number = seqNo - lastSeq
         if (seqDelta <= 0) {
+          // Check if this is a PossDupFlag=Y message (resend replay) before rejecting.
+          // PossDupFlag messages have old sequence numbers and bypass normal checks.
+          const possDupFlag = view.getTyped(MsgTag.PossDupFlag) as boolean | undefined
+          if (possDupFlag === true) {
+            this.sessionLogger.debug(`message '${msgType}' has PossDupFlag=Y, bypassing sequence check`)
+            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()
         } else if (seqDelta > 1) {
           // resend request required as have missed messages.
+          const expectedSeq = lastSeq + 1
 
           // We process a Logon beforehand to confirm the connection even we out of sync
           if (msgType === MsgType.Logon) {
@@ -49,10 +107,43 @@ export abstract class AsciiSession extends FixSession {
           if (msgType === MsgType.ResendRequest) {
             this.onResendRequest(view)
           }
-          this.sendResendRequest(lastSeq, seqNo)
+
+          // Use coordinator to determine what action to take for the gap
+          const action = this.coordinator.onGapDetected(expectedSeq, seqNo)
+          this.sessionLogger.info(`gap action: ${action}`)
+
+          switch (action.type) {
+            case ResendActionType.SendResendRequest: {
+              if (action.begin != null && action.end != null) {
+                this.sendResendRequest(lastSeq, seqNo)
+                this.coordinator.recordResendRequestSent(action.begin, action.end)
+              }
+              break
+            }
+            case ResendActionType.Wait: {
+              this.sessionLogger.info(`waiting for existing resend request: ${action.reason}`)
+              break
+            }
+            case ResendActionType.SendGapFill: {
+              this.sessionLogger.warning(`gap recovery abandoned (storm protection): ${action.reason}`)
+              break
+            }
+          }
+
+          // 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
           state.lastPeerMsgSeqNum = seqNo
+          this.coordinator.onMessageReceived(seqNo, false)
+        }
+
+        // Reset timeout recovery on successful message receipt
+        if (ret) {
+          this.coordinator.resetTimeoutRecovery()
         }
         return ret
       }
@@ -180,6 +271,51 @@ export abstract class AsciiSession extends FixSession {
     })
   }
 
+  protected override onPrepareForReconnect (): void {
+    this.coordinator.prepareForReconnect()
+    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}'`)
+      this.setState(SessionState.PeerLogonRejected)
+      this.stop()
+      return
+    }
+
+    // The encoder's msgSeqNum is already incremented after each message is sent,
+    // so we just need to retry the logon. The next logon will use the next sequence number.
+    this.sessionLogger.info(`LOGON_SEQ_RETRY: attempt=${this.coordinator.logonRetryCount}/${AsciiSession.MaxLogonRetries}, reason='${text}'`)
+    this.sendLogon()
+  }
+
   okForLogon (): boolean {
     const state = this.sessionState.state
     if (this.acceptor) {
@@ -230,14 +366,29 @@ export abstract class AsciiSession extends FixSession {
 
       case MsgType.SequenceReset: {
         const newSeqNo: number = view.getTyped(MsgTag.NewSeqNo) as number
+        const gapFillSeq: number = view.getTyped(MsgTag.MsgSeqNum) as number
         logger.info(`peer sends '${msgType}' sequence reset. newSeqNo = ${newSeqNo}`)
         // expect  newSeqNo to be the next message's sequence number.
         this.sessionState.lastPeerMsgSeqNum = newSeqNo - 1
+        // Notify coordinator to update expected target and clear pending resend requests
+        this.coordinator.onGapFillReceived(gapFillSeq, newSeqNo)
         break
       }
 
       case MsgType.Reject: {
-        logger.info(`peer rejects type '${msgType}' with text '${view.getTyped(MsgTag.Text)}'`)
+        const refMsgType = view.getString(MsgTag.RefMsgType)
+        const text = view.getString(MsgTag.Text)
+        const reason = view.getTyped(MsgTag.SessionRejectReason) as number | undefined
+        logger.info(`peer rejects RefMsgType='${refMsgType}', reason=${reason}, text='${text}'`)
+
+        // Check if this is a logon rejection due to sequence mismatch while we're waiting for logon response.
+        // Only retry for ValueIsIncorrect (sequence too low) — structural rejections (RequiredTagMissing etc.)
+        // indicate a config problem that retrying won't fix.
+        if (refMsgType === MsgType.Logon &&
+            this.sessionState.state === SessionState.InitiationLogonSent &&
+            reason === SessionRejectReason.ValueIsIncorrect) {
+          this.handleLogonRejected(text)
+        }
         break
       }
     }
@@ -291,7 +442,34 @@ export abstract class AsciiSession extends FixSession {
   private peerLogon (view: MsgView): void {
     const logger = this.sessionLogger
     const [heartBtInt, peerCompId, userName, password] = view.getTypedTags([MsgTag.HeartBtInt, MsgTag.SenderCompID, MsgTag.Username, MsgTag.Password])
-    logger.info(`peerLogon Username = ${userName}, heartBtInt = ${heartBtInt}, peerCompId = ${peerCompId}, userName = ${userName}`)
+    const resetSeqNumFlag = view.getTyped(MsgTag.ResetSeqNumFlag) as boolean | undefined
+    logger.info(`peerLogon Username = ${userName}, heartBtInt = ${heartBtInt}, peerCompId = ${peerCompId}, resetSeqNumFlag = ${resetSeqNumFlag}`)
+
+    // Handle ResetSeqNumFlag from peer's logon
+    if (resetSeqNumFlag === true) {
+      const peerSeqNum = (view.getTyped(MsgTag.MsgSeqNum) as number) ?? 1
+      const weAlsoReset = this.config.description.ResetSeqNumFlag
+      logger.info(`peer sent ResetSeqNumFlag=Y with seqNum=${peerSeqNum}, weAlsoReset=${weAlsoReset}`)
+
+      const transmitter = this.transport?.transmitter as AsciiMsgTransmitter | undefined
+      const savedEncoderSeqNum = weAlsoReset && transmitter ? transmitter.msgSeqNum : null
+
+      // Fire-and-forget the async coordinator call (store updates resolve on next microtask)
+      // but compute the expected values synchronously since we know the reset outcome
+      this.coordinator.handlePeerReset(peerSeqNum, weAlsoReset)
+      if (transmitter) {
+        transmitter.msgSeqNum = savedEncoderSeqNum ?? 1
+      }
+      this.sessionState.lastPeerMsgSeqNum = peerSeqNum
+
+      // Recreate resender with empty store
+      if (this.store) {
+        this.store.clear()
+        this.resender = new FixMsgAsciiStoreResend(this.store, this.config)
+      }
+      logger.info(`reset complete: encoderSeqNum=${transmitter?.msgSeqNum}, lastPeerMsgSeqNum=${peerSeqNum}`)
+    }
+
     const state = this.sessionState
     state.peerHeartBeatSecs = view.getTyped(MsgTag.HeartBtInt) as number
     state.peerCompId = view.getTyped(MsgTag.SenderCompID) as string
@@ -301,11 +479,34 @@ export abstract class AsciiSession extends FixSession {
     if (this.acceptor) {
       this.setState(SessionState.InitiationLogonResponse)
       logger.info('acceptor responds to logon request')
+
+      // If WE (acceptor) are sending ResetSeqNumFlag=Y but peer didn't request it,
+      // reset our sequences before sending our logon response.
+      // This handles the broker-reset pattern where client sends N, we respond with Y.
+      const weReset = this.config.description.ResetSeqNumFlag
+      if (weReset && resetSeqNumFlag !== true) {
+        logger.info('acceptor sending ResetSeqNumFlag=Y (peer sent N), resetting sequences')
+        // Fire-and-forget async coordinator call, set values synchronously
+        this.coordinator.resetAsAcceptor()
+        const transmitter = this.transport?.transmitter as AsciiMsgTransmitter | undefined
+        if (transmitter) {
+          transmitter.msgSeqNum = 1
+        }
+        this.sessionState.lastPeerMsgSeqNum = 0
+        if (this.store) {
+          this.store.clear()
+          this.resender = new FixMsgAsciiStoreResend(this.store, this.config)
+        }
+      }
+
       this.sendLogon() // if res send response else reject, terminate
     } else { // as an initiator the acceptor has responded
       logger.info('initiator receives logon response')
       this.setState(SessionState.InitiationLogonReceived)
     }
+    // Reset logon retry counter on successful logon
+    this.coordinator.resetLogonRetryCount()
+
     if (this.heartbeat) {
       this.startTimer()
     }
@@ -336,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: {
@@ -356,8 +559,17 @@ export abstract class AsciiSession extends FixSession {
       }
 
       case TickAction.TerminateOnError: {
-        logger.info(sessionState.toString())
-        this.terminate(new Error(`${application?.name}: peer not responding`))
+        if (this.coordinator.incrementTimeoutRecovery(AsciiSession.MaxTimeoutRecoveryAttempts)) {
+          // Try to recover — reset timeout state to give session a fresh window.
+          // This helps survive sleep/wake scenarios where TCP connection may still be alive.
+          logger.info(`timeout recovery attempt ${this.coordinator.timeoutRecoveryAttempts}, resetting timeout state`)
+          sessionState.lastTestRequestAt = null
+          sessionState.lastReceivedAt = new Date()
+          this.setState(SessionState.ActiveNormalSession)
+        } else {
+          logger.info(sessionState.toString())
+          this.terminate(new Error(`${application?.name}: peer not responding`))
+        }
         break
       }
 

package/src/transport/fixml/fixml-msg-transmitter.ts

@@ -22,7 +22,7 @@ export class FixmlMsgTransmitter extends MsgTransmitter {
     }
     const fe = this.encoder as FixmlEncoder
     const factory = this.config.factory
-    obj.StandardHeader = factory?.header()
+    obj.StandardHeader = factory?.header(msgType, 0, new Date())
     fe.encode(obj, msgType)
     return obj.StandardHeader
   }

package/src/transport/http/http-acceptor.ts

@@ -4,7 +4,7 @@ import { IJsFixConfig, IJsFixLogger } from '../../config'
 import { IFixmlRequest } from '../fixml'
 import { FixDuplex, StringDuplex, StringDuplexTraits } from '../duplex'
 
-import * as express from 'express'
+import express = require('express')
 import * as bodyParser from 'body-parser'
 import * as http from 'http'
 import { v4 as uuidv4 } from 'uuid'

package/src/transport/session/a-session-msg-factory.ts

@@ -31,7 +31,7 @@ export abstract class ASessionMsgFactory implements ISessionMsgFactory {
   }
 
   // see implementations Ascii and Fixml
-  public abstract logon (userRequestId: string, isResponse: boolean): ILooseObject
+  public abstract logon (userRequestId?: string, isResponse?: boolean): ILooseObject
   public abstract logout (msgType: string, text: string): ILooseObject
   public abstract header (msgType: string, seqNum: number, time: Date, overrideData?: Partial<IStandardHeader>): ILooseObject
 

package/src/transport/session/fix-clock.ts

@@ -0,0 +1,9 @@
+export interface IFixClock {
+  now (): Date
+}
+
+export class DefaultFixClock implements IFixClock {
+  now (): Date {
+    return new Date()
+  }
+}