jspurefix 5.1.0 → 5.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jspurefix",
-  "version": "5.1.0",
+  "version": "5.3.0",
   "description": "pure node js fix engine",
   "keywords": [
     "typescript",
@@ -74,42 +74,43 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@jest/globals": "^30.3.0",
     "align-text": "^1.0.2",
-    "axios": "^1.13.2",
+    "axios": "^1.14.0",
     "express": "^5.2.1",
     "lodash": "^4.17.23",
-    "mathjs": "^15.1.0",
+    "mathjs": "^15.1.1",
     "minimist": "^1.2.8",
     "minimist-options": "^4.1.0",
     "moment": "^2.30.1",
     "node-fs-extra": "^0.8.2",
     "reflect-metadata": "^0.2.2",
-    "sax": "^1.4.4",
+    "sax": "^1.6.0",
     "tsyringe": "^4.10.0",
     "uuid": "^9.0.1",
     "winston": "^3.19.0",
     "word-wrap": "^1.2.5",
-    "yauzl": "^3.2.0"
+    "yauzl": "^3.2.1"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^5.10.0",
     "@types/express": "^5.0.6",
     "@types/express-serve-static-core": "^5.1.1",
     "@types/jest": "^30.0.0",
-    "@types/lodash": "^4.17.23",
+    "@types/lodash": "^4.17.24",
     "@types/mathjs": "^9.4.2",
     "@types/minimist": "^1.2.5",
-    "@types/node": "^25.0.10",
+    "@types/node": "^25.5.0",
     "@types/request-promise-native": "^1.0.21",
     "@types/sax": "^1.2.7",
-    "@types/uuid": "^9.0.7",
+    "@types/uuid": "^9.0.8",
     "@types/winston": "^2.4.4",
     "eslint": "^9.39.4",
     "eslint-config-love": "^151.0.0",
-    "jest": "^30.2.0",
+    "jest": "^30.3.0",
     "madge": "^8.0.0",
     "standard": "^17.1.2",
     "ts-jest": "^29.4.6",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   }
 }

package/src/buffer/fixml/fixml-view.ts

@@ -3,7 +3,7 @@ import { FixDefinitions, SimpleFieldDefinition } from '../../dictionary/definiti
 import { Structure } from '../structure'
 import { SegmentDescription } from '../segment/segment-description'
 import { AsciiChars } from '../ascii/'
