jspurefix 1.2.0 → 2.0.0

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

@@ -3,20 +3,15 @@
  */
 
 import { IFixMsgStoreRecord } from './fix-msg-store-record'
+import { IFixMsgStoreState } from './fix-msg-store-state'
 
 export interface IFixMsgStore {
-  readonly id: string
-  readonly length: number
-  /*
-  default to Logon , Logout , ResendRequest, HeartbeatInt, TestRequest, SequenceReset
-  = ["A", "5", "2", "0", "1", "4"]
-   */
-  setExcMsgType (exclude: string[]): void
-  put (record: IFixMsgStoreRecord): boolean
-  exits (seqNum: number): boolean
-  getSeqNum (seqNum: number): IFixMsgStoreRecord
+  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): IFixMsgStoreRecord[]
-  getDateRange (from: Date, to: Date): IFixMsgStoreRecord[]
-  getMsgType (msgType: string): IFixMsgStoreRecord[]
+  getSeqNumRange (from: number, to?: number): Promise<IFixMsgStoreRecord[]>
+  getMsgType (msgType: string): Promise<IFixMsgStoreRecord[]>
 }

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

@@ -1,10 +1,15 @@
-import { AsciiChars, AsciiEncoder, TimeFormatter } from '../../buffer'
+import { AsciiChars, AsciiEncoder, TimeFormatter } from '../../buffer/ascii'
 import { MsgTransmitter } from '../msg-transmitter'
 import { ILooseObject } from '../../collections/collection'
-import { ContainedFieldSet, MessageDefinition } from '../../dictionary'
+import { ContainedFieldSet } from '../../dictionary/contained'
+import { MessageDefinition } from '../../dictionary/definition'
 import { IJsFixConfig } from '../../config'
 import { IStandardHeader } from '../../types/FIX4.4/repo'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../runtime/di-tokens'
+import { ElasticBuffer } from '../../buffer'
 
