jspurefix 1.1.2 → 1.4.1

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

@@ -0,0 +1,87 @@
+import { IFixMsgStore } from './fix-msg-store'
+import { FixMsgStoreRecord, IFixMsgStoreRecord } from './fix-msg-store-record'
+import { IJsFixConfig } from '../config'
+import { MsgType } from '../types'
+import { AsciiParser, MsgView } from '../buffer'
+import { ISequenceReset, IStandardHeader } from '../types/FIX4.4/repo'
+
+export class FixMsgAsciiStoreResend {
+  parser: AsciiParser
+  constructor (public readonly store: IFixMsgStore, public readonly config: IJsFixConfig) {
+    this.parser = new AsciiParser(this.config.definitions, null, this.config.delimiter)
+  }
+
+  public getResendRequest (startSeq: number, endSeq: number): Promise<IFixMsgStoreRecord[]> {
+
+    // need to cover request from start to end where any missing numbers are
+    // included as gaps to allow vector of messages to be sent by the session
+    // on a request
+
+    return new Promise((resolve, reject) => {
+      this.store.getSeqNumRange(startSeq, endSeq).then(res => {
+        resolve(this.inflateRange(startSeq, endSeq, res))
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  private inflateRange (startSeq: number, endSeq: number, input: IFixMsgStoreRecord[]): IFixMsgStoreRecord[] {
+    const toResend: IFixMsgStoreRecord[] = []
+    let expected = startSeq
+    for (let i = 0; i < input.length; ++i) {
+      const record = input[i].clone()
+      const seqNum = record.seqNum
+      const toGap = seqNum - expected
+      if (toGap > 0) {
+        this.gap(expected, seqNum, toResend)
+      }
+      expected = seqNum + 1
+      if (record.encoded) {
+        this.inflate(record)
+      }
+      toResend.push(record)
+    }
+    if (endSeq - expected > 0) {
+      this.gap(expected, endSeq + 1, toResend)
+    }
+    return toResend
+  }
+
+  public gap (beginGap: number, seqNum: number, arr: IFixMsgStoreRecord[]) {
+    if (beginGap > 0) {
+      arr.push(this.sequenceResetGap(beginGap, seqNum))
+    }
+  }
+
+  // if records were sent as encoded text then inflate back to object
+  // so can be resent or examined
+
+  public inflate (record: IFixMsgStoreRecord): void {
+    if (record.obj) return
+    if (!record.encoded) return
+    const parser = this.parser
+    parser.on('error', (e: Error) => {
+      record.obj = null
+    })
+    parser.on('msg', (view: MsgView) => {
+      record.obj = view.toObject()
+    })
+    // inline parse
+    parser.parseText(record.encoded)
+  }
+
+  public 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.PossDupFlag = true
+    gapFill.NewSeqNo = newSeq
+    return new FixMsgStoreRecord(
+      MsgType.SequenceReset,
+      new Date(),
+      newSeq,
+      gapFill,
+      null)
+  }
+}

package/src/store/fix-msg-memory-store.ts

@@ -0,0 +1,171 @@
+import { IFixMsgStore } from './fix-msg-store'
+import { IJsFixConfig, IJsFixLogger } from '../config'
+import { IFixMsgStoreRecord } from './fix-msg-store-record'
+import { Dictionary } from '../collections'
+import { MsgType } from '../types'
+import { IFixMsgStoreState } from '.'
+
+export class FixMsgMemoryStore implements IFixMsgStore {
+  protected readonly logger: IJsFixLogger
+  public heartbeat: boolean = true
+  private sortedBySeqNum: IFixMsgStoreRecord[] = []
+  private excluded: Dictionary<boolean> = new Dictionary<boolean>()
+  public length: number = 0
+  private sessionMessages: string[] = [
+    MsgType.Logon,
+    MsgType.Logout,
+    MsgType.ResendRequest,
+    MsgType.Heartbeat,
+    MsgType.TestRequest,
+    MsgType.SequenceReset
+  ]
+
+  public constructor (public readonly id: string, public readonly config: IJsFixConfig) {
+    this.logger = config.logFactory.logger(`${this.id}:FixMsgMemoryStore`)
+    this.setExcMsgType([])
+  }
+
+  public static search (ar: IFixMsgStoreRecord[], target?: number, isDate?: boolean): number {
+    let m: number = 0
+    let n: number = ar.length - 1
+    while (m <= n) {
+      const k: number = (n + m) >> 1
+      const check: number = isDate ? ar[k].timestamp.getDate() : ar[k].seqNum
+      const cmp: number = target - check
+      if (cmp > 0) {
+        m = k + 1
+      } else if (cmp < 0) {
+        n = k - 1
+      } else {
+        return k
+      }
+    }
+    return -m - 1
+  }
+
+  public getMsgType (msgType: string): Promise<IFixMsgStoreRecord[]> {
+    return new Promise((resolve, reject: any) => {
+      const data = this.sortedBySeqNum
+      if (data === null) reject(new Error('no store'))
+      const required = data.filter(x => x.msgType === msgType)
+      resolve(required)
+    })
+  }
+
+  private getIndex (seq: number): number {
+    const arr = this.sortedBySeqNum
+    let index = FixMsgMemoryStore.search(arr, seq)
+    if (index < 0) {
+      index = -(index + 1)
+    }
+    return index
+  }
+
+  private bounded (fromIdx: number, toIdx: number) {
+    const arr = this.sortedBySeqNum
+    return fromIdx >= 0 && fromIdx <= arr.length && toIdx >= fromIdx && toIdx <= arr.length
+  }
+
+  public get (from: number): Promise<IFixMsgStoreRecord> {
+    return new Promise((resolve, reject) => {
+      this.getSeqNumRange(from, from).then(res => {
+        if (res.length > 0) {
+          const record = res[0].clone()
+          resolve(record)
+        } else {
+          reject(new Error(`${from} not in store`))
+        }
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  public getSeqNumRange (from: number, to?: number): Promise<IFixMsgStoreRecord[]> {
+    return new Promise((resolve, reject) => {
+      const arr = this.sortedBySeqNum
+      if (from < 0) reject(new Error(`illegal from ${from}`))
+      if (to < 0) reject(new Error(`illegal to ${to}`))
+      let fromIdx = this.getIndex(from)
+      const toEnd = to === 0 || isNaN(to)
+      let toIdx = toEnd ? arr.length - 1 : this.getIndex(to)
+      if (this.bounded(fromIdx, toIdx)) {
+        resolve(arr.slice(fromIdx, toIdx + 1))
+      } else {
+        reject(new Error(`incorrect bounds from=${from}, fromIdx=${fromIdx}, to=${to}, toIdx=${toIdx}, length=${arr.length}`))
+      }
+    })
+  }
+
+  private buildState (): IFixMsgStoreState {
+    const arr = this.sortedBySeqNum
+    return {
+      firstSeq: arr.length > 0 ? arr[0].seqNum : 0,
+      lastSeq: arr.length > 0 ? arr[arr.length - 1].seqNum : 0,
+      id: this.id,
+      length: arr.length
+    } as IFixMsgStoreState
+  }
+
+  public getState (): Promise<IFixMsgStoreState> {
+    return new Promise((resolve, reject) => {
+      try {
+        resolve(this.buildState())
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+
+  public clear (): Promise<IFixMsgStoreState> {
+    this.sortedBySeqNum = []
+    return new Promise((resolve, reject) => {
+      try {
+        resolve(this.buildState())
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+
+  public put (record: IFixMsgStoreRecord): Promise<IFixMsgStoreState> {
+    return new Promise((resolve, reject) => {
+      if (this.excluded.containsKey(record.msgType)) {
+        resolve(this.buildState())
+      } else {
+        const arr = this.sortedBySeqNum
+        const idx = FixMsgMemoryStore.search(arr, record.seqNum)
+        if (idx >= 0) { // seen this before
+          reject(new Error(`this seqNum ${record.seqNum} already in store`))
+        }
+        arr.splice(-idx, 0, record)
+        this.length = arr.length
+        resolve(this.buildState())
+      }
+    })
+  }
+
+  public setExcMsgType (exclude: string[]): void {
+    this.excluded.clear()
+    this.excludeRange(this.sessionMessages)
+    this.excludeRange(exclude)
+  }
+
+  private excludeRange (exclude: string[]): void {
+    exclude.forEach(s => {
+      this.excluded.add(s, true)
+    })
+  }
+
+  exists (seqNum: number): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      try {
+        const arr = this.sortedBySeqNum
+        let index = FixMsgMemoryStore.search(arr, seqNum)
+        resolve(index >= 0)
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+}

package/src/store/fix-msg-store-record.ts

@@ -0,0 +1,23 @@
+import { ILooseObject } from '../collections/collection'
+
+export interface IFixMsgStoreRecord {
+  readonly msgType: string
+  readonly timestamp: Date
+  readonly seqNum: number
+  obj?: ILooseObject
+  readonly encoded?: string
+  clone (): IFixMsgStoreRecord
+}
+
+export class FixMsgStoreRecord implements IFixMsgStoreRecord {
+  constructor (public readonly msgType: string,
+               public readonly timestamp: Date,
+               public readonly seqNum: number,
+               public obj?: ILooseObject,
+               public readonly encoded?: string) {
+  }
+
+  clone (): IFixMsgStoreRecord {
+    return new FixMsgStoreRecord(this.msgType, this.timestamp, this.seqNum, this.obj, this.encoded)
+  }
+}

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

@@ -0,0 +1,23 @@
+/*
+ a message store that represents a single entity which can be queried for recovery
+ */
+
+import { IFixMsgStoreRecord } from './fix-msg-store-record'
+
+export interface IFixMsgStoreState {
+  readonly length: number,
+  readonly firstSeq: number,
+  readonly lastSeq: number
+  readonly id: string
+}
+
+export interface IFixMsgStore {
+  clear (): Promise<IFixMsgStoreState>
+  getState (): Promise<IFixMsgStoreState>
+  put (record: IFixMsgStoreRecord): Promise<IFixMsgStoreState>
+  get (seq: number): Promise<IFixMsgStoreRecord>
+  exists (seq: number): Promise<boolean>
+  // if to = 0, then to the end of sequence
+  getSeqNumRange (from: number, to?: number): Promise<IFixMsgStoreRecord[]>
+  getMsgType (msgType: string): Promise<IFixMsgStoreRecord[]>
+}

package/src/store/index.ts

@@ -0,0 +1,4 @@
+export * from './fix-msg-memory-store'
+export * from './fix-msg-store'
+export * from './fix-msg-store-record'
+export * from './fix-msg-ascii-store-resend'

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

@@ -0,0 +1,81 @@
+import { ISessionMsgFactory } from './fix-msg-factory'
+import { ISessionDescription } from './session-description'
+import { ILooseObject } from '../collections/collection'
+import { MsgType } from '../types'
+
+import {
+  IHeartbeat,
+  IReject,
+  IResendRequest,
+  ISequenceReset,
+  IStandardHeader,
+  IStandardTrailer,
+  ITestRequest
+} from '../types/FIX4.4/repo'
+
+export interface ObjectMutator { (description: ISessionDescription, type: string, o: ILooseObject): ILooseObject
+}
+
+export abstract class ASessionMsgFactory implements ISessionMsgFactory {
+  public isAscii: boolean
+  constructor (public readonly description: ISessionDescription, public mutator: ObjectMutator = null) {
+  }
+
+  public reject (msgType: string, seqNo: number, msg: string, reason: number): ILooseObject {
+    const o: IReject = {
+      RefMsgType: msgType,
+      SessionRejectReason: reason,
+      RefSeqNum: seqNo,
+      Text: msg
+    } as IReject
+    return this.mutator ? this.mutator(this.description, MsgType.Reject, o) : o
+  }
+
+  // see implementations Ascii and Fixml
+  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
+
+  protected mutate (o: ILooseObject, type: string): ILooseObject {
+    return this.mutator ? this.mutator(this.description, type, o) : o
+  }
+
+  public testRequest (reqId: string = `ping-${new Date().toUTCString()}`): ILooseObject {
+    const o: ITestRequest = {
+      TestReqID: reqId
+    } as ITestRequest
+    return this.mutate(o, MsgType.TestRequest)
+  }
+
+  public heartbeat (testReqId: string): ILooseObject {
+    const o: IHeartbeat = {
+      TestReqID: testReqId
+    } as IHeartbeat
+    return this.mutate(o, MsgType.Heartbeat)
+  }
+
+  public resendRequest (from: number, to: number): ILooseObject {
+    const o: IResendRequest = {
+      BeginSeqNo: from,
+      EndSeqNo: to
+    } as IResendRequest
+    return this.mutate(o, MsgType.ResendRequest)
+  }
+
+  public sequenceReset (newSeqNo: number, gapFill?: boolean): ILooseObject {
+    const o: ISequenceReset = {
+      GapFillFlag: gapFill === true,
+      NewSeqNo: newSeqNo
+    } as ISequenceReset
+    return this.mutate(o, MsgType.SequenceReset)
+  }
+
+  public trailer (checksum: number): ILooseObject {
+    const s = checksum.toString()
+    const padded = s.padStart(3, '0')
+    const o = {
+      CheckSum: padded
+    } as IStandardTrailer
+    return this.mutate(o, 'StandardTrailer')
+  }
+}

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

@@ -1,4 +1,4 @@
-import { AsciiEncoder, TimeFormatter } from '../../buffer'
+import { AsciiChars, AsciiEncoder, TimeFormatter } from '../../buffer'
 import { MsgTransmitter } from '../msg-transmitter'
 import { ILooseObject } from '../../collections/collection'
 import { ContainedFieldSet, MessageDefinition } from '../../dictionary'
@@ -18,20 +18,40 @@ export class AsciiMsgTransmitter extends MsgTransmitter {
     this.msgSeqNum = (config.description.LastSentSeqNum || 0) + 1 // adding 1 as this the next sequence # to use.
     const buffer = this.buffer
     const tf: TimeFormatter = new TimeFormatter(buffer)
-    this.encoder = new AsciiEncoder(buffer, config.definitions, tf, config.delimiter)
-    this.header = config.definitions.component.get('header')
-    this.trailer = config.definitions.component.get('trailer')
+    this.encoder = new AsciiEncoder(buffer, config.definitions, tf,
+      config.delimiter || AsciiChars.Soh,
+      config.logDelimiter || AsciiChars.Pipe)
+    const components = config.definitions.component
+    this.header = components.get('StandardHeader')
+    this.trailer = components.get('StandardTrailer')
+  }
+
+  private checksum (): number {
+    const buffer = this.buffer
+    const encoder: AsciiEncoder = this.encoder as AsciiEncoder
+    let checksum: number = buffer.sum()
+    if (encoder.delimiter !== encoder.logDelimiter) {
+      const changes = encoder.tags.nextTagPos
+      checksum -= changes * encoder.logDelimiter
+      checksum += changes * encoder.delimiter
+    }
+    checksum = checksum % 256
+    return checksum
   }
 
   public encodeMessage (msgType: string, obj: ILooseObject): void {
     const encoder: AsciiEncoder = this.encoder as AsciiEncoder
     const factory = this.config.factory
-
-    const headerProps: Partial<IStandardHeader> = {
-      ...(obj.StandardHeader?.PossDupFlag ? { PossDupFlag: obj.StandardHeader?.PossDupFlag } : {}),
-      ...(obj.StandardHeader?.MsgSeqNum ? { MsgSeqNum: obj.StandardHeader?.MsgSeqNum } : {})
+    let headerProps: Partial<IStandardHeader> = {}
+    const { StandardHeader, ...bodyProps } = obj
+    if (StandardHeader) {
+      const { BeginString, BodyLength, MsgType, SenderCompID, SendingTime, TargetCompID, TargetSubID, ...hp } = StandardHeader
+      headerProps = hp // pick up any optional applied by application
+      headerProps.OrigSendingTime = SendingTime // when first sent
     }
-    const hdr: ILooseObject = factory.header(msgType, this.msgSeqNum,this.time || new Date(), headerProps)
+
+    const sendingTime = this.time || new Date()
+    const hdr: ILooseObject = factory.header(msgType, this.msgSeqNum, sendingTime, headerProps)
 
     // Only increment sequence number if this is not a duplicate message.
     if (!headerProps.PossDupFlag) {
@@ -42,15 +62,16 @@ export class AsciiMsgTransmitter extends MsgTransmitter {
     buffer.reset()
     const msgDef: MessageDefinition = this.definitions.message.get(msgType)
     if (!msgDef) {
+      this.emit('error', new Error(`ascii transmitter cannot find definition for ${msgType}`))
       return
     }
     encoder.encode(hdr, this.header.name)
-    encoder.encode(obj, msgDef.name)
+    encoder.encode(bodyProps, msgDef.name)
     const lenPos = encoder.bodyLengthPos
     const bodyLength: number = Math.max(4, this.config.description.BodyLengthChars || 7)
     const len = buffer.getPos() - encoder.msgTypePos
     buffer.patchPaddedNumberAtPos(lenPos, len, bodyLength)
-    const checksum: number = buffer.checksum()
+    let checksum: number = this.checksum()
     const trl: ILooseObject = factory.trailer(checksum)
     encoder.encode(trl, this.trailer.name)
   }

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

@@ -0,0 +1,62 @@
+import { ISessionDescription } from '../session-description'
+import { ILooseObject } from '../../collections/collection'
+import { MsgType } from '../../types'
+import { ASessionMsgFactory, ObjectMutator } from '../a-session-msg-factory'
+
+import {
+  EncryptMethod,
+  ILogon,
+  ILogout,
+  IStandardHeader
+} from '../../types/FIX4.4/repo'
+
+export class AsciiSessionMsgFactory extends ASessionMsgFactory {
+
+  constructor (readonly description: ISessionDescription, mutator: ObjectMutator = null) {
+    super(description, mutator)
+    this.isAscii = description.application.protocol === 'ascii'
+  }
+
+  public logon (): ILooseObject {
+    const description = this.description
+    const o: ILogon = {
+      Username: description.Username,
+      Password: description.Password,
+      HeartBtInt: description.HeartBtInt,
+      ResetSeqNumFlag: description.ResetSeqNumFlag,
+      EncryptMethod: EncryptMethod.None
+    } as ILogon
+    return this.mutate(o, MsgType.Logon)
+  }
+
+  public logout (text: string): ILooseObject {
+    const o: ILogout = {
+      Text:  text
+    } as ILogout
+    return this.mutate(o, MsgType.Logout)
+  }
+
+  public header (msgType: string, seqNum: number, time: Date, overrideData?: Partial<IStandardHeader>): ILooseObject {
+    const description = this.description
+    const bodyLength: number = Math.max(4, description.BodyLengthChars || 7)
+    const placeHolder = Math.pow(10, bodyLength - 1) + 1
+    const o: IStandardHeader = {
+      BeginString: description.BeginString,
+      BodyLength: placeHolder,
+      MsgType: msgType,
+      SenderCompID: description.SenderCompId,
+      MsgSeqNum: seqNum,
+      SendingTime: time,
+      TargetCompID: description.TargetCompID,
+      TargetSubID: description.TargetSubID,
+      ...overrideData
+    }
+    return this.mutate(o, 'StandardHeader')
+  }
+}
+
+export class SessionMsgFactory extends AsciiSessionMsgFactory {
+  constructor (public readonly description: ISessionDescription, public mutator: ObjectMutator = null) {
+    super(description, mutator)
+  }
+}