-import * as moment from 'moment'
+import moment = require('moment')
 import { TagType } from '../tag/tag-type'
 
 export class FixmlView extends MsgView {

package/src/buffer/msg-view.ts

@@ -265,7 +265,7 @@ export abstract class MsgView {
 
   public getView (name: string): MsgView | null {
     const parts: string[] = name.split('.')
-    const reducer = (a: MsgView, current: string): MsgView | null => {
+    const reducer = (a: MsgView | null, current: string): MsgView | null => {
       if (!a) {
         return a
       }

package/src/config/js-fix-config.ts

@@ -5,6 +5,7 @@ import { JsFixLoggerFactory } from './js-fix-logger-factory'
 import { EmptyLogFactory } from './empty-log-factory'
 import { AsciiChars } from '../buffer/ascii/ascii-chars'
 import { DependencyContainer } from 'tsyringe'
+import { IFixSessionStoreFactory } from '../store/fix-session-store-factory'
 
 export interface IJsFixConfig {
   factory: ISessionMsgFactory | null
@@ -14,6 +15,7 @@ export interface IJsFixConfig {
   logDelimiter?: number
   logFactory: JsFixLoggerFactory
   sessionContainer: DependencyContainer
+  sessionStoreFactory?: IFixSessionStoreFactory
 }
 
 export class JsFixConfig implements IJsFixConfig {

package/src/config/winston-logger.ts

@@ -68,13 +68,13 @@ export class WinstonLogger {
       },
 
       info: function (msg: string): void {
-        this.log(msg)
+        (this as any).log(msg)
       },
       debug: function (msg: string): void {
-        this.log(msg)
+        (this as any).log(msg)
       },
       warning: function (msg: string): void {
-        this.log(msg)
+        (this as any).log(msg)
       },
       error: function (): void {
         // nothing

package/src/dictionary/contained/contained-field-set.ts

@@ -138,7 +138,8 @@ export abstract class ContainedFieldSet implements IContainedSet {
    */
   public getSet (path: string): (IContainedSet | null) {
     if (!path) return null
-    return path.split('.').reduce((set: IContainedSet, next: string): (IContainedSet | null) => {
+    return path.split('.').reduce<IContainedSet | null>((set: IContainedSet | null, next: string): (IContainedSet | null) => {
+      if (!set) return null
       return set.groups.get(next) ?? set.components.get(next) ?? null
     }, this)
   }

package/src/dictionary/parser/fixml/fields-parser.ts

@@ -93,8 +93,8 @@ export class FieldsParser extends XsdParser {
   }
 
   private insertFields (): void {
-    const alias = this.alias
-    this.data.forEach((f: ISimpleField) => {
+    const alias = this.alias;
+    (this.data as ISimpleField[]).forEach((f: ISimpleField) => {
       const sf: SimpleFieldDefinition = new SimpleFieldDefinition(f.Tag,
         f.name,
         f.AbbrName,

package/src/jsfix-cmd.ts

@@ -11,7 +11,7 @@ import { MsgTag } from './types'
 import { IJsFixConfig } from './config'
 
 import * as util from 'util'
-import * as minimist from 'minimist'
+import minimist = require('minimist')
 import * as path from 'path'
 import { MsgTransport } from './transport/factory'
 import { EnumCompiler, ICompilerSettings, MsgCompiler } from './dictionary/compiler'

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

@@ -0,0 +1,294 @@
+import { IFixSessionStore } from './fix-session-store'
+import { SessionId } from './session-id'
+import { IFixMsgStoreRecord, FixMsgStoreRecord } from './fix-msg-store-record'
+import { ISessionStreamProvider } from './session-stream-provider'
+import { FileSessionStreamProvider } from './file-session-stream-provider'
+
+/**
+ * QuickFix-compatible file-based session store.
+ *
+ * File format:
+ * - .seqnums: "SSSSSSSSSSSSSSSSSSSS : TTTTTTTTTTTTTTTTTTTT" (20-char right-justified sender : target)
+ * - .session: "YYYYMMDD-HH:MM:SS.ffffff" (session creation time)
+ * - .header: "seqnum,offset,length" per line (index into body)
+ * - .body: concatenated raw FIX messages (no delimiters)
+ */
+export class FileSessionStore implements IFixSessionStore {
+  private readonly streamProvider: ISessionStreamProvider
+  private readonly ownsProvider: boolean
+
+  private senderSeqNumValue: number = 1
+  private targetSeqNumValue: number = 1
+  private creationTimeValue: Date = new Date()
+
+  // In-memory index: seqnum -> { offset, length }
+  private readonly headerIndex: Map<number, { offset: number, length: number }> = new Map()
+
+  /**
+   * Creates a FileSessionStore with the default file-based stream provider.
+   */
+  static createWithFiles (sessionId: SessionId, directory: string): FileSessionStore {
+    return new FileSessionStore(sessionId, new FileSessionStreamProvider(sessionId, directory), true)
+  }
+
+  /**
+   * Creates a FileSessionStore with a custom stream provider.
+   * Useful for testing with in-memory streams.
+   */
+  constructor (
+    public readonly sessionId: SessionId,
+    streamProvider: ISessionStreamProvider,
+    ownsProvider: boolean = false
+  ) {
+    this.streamProvider = streamProvider
+    this.ownsProvider = ownsProvider
+  }
+
+  /**
+   * Gets the stream provider for direct access (useful for testing).
+   */
+  getStreamProvider (): ISessionStreamProvider {
+    return this.streamProvider
+  }
+
+  // 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
+    await this.persistSeqNums()
+  }
+
+  async setTargetSeqNum (value: number): Promise<void> {
+    this.targetSeqNumValue = value
+    await this.persistSeqNums()
+  }
+
+  async nextSenderSeqNum (): Promise<number> {
+    const next = ++this.senderSeqNumValue
+    await this.persistSeqNums()
+    return next
+  }
+
+  async nextTargetSeqNum (): Promise<number> {
+    const next = ++this.targetSeqNumValue
+    await this.persistSeqNums()
+    return next
+  }
+
+  // Session
+
+  get creationTime (): Date {
+    return this.creationTimeValue
+  }
+
+  async reset (): Promise<void> {
+    this.senderSeqNumValue = 1
+    this.targetSeqNumValue = 1
+    this.creationTimeValue = new Date()
+    this.headerIndex.clear()
+
+    await this.streamProvider.reset()
+    await this.persistSeqNums()
+    await this.persistSessionTime()
+    this.streamProvider.openBody()
+  }
+
+  // Message Operations
+
+  async put (record: IFixMsgStoreRecord): Promise<void> {
+    if (record.encoded == null) {
+      throw new Error('Record must have encoded content')
+    }
+
+    const bytes = Buffer.from(record.encoded, 'utf8')
+    const length = bytes.length
+    const offset = await this.streamProvider.appendBody(bytes)
+    this.headerIndex.set(record.seqNum, { offset, length })
+    await this.streamProvider.appendHeaderLine(`${record.seqNum},${offset},${length}`)
+  }
+
+  async get (seqNum: number): Promise<IFixMsgStoreRecord | null> {
+    const entry = this.headerIndex.get(seqNum)
+    if (!entry) return null
+    return await this.readMessage(seqNum, entry.offset, entry.length)
+  }
+
+  async getRange (fromSeqNum: number, toSeqNum: number): Promise<IFixMsgStoreRecord[]> {
+    const results: IFixMsgStoreRecord[] = []
+    for (let seq = fromSeqNum; seq <= toSeqNum; seq++) {
+      const record = await this.get(seq)
+      if (record) {
+        results.push(record)
+      }
+    }
+    return results
+  }
+
+  // Lifecycle
+
+  async initialize (): Promise<void> {
+    await this.loadSeqNums()
+    await this.loadSessionTime()
+    await this.loadHeaderIndex()
+    this.streamProvider.openBody()
+  }
+
+  async flush (): Promise<void> {
+    await this.streamProvider.flush()
+  }
+
+  async dispose (): Promise<void> {
+    await this.streamProvider.flush()
+    if (this.ownsProvider) {
+      await this.streamProvider.dispose()
+    }
+  }
+
+  // Private - persistence
+
+  private async persistSeqNums (): Promise<void> {
+    const sender = this.senderSeqNumValue.toString().padStart(20, ' ')
+    const target = this.targetSeqNumValue.toString().padStart(20, ' ')
+    await this.streamProvider.writeSeqNums(`${sender} : ${target}`)
+  }
+
+  private async loadSeqNums (): Promise<void> {
+    const content = await this.streamProvider.readSeqNums()
+    if (content == null) {
+      this.senderSeqNumValue = 1
+      this.targetSeqNumValue = 1
+      return
+    }
+    const parts = content.split(':')
+    if (parts.length === 2) {
+      this.senderSeqNumValue = parseInt(parts[0].trim(), 10) || 1
+      this.targetSeqNumValue = parseInt(parts[1].trim(), 10) || 1
+    }
+  }
+
+  private async persistSessionTime (): Promise<void> {
+    await this.streamProvider.writeSessionTime(FileSessionStore.formatSessionTime(this.creationTimeValue))
+  }
+
+  private async loadSessionTime (): Promise<void> {
+    const content = await this.streamProvider.readSessionTime()
+    if (content == null) {
+      this.creationTimeValue = new Date()
+      await this.persistSessionTime()
+      return
+    }
+    const parsed = FileSessionStore.parseSessionTime(content.trim())
+    this.creationTimeValue = parsed ?? new Date()
+  }
+
+  private async loadHeaderIndex (): Promise<void> {
+    const lines = await this.streamProvider.readHeaderLines()
+    for (const line of lines) {
+      if (!line.trim()) continue
+      const parts = line.split(',')
+      if (parts.length === 3) {
+        const seqNum = parseInt(parts[0], 10)
+        const offset = parseInt(parts[1], 10)
+        const length = parseInt(parts[2], 10)
+        if (!isNaN(seqNum) && !isNaN(offset) && !isNaN(length)) {
+          this.headerIndex.set(seqNum, { offset, length })
+        }
+      }
+    }
+  }
+
+  // Private - message reading
+
+  private async readMessage (seqNum: number, offset: number, length: number): Promise<IFixMsgStoreRecord | null> {
+    const buffer = await this.streamProvider.readBody(offset, length)
+    if (buffer.length !== length) return null
+
+    const encoded = buffer.toString('utf8')
+    const msgType = FileSessionStore.extractTag(encoded, '35')
+    const sendingTimeStr = FileSessionStore.extractTag(encoded, '52')
+    let timestamp = new Date(0)
+    if (sendingTimeStr) {
+      const parsed = FileSessionStore.parseSessionTime(sendingTimeStr)
+      if (parsed) timestamp = parsed
+    }
+
+    return new FixMsgStoreRecord(msgType ?? '', timestamp, seqNum, undefined, encoded)
+  }
+
+  /**
+   * Extract a FIX tag value from a raw message string.
+   * Tags are delimited by SOH (0x01) or pipe (|).
+   */
+  static extractTag (message: string, tag: string): string | null {
+    const tagPrefix = `${tag}=`
+
+    // Check if tag is at the start
+    if (message.startsWith(tagPrefix)) {
+      const endIndex = FileSessionStore.findDelimiter(message, tagPrefix.length)
+      return message.substring(tagPrefix.length, endIndex)
+    }
+
+    // Search for SOH + tag= or | + tag=
+    for (const delim of ['\x01', '|']) {
+      const search = `${delim}${tagPrefix}`
+      const idx = message.indexOf(search)
+      if (idx >= 0) {
+        const startIndex = idx + search.length
+        const endIndex = FileSessionStore.findDelimiter(message, startIndex)
+        return message.substring(startIndex, endIndex)
+      }
+    }
+
+    return null
+  }
+
+  private static findDelimiter (message: string, fromIndex: number): number {
+    for (let i = fromIndex; i < message.length; i++) {
+      const ch = message.charAt(i)
+      if (ch === '\x01' || ch === '|') return i
+    }
+    return message.length
+  }
+
+  /**
+   * Format a date as QuickFix session time: YYYYMMDD-HH:MM:SS.ffffff
+   */
+  static formatSessionTime (date: Date): string {
+    const y = date.getUTCFullYear()
+    const M = (date.getUTCMonth() + 1).toString().padStart(2, '0')
+    const d = date.getUTCDate().toString().padStart(2, '0')
+    const h = date.getUTCHours().toString().padStart(2, '0')
+    const m = date.getUTCMinutes().toString().padStart(2, '0')
+    const s = date.getUTCSeconds().toString().padStart(2, '0')
+    const ms = date.getUTCMilliseconds().toString().padStart(3, '0')
+    return `${y}${M}${d}-${h}:${m}:${s}.${ms}000`
+  }
+
+  /**
+   * Parse a QuickFix session time string: YYYYMMDD-HH:MM:SS.fff[fff]
+   */
+  static parseSessionTime (str: string): Date | null {
+    // Format: YYYYMMDD-HH:MM:SS.ffffff
+    const match = str.match(/^(\d{4})(\d{2})(\d{2})-(\d{2}):(\d{2}):(\d{2})\.(\d{3,6})$/)
+    if (!match) return null
+    const [, y, M, d, h, m, s, frac] = match
+    const ms = parseInt(frac.substring(0, 3), 10)
+    return new Date(Date.UTC(parseInt(y), parseInt(M) - 1, parseInt(d), parseInt(h), parseInt(m), parseInt(s), ms))
+  }
+}

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

@@ -0,0 +1,123 @@
+import * as fs from 'fs'
+import { ISessionStreamProvider } from './session-stream-provider'
+import { SessionId } from './session-id'
+
+/**
+ * File-based implementation of ISessionStreamProvider.
+ * Creates QuickFix-compatible files in the specified directory.
+ *
+ * Files created:
+ * - {prefix}.body   — concatenated raw FIX messages
+ * - {prefix}.header — index lines: "seqnum,offset,length"
+ * - {prefix}.seqnums — sender/target sequence numbers
+ * - {prefix}.session — session creation time
+ */
+export class FileSessionStreamProvider implements ISessionStreamProvider {
+  private readonly bodyPath: string
+  private readonly headerPath: string
+  private readonly seqNumsPath: string
+  private readonly sessionPath: string
+  private bodyFd: number | null = null
+  private bodySize: number = 0
+
+  constructor (
+    sessionId: SessionId,
+    directory: string
+  ) {
+    fs.mkdirSync(directory, { recursive: true })
+    this.bodyPath = sessionId.getFilePath(directory, 'body')
+    this.headerPath = sessionId.getFilePath(directory, 'header')
+    this.seqNumsPath = sessionId.getFilePath(directory, 'seqnums')
+    this.sessionPath = sessionId.getFilePath(directory, 'session')
+  }
+
+  openBody (): void {
+    if (this.bodyFd !== null) return
+    this.bodyFd = fs.openSync(this.bodyPath, 'a+')
+    const stat = fs.fstatSync(this.bodyFd)
+    this.bodySize = stat.size
+  }
+
+  async appendBody (data: Buffer): Promise<number> {
+    if (this.bodyFd === null) {
+      this.openBody()
+    }
+    const offset = this.bodySize
+    fs.writeSync(this.bodyFd!, data, 0, data.length, offset)
+    this.bodySize += data.length
+    return offset
+  }
+
+  async readBody (offset: number, length: number): Promise<Buffer> {
+    if (this.bodyFd === null) {
+      this.openBody()
+    }
+    const buf = Buffer.alloc(length)
+    fs.readSync(this.bodyFd!, buf, 0, length, offset)
+    return buf
+  }
+
+  getBodySize (): number {
+    return this.bodySize
+  }
+
+  async appendHeaderLine (line: string): Promise<void> {
+    await fs.promises.appendFile(this.headerPath, line + '\n', 'utf8')
+  }
+
+  async readHeaderLines (): Promise<string[]> {
+    if (!fs.existsSync(this.headerPath)) return []
+    const content = await fs.promises.readFile(this.headerPath, 'utf8')
+    if (!content.trim()) return []
+    return content.split('\n').filter(l => l.trim().length > 0)
+  }
+
+  async readSeqNums (): Promise<string | null> {
+    if (!fs.existsSync(this.seqNumsPath)) return null
+    return await fs.promises.readFile(this.seqNumsPath, 'utf8')
+  }
+
+  async writeSeqNums (content: string): Promise<void> {
+    await fs.promises.writeFile(this.seqNumsPath, content, 'utf8')
+  }
+
+  async readSessionTime (): Promise<string | null> {
+    if (!fs.existsSync(this.sessionPath)) return null
+    return await fs.promises.readFile(this.sessionPath, 'utf8')
+  }
+
+  async writeSessionTime (content: string): Promise<void> {
+    await fs.promises.writeFile(this.sessionPath, content, 'utf8')
+  }
+
+  async reset (): Promise<void> {
+    if (this.bodyFd !== null) {
+      fs.closeSync(this.bodyFd)
+      this.bodyFd = null
+    }
+    this.bodySize = 0
+    this.deleteIfExists(this.bodyPath)
+    this.deleteIfExists(this.headerPath)
+    this.deleteIfExists(this.seqNumsPath)
+    this.deleteIfExists(this.sessionPath)
+  }
+
+  async flush (): Promise<void> {
+    if (this.bodyFd !== null) {
+      fs.fsyncSync(this.bodyFd)
+    }
+  }
+
+  async dispose (): Promise<void> {
+    if (this.bodyFd !== null) {
+      fs.closeSync(this.bodyFd)
+      this.bodyFd = null
+    }
+  }
+
+  private deleteIfExists (filePath: string): void {
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath)
+    }
+  }
+}

package/src/store/fix-msg-ascii-store-resend.ts

@@ -87,7 +87,7 @@ export class FixMsgAsciiStoreResend {
   private sequenceResetGap (startGap: number, newSeq: number): IFixMsgStoreRecord {
     const factory = this.config.factory
     const gapFill: ISequenceReset = factory?.sequenceReset(newSeq, true) as ISequenceReset
-    gapFill.StandardHeader = factory?.header(MsgType.SequenceReset, startGap) as IStandardHeader
+    gapFill.StandardHeader = factory?.header(MsgType.SequenceReset, startGap, new Date()) as IStandardHeader
     gapFill.StandardHeader.PossDupFlag = true
 
     return new FixMsgStoreRecord(

package/src/store/fix-session-store-factory.ts

@@ -0,0 +1,31 @@
+import { IFixSessionStore } from './fix-session-store'
+import { SessionId } from './session-id'
+import { MemorySessionStore } from './memory-session-store'
+import { FileSessionStore } from './file-session-store'
+
+/**
+ * Factory for creating session stores.
+ */
+export interface IFixSessionStoreFactory {
+  create (sessionId: SessionId): IFixSessionStore
+}
+
+/**
+ * Factory for creating in-memory session stores.
+ */
+export class MemorySessionStoreFactory implements IFixSessionStoreFactory {
+  create (sessionId: SessionId): IFixSessionStore {
+    return new MemorySessionStore(sessionId)
+  }
+}
+
+/**
+ * Factory for creating file-based session stores.
+ */
+export class FileSessionStoreFactory implements IFixSessionStoreFactory {
+  constructor (private readonly directory: string) {}
+
+  create (sessionId: SessionId): IFixSessionStore {
+    return FileSessionStore.createWithFiles(sessionId, this.directory)
+  }
+}

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

@@ -0,0 +1,37 @@
+import { SessionId } from './session-id'
+import { IFixMsgStoreRecord } from './fix-msg-store-record'
+
+/**
+ * Unified session store interface for FIX message persistence and sequence number management.
+ * Coordinates all persistence for a single FIX session:
+ * - Message storage (.body + .header files)
+ * - Sequence numbers (.seqnums file)
+ * - Session metadata (.session file)
+ *
+ * QuickFix-compatible file format for interoperability.
+ */
+export interface IFixSessionStore {
+  readonly sessionId: SessionId
+
+  // Message Operations
+  put (record: IFixMsgStoreRecord): Promise<void>
+  get (seqNum: number): Promise<IFixMsgStoreRecord | null>
+  getRange (fromSeqNum: number, toSeqNum: number): Promise<IFixMsgStoreRecord[]>
+
+  // Sequence Number Operations
+  senderSeqNum: number
+  targetSeqNum: number
+  setSenderSeqNum (value: number): Promise<void>
+  setTargetSeqNum (value: number): Promise<void>
+  nextSenderSeqNum (): Promise<number>
+  nextTargetSeqNum (): Promise<number>
+
+  // Session Operations
+  readonly creationTime: Date
+  reset (): Promise<void>
+
+  // Lifecycle
+  initialize (): Promise<void>
+  flush (): Promise<void>
+  dispose (): Promise<void>
+}

package/src/store/index.ts

@@ -2,3 +2,12 @@ export * from './fix-msg-memory-store'
 export * from './fix-msg-store'
 export * from './fix-msg-store-record'
 export * from './fix-msg-ascii-store-resend'
+export * from './session-id'
+export * from './fix-session-store'
+export * from './memory-session-store'
+export * from './fix-session-store-factory'
+export * from './session-stream-provider'
+export * from './memory-session-stream-provider'
+export * from './file-session-stream-provider'
+export * from './file-session-store'
+export * from './store-config'