+@injectable()
 export class AsciiMsgTransmitter extends MsgTransmitter {
   public msgSeqNum: number
   public time: Date
@@ -12,17 +17,17 @@ export class AsciiMsgTransmitter extends MsgTransmitter {
   private readonly header: ContainedFieldSet
   private readonly trailer: ContainedFieldSet
 
-  constructor (public readonly config: IJsFixConfig) {
-
-    super(config.definitions, config.description)
+  constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
+    super(config.sessionContainer.resolve<ElasticBuffer>(DITokens.TransmitBuffer), config.definitions, config.description)
     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 || AsciiChars.Soh,
       config.logDelimiter || AsciiChars.Pipe)
-    this.header = config.definitions.component.get('StandardHeader')
-    this.trailer = config.definitions.component.get('StandardTrailer')
+    const components = config.definitions.component
+    this.header = components.get('StandardHeader')
+    this.trailer = components.get('StandardTrailer')
   }
 
   private checksum (): number {
@@ -41,12 +46,16 @@ export class AsciiMsgTransmitter extends MsgTransmitter {
   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) {
@@ -57,10 +66,11 @@ 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

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

@@ -0,0 +1,62 @@
+import { ISessionDescription } from '../session/session-description'
+import { ILooseObject } from '../../collections/collection'
+import { MsgType } from '../../types'
+import { ASessionMsgFactory, ObjectMutator } from '../session/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)
+  }
+}

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

@@ -1,18 +1,25 @@
-import { MsgView, SegmentType } from '../../buffer'
+import { MsgView } from '../../buffer'
 import { MsgTag, MsgType, SessionRejectReason } from '../../types'
 import { IJsFixConfig } from '../../config'
-import { IMsgApplication } from '../session-description'
-import { SessionState, TickAction } from '../fix-session-state'
-import { FixSession } from '../fix-session'
+import { FixSession } from '../session/fix-session'
+import { FixMsgAsciiStoreResend, FixMsgMemoryStore, IFixMsgStore, IFixMsgStoreRecord } from '../../store'
+import { SessionState } from '../tcp'
+import { TickAction } from '../tick-action'
+import { IMsgApplication } from '../msg-application'
+import { SegmentType } from '../../buffer/segment/segment-type'
 
 export abstract class AsciiSession extends FixSession {
 
   public heartbeat: boolean = true
+  protected store: IFixMsgStore = null
+  protected resender: FixMsgAsciiStoreResend
 
   protected constructor (public readonly config: IJsFixConfig) {
     super(config)
     this.requestLogoutType = this.respondLogoutType = MsgType.Logout
     this.requestLogonType = MsgType.Logon
+    this.store = new FixMsgMemoryStore(this.config.description.SenderCompId, this.config)
+    this.resender = new FixMsgAsciiStoreResend(this.store, this.config)
   }
 
   private checkSeqNo (msgType: string, view: MsgView): boolean {
@@ -33,14 +40,18 @@ export abstract class AsciiSession extends FixSession {
           this.sessionLogger.warning(`terminate as seqDelta (${seqDelta}) < 0 lastSeq = ${lastSeq} seqNo = ${seqNo}`)
           this.stop()
         } else if (seqDelta > 1) {
-          // reset required as have missed messages.
-          const resend = this.config.factory.resendRequest(lastSeq + 1, seqNo)
-          this.sessionLogger.warning(`sending resend last received ${lastSeq} seqNo ${seqNo}`)
-          this.send(MsgType.ResendRequest, resend)
-          // Sequence discrepancies should be resolved after logon. However, this does not make the Logon invalid.
-          if (MsgType.Logon) {
-            return true
+          // resend request required as have missed messages.
+
+          // We process a Logon beforehand to confirm the connection even we out of sync
+          if (msgType === MsgType.Logon) {
+            this.peerLogon(view)
+          }
+          // If the out of sync message is a resend request itself, then we handle it first in order
+          // to avoid triggering an endless loop of both sides sending resend requests in response to resend requests.
+          if (msgType === MsgType.ResendRequest) {
+            this.onResendRequest(view)
           }
+          this.sendResendRequest(lastSeq, seqNo)
         } else {
           ret = true
           state.lastPeerMsgSeqNum = seqNo
@@ -50,6 +61,17 @@ export abstract class AsciiSession extends FixSession {
     }
   }
 
+  protected checkForwardMsg (msgType: string, view: MsgView): void {
+    const okToForward = this.validStateApplicationMsg()
+    if (okToForward) {
+      this.sessionLogger.info(`ascii forwarding msgType = '${msgType}' to application`)
+      this.setState(SessionState.ActiveNormalSession)
+      this.onApplicationMsg(msgType, view)
+    } else {
+      this.terminate(new Error(`msgType ${msgType} received in state ${this.stateString()}`))
+    }
+  }
+
   private sendReject (msgType: string, seqNo: number, msg: string, reason: number): void {
     const factory = this.config.factory
     const reject = factory.reject(msgType, seqNo, msg, reason)
@@ -57,6 +79,12 @@ export abstract class AsciiSession extends FixSession {
     this.send(MsgType.Reject, reject)
   }
 
+  protected sendResendRequest (lastSeq: number, receivedSeq: number) {
+    const resend = this.config.factory.resendRequest(lastSeq + 1, 0)
+    this.sessionLogger.warning(`received seq ${receivedSeq}, but last known seq is ${lastSeq}. Sending resend request for all messages > ${lastSeq}`)
+    this.send(MsgType.ResendRequest, resend)
+  }
+
   private checkIntegrity (msgType: string, view: MsgView): boolean {
     const state = this.sessionState
     const seqNum = view.getTyped(MsgTag.MsgSeqNum)
@@ -101,14 +129,14 @@ export abstract class AsciiSession extends FixSession {
       case SessionState.InitiationLogonResponse: {
         const targetCompId = view.getString(MsgTag.TargetCompID)
         if (targetCompId !== state.compId) {
-          const msg: string = `msgType ${msgType} unexpected TargetCompID ${targetCompId}`
+          const msg: string = `msgType ${msgType} unexpected TargetCompID ${targetCompId} expecting ${state.compId})`
           this.sendReject(msgType, seqNum, msg, SessionRejectReason.CompIDProblem)
           return false
         }
 
         const peerCompId = view.getString(MsgTag.SenderCompID)
         if (peerCompId !== state.peerCompId) {
-          const msg: string = `msgType ${msgType} unexpected SenderCompID ${peerCompId}`
+          const msg: string = `msgType ${msgType} unexpected SenderCompID ${peerCompId}  expecting ${state.compId}`
           this.sendReject(msgType, seqNum, msg, SessionRejectReason.CompIDProblem)
           return false
         }
@@ -127,21 +155,44 @@ export abstract class AsciiSession extends FixSession {
    * Override to resend stored messages following a sequence reset.
    * @protected
    */
-  // tslint:disable-next-line:no-empty
   protected onResendRequest (view: MsgView) {
-    const endSeqNo: number = view.getTyped(MsgTag.EndSeqNo)
-    const resend = this.config.factory.sequenceReset(endSeqNo, true)
-    this.send(MsgType.SequenceReset, resend)
+    // if no records are in store then send a gap fill for entire sequence
+    this.setState(SessionState.HandleResendRequest)
+    const [beginSeqNo, endSeqNo] = view.getTypedTags([MsgTag.BeginSeqNo, MsgTag.EndSeqNo])
+    this.sessionLogger.info(`onResendRequest getResendRequest beginSeqNo = ${beginSeqNo}, endSeqNo = ${endSeqNo}`)
+    this.resender.getResendRequest(beginSeqNo, endSeqNo).then((records: IFixMsgStoreRecord[]) => {
+      const validRecords = records.filter(rec => rec.obj !== null)
+      this.sessionLogger.info(`sending ${validRecords.length}`)
+      validRecords.forEach(rec => {
+        this.send(rec.msgType, rec.obj)
+      })
+      this.setState(SessionState.ActiveNormalSession)
+    }).catch(e => {
+      this.sessionLogger.error(e)
+    })
+  }
+
+  okForLogon (): boolean {
+    const state = this.sessionState.state
+    if (this.acceptor) {
+      return state === SessionState.WaitingForALogon
+    }
+    return state === SessionState.InitiationLogonSent
   }
 
   protected onSessionMsg (msgType: string, view: MsgView): void {
 
-    const factory = this.config.factory
     const logger = this.sessionLogger
 
     switch (msgType) {
       case MsgType.Logon: {
-        this.peerLogon(view)
+        // only valid to receive a logon when in LogonSent or WaitingALogon
+        // else will drop connection immediately.
+        if (this.okForLogon()) {
+          this.peerLogon(view)
+        } else {
+          this.terminate(new Error(`state ${this.stateString()} is illegal for Logon`))
+        }
         break
       }
 
@@ -152,17 +203,18 @@ export abstract class AsciiSession extends FixSession {
 
       case MsgType.TestRequest: {
         const req: string = view.getString(MsgTag.TestReqID)
-        this.send(MsgType.Heartbeat, factory.heartbeat(req))
+        this.sendHeartbeat(req)
         break
       }
 
       case MsgType.Heartbeat: {
         this.sessionState.lastTestRequestAt = null
+        this.setState(SessionState.ActiveNormalSession)
         break
       }
 
       case MsgType.ResendRequest: {
-        logger.info(`peer sends '${msgType}' resend reset.`)
+        logger.info(`peer sends '${msgType}' resend request.`)
         this.onResendRequest(view)
         break
       }
@@ -194,9 +246,7 @@ export abstract class AsciiSession extends FixSession {
       switch (msgType) {
         case MsgType.Logon: {
           this.setState(SessionState.PeerLogonRejected)
-          this.timer = setInterval(() => {
-            this.tick()
-          }, 200)
+          this.startTimer()
           break
         }
       }
@@ -222,36 +272,54 @@ export abstract class AsciiSession extends FixSession {
     }
   }
 
+  private startTimer (interval: number = 200) {
+    this.timer = setInterval(() => {
+      this.tick()
+    }, interval)
+  }
+
   private peerLogon (view: MsgView) {
     const logger = this.sessionLogger
-    const heartBtInt = view.getTyped(MsgTag.HeartBtInt)
-    const peerCompId = view.getTyped(MsgTag.SenderCompID)
-    const userName = view.getString(MsgTag.Username)
+    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 state = this.sessionState
     state.peerHeartBeatSecs = view.getTyped(MsgTag.HeartBtInt)
     state.peerCompId = view.getTyped(MsgTag.SenderCompID)
+    const res = this.onLogon(view, userName, password)
+    // currently not using this.
+    logger.info(`peerLogon onLogon returns ${res}`)
     if (this.acceptor) {
       this.setState(SessionState.InitiationLogonResponse)
-      this.send(MsgType.Logon, this.config.factory.logon())
+      logger.info('acceptor responds to logon request')
+      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)
     }
     if (this.heartbeat) {
       logger.debug(`start heartbeat timer.`)
-      this.timer = setInterval(() => {
-        this.tick()
-      }, 200)
+      this.startTimer()
     }
     logger.info(`system ready, inform app`)
     this.onReady(view)
   }
 
+  private sendTestRequest () {
+    const factory = this.config.factory
+    this.setState(SessionState.AwaitingProcessingResponseToTestRequest)
+    this.send(MsgType.TestRequest, factory.testRequest())
+  }
+
+  private sendHeartbeat (testReqId: string) {
+    const factory = this.config.factory
+    this.send(MsgType.Heartbeat, factory.heartbeat(testReqId))
+  }
+
   private tick (): void {
+    if (!this.transport) return
     const sessionState = this.sessionState
     const action: TickAction = sessionState.calcAction(new Date())
     const application: IMsgApplication = this.transport.config.description.application
-    const factory = this.config.factory
     const logger = this.sessionLogger
 
     switch (action) {
@@ -262,13 +330,13 @@ export abstract class AsciiSession extends FixSession {
 
       case TickAction.TestRequest: {
         logger.debug(`send test req. state = ${sessionState.toString()}`)
-        this.send(MsgType.TestRequest, factory.testRequest())
+        this.sendTestRequest()
         break
       }
 
       case TickAction.Heartbeat: {
         logger.debug(`send heartbeat. state = ${sessionState.toString()}`)
-        this.send(MsgType.Heartbeat, factory.heartbeat(sessionState.now.toUTCString()))
+        this.sendHeartbeat(sessionState.now.toUTCString())
         break
       }
 

package/src/transport/ascii/index.ts

@@ -1,2 +1,2 @@
 export * from './ascii-session'
-export * from './ascii-msg-transmitter'
+export * from './ascii-session-msg-factory'

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

@@ -1,7 +1,7 @@
 import { FixDuplex } from './fix-duplex'
 import { Readable, Writable } from 'stream'
-import { IHttpAdapter } from '../session-description'
-import * as requestPromise from 'request-promise'
+import * as rp from 'request-promise-native'
+import { IHttpAdapter } from '../http/http-adapter'
 
 export class HttpDuplex extends FixDuplex {
   public constructor (public readonly adapter: IHttpAdapter) {
@@ -28,7 +28,7 @@ export class HttpDuplex extends FixDuplex {
         try {
           const adapter = this.adapter
           const options = adapter.getOptions(data)
-          requestPromise(options).then((message: any) => {
+          rp(options).then((message: any) => {
             const body = adapter.endMessage(message)
             forward.push(body)
             done()

package/src/transport/duplex/tcp-duplex.ts

@@ -1,8 +1,11 @@
 import { FixDuplex } from './fix-duplex'
 import * as net from 'net'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../runtime/di-tokens'
 
+@injectable()
 export class TcpDuplex extends FixDuplex {
-  constructor (public readonly socket: net.Socket) {
+  constructor (@inject(DITokens.duplexParam) public readonly socket: net.Socket) {
     super()
     this.readable = socket
     this.writable = socket

package/src/transport/factory/index.ts

@@ -0,0 +1 @@
+export * from './msg-transport'

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

@@ -0,0 +1,55 @@
+import { MsgParser } from '../../buffer'
+import { MsgTransmitter } from '../msg-transmitter'
+import { FixDuplex } from '../duplex'
+import { IJsFixConfig } from '../../config'
+import { DITokens } from '../../runtime/di-tokens'
+import { Readable } from 'stream'
+import { inject, injectable } from 'tsyringe'
+
+@injectable()
+export class MsgTransport {
+  public readonly transmitter: MsgTransmitter
+  public readonly receiver: MsgParser
+
+  constructor (@inject(DITokens.sessionId) public readonly id: number,
+               @inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig,
+               @inject(DITokens.FixDuplex) public readonly duplex: FixDuplex) {
+
+    const delimiter = config.delimiter
+    if (!delimiter) {
+      throw new Error(`no delimiter char given.`)
+    }
+
+    const sessionContainer = this.config.sessionContainer
+    sessionContainer.registerInstance<Readable>(DITokens.readStream, this.duplex.readable)
+
+    // let parser replace delimiter with Pipe so fix log does not require
+    // expensive replace
+
+    this.transmitter = sessionContainer.resolve<MsgTransmitter>(DITokens.MsgTransmitter)
+    this.receiver = sessionContainer.resolve<MsgParser>(DITokens.MsgParser)
+
+    // pipe the encoder to say a socket.
+    if (duplex.writable) {
+      this.transmitter.encodeStream.pipe(duplex.writable)
+    }
+  }
+
+  public end (): void {
+    this.duplex.end()
+  }
+
+  public wait (): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+      this.receiver.on('end', () => {
+        resolve(this.id)
+      })
+      this.receiver.on('error', (e) => {
+        reject(e)
+      })
+      this.transmitter.on('error', (e) => {
+        reject(e)
+      })
+    })
+  }
+}

package/src/transport/fix-acceptor.ts

@@ -1,7 +1,7 @@
 import * as events from 'events'
-import { MsgTransport } from './msg-transport'
-import { IMsgApplication } from './session-description'
+import { MsgTransport } from './factory'
 import { INumericKeyed } from '../collections/collection'
+import { IMsgApplication } from './msg-application'
 
 export abstract class FixAcceptor extends events.EventEmitter {
   public transports: INumericKeyed<MsgTransport> = {}

package/src/transport/fix-entity.ts

@@ -0,0 +1,9 @@
+import { IJsFixConfig } from '../config'
+import * as events from 'events'
+
+export abstract class FixEntity extends events.EventEmitter {
+  abstract start (): Promise<any>
+  constructor (public readonly config: IJsFixConfig) {
+    super()
+  }
+}

package/src/transport/fix-initiator.ts

@@ -1,5 +1,5 @@
-import { IMsgApplication } from './session-description'
-import { MsgTransport } from './msg-transport'
+import { MsgTransport } from './factory'
+import { IMsgApplication } from './msg-application'
 
 export abstract class FixInitiator {
   protected constructor (public readonly application: IMsgApplication) {

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

@@ -1,14 +1,18 @@
-import { FixmlEncoder } from '../../buffer'
+import { FixmlEncoder } from '../../buffer/fixml'
 import { IJsFixConfig } from '../../config'
 import { MsgTransmitter } from '../msg-transmitter'
 import { ILooseObject } from '../../collections/collection'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../runtime/di-tokens'
+import { ElasticBuffer } from '../../buffer'
 
+@injectable()
 export class FixmlMsgTransmitter extends MsgTransmitter {
   public time: Date
 
-  constructor (public readonly config: IJsFixConfig) {
-    super(config.definitions, config.description)
-    this.encoder = new FixmlEncoder(this.buffer, config.definitions)
+  constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
+    super(config.sessionContainer.resolve<ElasticBuffer>(DITokens.TransmitBuffer), config.definitions, config.description)
+    this.encoder = config.sessionContainer.resolve<FixmlEncoder>(DITokens.MsgEncoder)
   }
 
   public encodeMessage (msgType: string, obj: ILooseObject): void {

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

@@ -0,0 +1,76 @@
+import { ISessionDescription } from '../session/session-description'
+import { ILooseObject } from '../../collections/collection'
+import { MsgType } from '../../types'
+import { ASessionMsgFactory, ObjectMutator } from '../session/a-session-msg-factory'
+
+import {
+  IStandardHeader,
+  IUserRequest,
+  IUserResponse,
+  UserRequestType,
+  UserStatus
+} from '../../types/FIXML50SP2'
+
+export class FixmlSessionMsgFactory extends ASessionMsgFactory {
+
+  constructor (readonly description: ISessionDescription, mutator: ObjectMutator = null) {
+    super(description, mutator)
+  }
+
+  public logon (userRequestId: string = '', isResponse: boolean = false): ILooseObject {
+    return this.fixmlLogon(userRequestId, isResponse)
+  }
+
+  public logout (msgType: string, text: string): ILooseObject {
+    return this.fixmlLogout(msgType, msgType !== 'UserReq')
+  }
+
+  public header (msgType: string, seqNum: number = 0, time: Date = new Date(), overrideData?: Partial<IStandardHeader>): ILooseObject {
+    const description = this.description
+    const o: IStandardHeader = {
+      SenderCompID: description.SenderCompId,
+      TargetCompID: description.TargetCompID,
+      SenderSubID: description.SenderSubID,
+      TargetSubID: description.TargetSubID
+    } as IStandardHeader
+    return this.mutate(o, 'StandardHeader')
+  }
+
+  private fixmlLogon (userRequestId: string, isResponse: boolean): ILooseObject {
+    const description = this.description
+    if (!isResponse) {
+      const o: IUserRequest = {
+        Username: description.Username,
+        Password: description.Password,
+        UserRequestID: userRequestId,
+        UserRequestType: UserRequestType.LogOnUser
+      } as IUserRequest
+      return this.mutate(o, MsgType.Logon)
+    } else {
+      const o: IUserResponse = {
+        Username: description.Username,
+        UserRequestID: userRequestId,
+        UserStatus: UserStatus.LoggedIn
+      } as IUserResponse
+      return this.mutate(o, MsgType.Logon)
+    }
+  }
+
+  private fixmlLogout (userRequestId: string, isResponse: boolean): ILooseObject {
+    if (!isResponse) {
+      const o: IUserRequest = {
+        Username: this.description.Username,
+        UserRequestID: userRequestId,
+        UserRequestType: UserRequestType.LogOffUser
+      } as IUserRequest
+      return this.mutate(o, MsgType.Logout)
+    } else {
+      const o: IUserResponse = {
+        Username: this.description.Username,
+        UserRequestID: userRequestId,
+        UserStatus: UserStatus.NotLoggedIn
+      } as IUserResponse
+      return this.mutate(o, MsgType.Logout)
+    }
+  }
+}