jspurefix 2.2.1 → 3.0.0

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

@@ -6,7 +6,6 @@ import { FixSession } from '../session/fix-session'
 import { SessionState } from '../session/session-state'
 
 export abstract class FixmlSession extends FixSession {
-
   protected constructor (public readonly config: IJsFixConfig) {
     super(config)
     this.requestLogoutType = 'UserReq'
@@ -15,7 +14,6 @@ export abstract class FixmlSession extends FixSession {
   }
 
   protected onMsg (msgType: string, view: MsgView): void {
-
     switch (msgType) {
       case 'UserReq':
       case 'UserRsp': {
@@ -66,16 +64,19 @@ export abstract class FixmlSession extends FixSession {
     }
   }
 
-  private peerLogon (view: MsgView) {
+  private peerLogon (view: MsgView): void {
     const logger = this.sessionLogger
     const state = this.sessionState
     state.state = SessionState.InitiationLogonReceived
     state.peerCompId = view.getTyped(MsgTag.SenderCompID)
     if (this.acceptor) {
-      const reqId: string = view.getString('UserReqID')
-      this.send('UserRsp', this.config.factory.logon(reqId, true))
+      const reqId: string = view.getString('UserReqID') ?? 'req'
+      const o = this?.config?.factory?.logon(reqId, true)
+      if (o) {
+        this.send('UserRsp', o)
+      }
     }
-    logger.info(`system ready, inform app`)
+    logger.info('system ready, inform app')
     this.onReady(view)
   }
 }

package/src/transport/http/html-options.ts

@@ -1,8 +1,8 @@
 export interface IHtmlOptions {
-  method: string,
-  uri: string,
-  json: boolean,
-  body: any,
-  headers: any,
+  method: string
+  url: string
+  json: boolean
+  data: any
+  headers: any
   resolveWithFullResponse: boolean
 }

package/src/transport/http/html-route.ts

@@ -1,6 +1,6 @@
 import { IHtmlOptions } from './html-options'
 
 export interface IHtmlRoute {
-  name: string,
+  name: string
   value: IHtmlOptions
 }

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

@@ -12,8 +12,9 @@ export class HttpAcceptorListener extends FixEntity {
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config)
   }
-  start (): Promise<any> {
-    return new Promise<any>(async (accept, reject) => {
+
+  async start (): Promise<any> {
+    return new Promise<any>(async (resolve, reject) => {
       const logger = this.config.logFactory.logger('acceptor')
       const sessionContainer = this.config.sessionContainer
       if (!sessionContainer.isRegistered(DITokens.FixSession)) {
@@ -24,15 +25,16 @@ export class HttpAcceptorListener extends FixEntity {
       acceptor.on('transport', (t: MsgTransport) => {
         logger.info(`creates new transport using DI token ${DITokens.FixSession}.`)
         const acceptorSession = sessionContainer.resolve<FixSession>(DITokens.FixSession)
+        this.emit('session', acceptorSession, t)
         acceptorSession.run(t).then(() => {
           logger.info('ends')
           acceptor.close(() => {
             logger.info('acceptor closed.')
-            accept(true)
+            resolve(true)
           })
         }).catch((e: Error) => {
           logger.error(e)
-          logger.info(e.stack)
+          logger.info(e?.stack ?? '')
           reject(e)
         })
       })

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

@@ -14,16 +14,16 @@ import { DITokens } from '../../runtime/di-tokens'
 
 @injectable()
 export class HttpAcceptor extends FixAcceptor {
-  private app: express.Express = express()
+  private readonly app: express.Express = express()
   private server: http.Server
   private readonly logger: IJsFixLogger
   private readonly router: express.Router
   private nextId: number = 0
-  private keys: Dictionary<MsgTransport> = new Dictionary()
+  private readonly keys: Dictionary<MsgTransport> = new Dictionary()
 
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
-    super(config.description.application)
-    this.logger = config.logFactory.logger(`${config.description.application.name}:HttpAcceptor`)
+    super(config?.description?.application ?? null)
+    this.logger = config.logFactory.logger(`${config?.description?.application?.name}:HttpAcceptor`)
     this.logger.info('creating http server')
     this.router = express.Router()
     this.router.use(bodyParser.json())
@@ -33,21 +33,21 @@ export class HttpAcceptor extends FixAcceptor {
 
   public listen (): void {
     const app = this.config.description.application
-    const port = app.http.port
+    const port = app?.http?.port ?? 0
     const logger = this.logger
     logger.info(`start to listen ${port}`)
     this.server = this.app.listen(port, () => {
-      logger.info(`app listening at http://localhost:${port}${app.http.uri}`)
+      logger.info(`app listening at http://localhost:${port}${app?.http?.uri}`)
     })
-    this.server.on('error', ((err: Error) => {
+    this.server.on('error', (err: Error) => {
       logger.error(err)
       this.emit('error', err)
-    }))
+    })
   }
 
   public close (callback?: (err?: Error) => void): void {
     const app = this.config.description.application
-    const port = app.http.port
+    const port = app?.http?.port
     this.logger.info(`close listener on port ${port}`)
     this.server.close(callback)
   }
@@ -69,36 +69,36 @@ export class HttpAcceptor extends FixAcceptor {
     this.logger.info(`transport ${tid} ends total transports = ${keys.length}`)
   }
 
-  private respond (duplex: FixDuplex, res: express.Response, token: string = null): Promise<any> {
-    return new Promise<any>((accept, reject) => {
-      res.setHeader('Content-Type', 'application/json')
+  private async respond (duplex: FixDuplex, response: express.Response, token: string | null = null): Promise<any> {
+    return new Promise<any>((resolve, reject) => {
+      response.setHeader('Content-Type', 'application/json')
       const timer = setTimeout(() => {
-        const businessReject = `<FIXML><BizMsgRej BizRejRsn="4" Txt="no response from application"/></FIXML>`
+        const businessReject = '<FIXML><BizMsgRej BizRejRsn="4" Txt="no response from application"/></FIXML>'
         const b = Buffer.from(businessReject, 'utf-8')
         duplex.writable.removeListener('data', transmit)
-        res.send(b)
+        response.send(b)
         reject(new Error('no response'))
       }, 5000)
 
-      const transmit = (d: Buffer) => {
+      const transmit = (d: Buffer): void => {
         this.logger.info('responding to request')
         clearTimeout(timer)
         if (token) {
-          res.setHeader('authorization', token)
+          response.setHeader('authorization', token)
         }
         duplex.writable.removeListener('data', transmit)
-        res.send(d)
-        accept(true)
+        response.send(d)
+        resolve(true)
       }
 
       duplex.writable.on('data', transmit)
     })
   }
 
-  private async logon (req: express.Request, res: express.Response) {
+  private async logon (req: express.Request, res: express.Response): Promise<void> {
     const body: IFixmlRequest = req.body
     const id = this.nextId++
-    this.logger.info(JSON.stringify(body, null,4))
+    this.logger.info(JSON.stringify(body, null, 4))
     // check hand back session key
     const d = new StringDuplex()
     const transport = new MsgTransport(id, this.config, d)
@@ -111,28 +111,30 @@ export class HttpAcceptor extends FixAcceptor {
     d.readable.push(body.fixml)
   }
 
-  private async logout (req: express.Request, res: express.Response) {
+  private async logout (req: express.Request, res: express.Response): Promise<void> {
     const headers = req.headers
     const body: IFixmlRequest = req.body
-    const t: MsgTransport = this.keys.get(headers.authorization)
+    const t: MsgTransport | null = this.keys.get(headers?.authorization ?? '')
     if (t) {
       const token = req.headers.authorization
-      this.harvestTransport(token, t.id)
-      const d = t.duplex
-      this.respond(d, res, token).then(() => {
-        this.logger.info('responded to logout')
-        t.end()
-      }).catch((e: Error) => {
-        this.logger.error(e)
-      })
-      d.readable.push(body.fixml)
+      if (token) {
+        this.harvestTransport(token, t.id)
+        const d = t.duplex
+        this.respond(d, res, token).then(() => {
+          this.logger.info('responded to logout')
+          t.end()
+        }).catch((e: Error) => {
+          this.logger.error(e)
+        })
+        d.readable.push(body.fixml)
+      }
     }
   }
 
   private subscribe (): void {
     const router = this.router
     const app = this.config.description.application
-    const root = app.http.uri
+    const root = app?.http?.uri
     const authorise = `${root}authorise`
     const query = `${root}query`
     this.logger.info(`uri: authorise ${authorise}, query ${query}`)
@@ -149,9 +151,9 @@ export class HttpAcceptor extends FixAcceptor {
     router.get(query, async (req: express.Request, res: express.Response) => {
       const headers = req.headers
       const body: IFixmlRequest = req.body
-      const t: MsgTransport = this.keys.get(headers.authorization)
+      const t: MsgTransport | null = this.keys.get(headers.authorization ?? '') ?? null
       if (!t) {
-        this.logger.info(`received request with no token`)
+        this.logger.info('received request with no token')
         res.send({
           error: 'no key with query'
         })

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

@@ -1,7 +1,7 @@
 import { IHtmlOptions } from './html-options'
 
 export interface IHttpAdapter {
-  getOptions (data: Buffer): IHtmlOptions
-  beginMessage (msgType: string): void
-  endMessage (m: any): Buffer
+  getOptions: (data: Buffer) => IHtmlOptions | null
+  beginMessage: (msgType: string) => void
+  endMessage: (m: any) => Buffer
 }

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

@@ -14,16 +14,16 @@ export class HttpInitiator extends FixEntity {
     this.logger = config.logFactory.logger('initiator')
   }
 
-  start (): Promise<any> {
-    return this.connect(this.config)
+  async start (): Promise<any> {
+    return await this.connect(this.config)
   }
 
-// the adapter will be provided on config
-  connect (config: IJsFixConfig): Promise<any> {
-    return new Promise<any>(async (accept, reject) => {
-      const adapter = config.description.application.http.adapter
+  // the adapter will be provided on config
+  async connect (config: IJsFixConfig): Promise<any> {
+    return await new Promise<any>(async (resolve, reject) => {
+      const adapter = config?.description?.application?.http?.adapter
       if (!adapter) {
-        reject('http initiator needs config.description.application.http.adapter')
+        reject(new Error('http initiator needs config.description.application.http.adapter'))
       }
       const sessionContainer = this.config.sessionContainer
       if (!sessionContainer.isRegistered(DITokens.FixSession)) {
@@ -32,15 +32,21 @@ export class HttpInitiator extends FixEntity {
       this.logger.info(`create session with DI Token ${DITokens.FixSession}`)
       const initiatorSession = sessionContainer.resolve<FixSession>(DITokens.FixSession)
       this.logger.info('connecting ...')
-      const initiatorTransport: MsgTransport = new MsgTransport(0, config, new HttpDuplex(adapter))
-      this.logger.info('... connected, run session')
-      initiatorSession.run(initiatorTransport).then(() => {
-        this.logger.info('ends')
-        accept(true)
-      }).catch((e: Error) => {
-        this.logger.error(e)
-        reject(e)
-      })
+      const initiatorTransport: MsgTransport | null = adapter
+        ? new MsgTransport(0, config, new HttpDuplex(adapter))
+        : null
+      if (!initiatorTransport) {
+        reject(new Error('no initiatorTransport for http'))
+      } else {
+        this.logger.info('... connected, run session')
+        initiatorSession.run(initiatorTransport).then(() => {
+          this.logger.info('ends')
+          resolve(true)
+        }).catch((e: Error) => {
+          this.logger.error(e)
+          reject(e)
+        })
+      }
     })
   }
 }

package/src/transport/http/http-json-sample-adapter.ts

@@ -9,14 +9,14 @@ import { DITokens } from '../../runtime/di-tokens'
 
 @injectable()
 export class HttpJsonSampleAdapter implements IHttpAdapter {
-  private logger: IJsFixLogger
-  private queue: HttpTransaction[] = []
-  private token: string = null
-  private routes: Dictionary<IHtmlRoute> = new Dictionary()
+  private readonly logger: IJsFixLogger
+  private readonly queue: HttpTransaction[] = []
+  private token: string | null = null
+  private readonly routes: Dictionary<IHtmlRoute> = new Dictionary()
   constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     this.logger = config.logFactory.logger('http.adapter')
     const routes = this.routes
-    const options = config.description.application.http.options
+    const options = config?.description?.application?.http?.options
     if (!options) {
       return
     }
@@ -26,17 +26,18 @@ export class HttpJsonSampleAdapter implements IHttpAdapter {
     this.logger.info(`instance created routes ${routes.count()}`)
   }
 
-  public getOptions (data: Buffer): IHtmlOptions {
+  public getOptions (data: Buffer): IHtmlOptions | null {
     const q = this.queue
     if (q.length === 0) {
       return null
     }
-    const next: HttpTransaction = q.shift()
+    const next: HttpTransaction | null = q.shift() ?? null
+    if (next == null) return null
     const options = next.options
-    options.body = {
+    options.data = {
       fixml: data.toString()
     }
-    this.logger.info(`${next.msgType}: ${next.options.method} ${next.options.uri} ${data.length}`)
+    this.logger.info(`${next.msgType}: ${next.options.method} ${next.options.url} ${data.length}`)
     return options
   }
 
@@ -47,19 +48,19 @@ export class HttpJsonSampleAdapter implements IHttpAdapter {
       this.token = headers.authorization
       this.logger.info(`receive token ${this.token}`)
     }
-    return m.body
+    return m.data
   }
 
   beginMessage (msgType: string): void {
     // build options based on type
     const routes = this.routes
-    const route = routes.get(msgType) || routes.get('default')
+    const route = routes.get(msgType) ?? routes.get('default')
     const options = {
-      method: route.value.method,
-      uri: route.value.uri,
-      json: route.value.json,
-      resolveWithFullResponse: route.value.resolveWithFullResponse,
-      headers: route.value.headers
+      method: route?.value.method,
+      url: route?.value.url,
+      json: route?.value.json,
+      resolveWithFullResponse: route?.value.resolveWithFullResponse,
+      headers: route?.value.headers
     } as IHtmlOptions
     const headers = options.headers
     if (headers) {

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

@@ -2,6 +2,6 @@ import { IHtmlOptions } from './html-options'
 
 export class HttpTransaction {
   constructor (public readonly msgType: string,
-               public readonly options: IHtmlOptions) {
+    public readonly options: IHtmlOptions) {
   }
 }

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

@@ -3,7 +3,7 @@ import { IHttpAdapter } from './http-adapter'
 
 export interface IHttpTransportDescription {
   readonly port: number
-  readonly uri: string,
+  readonly uri: string
   readonly options: IHtmlRoute[]
   adapter: IHttpAdapter
 }

package/src/transport/msg-application.ts

@@ -3,11 +3,11 @@ import { IHttpTransportDescription } from './http/http-transport-description'
 
 export interface IMsgApplication {
   readonly name: string
-  readonly type: string,
+  readonly type: string
   readonly resilient: boolean
   readonly reconnectSeconds: number
-  readonly tcp?: ITcpTransportDescription,
-  readonly http?: IHttpTransportDescription,
-  readonly protocol: string,
+  readonly tcp?: ITcpTransportDescription
+  readonly http?: IHttpTransportDescription
+  readonly protocol: string
   readonly dictionary: string
 }

package/src/transport/msg-transmitter.ts

@@ -11,8 +11,8 @@ export abstract class MsgTransmitter extends events.EventEmitter {
   public encoder: MsgEncoder
 
   protected constructor (public readonly buffer: ElasticBuffer,
-                         public readonly definitions: FixDefinitions,
-                         public readonly session: ISessionDescription) {
+    public readonly definitions: FixDefinitions,
+    public readonly session: ISessionDescription) {
     super()
     this.encodeStream = this.encoderStream()
     this.encodeStream.on('error', (e: Error) => {
@@ -28,7 +28,7 @@ export abstract class MsgTransmitter extends events.EventEmitter {
     this.encodeStream.write(new MsgPayload(msgType, obj))
   }
 
-  public abstract encodeMessage (msgType: string, obj: ILooseObject): void
+  public abstract encodeMessage (msgType: string, obj: ILooseObject): any
 
   // read fix messages from one side, encode buffers on other ready to pipe
   // to output stream, say a socket
@@ -41,11 +41,11 @@ export abstract class MsgTransmitter extends events.EventEmitter {
         try {
           const msgType = payload.msgType
           transmitter.encoder.reset()
-          transmitter.encodeMessage(msgType, payload.obj)
+          const state = transmitter.encodeMessage(msgType, payload.obj)
           payload.encoded = transmitter.encoder.trim()
           this.push(payload.encoded)
           const encodedTxt = transmitter.buffer.toString()
-          transmitter.emit('encoded', msgType, encodedTxt)
+          transmitter.emit('encoded', msgType, encodedTxt, state)
           done()
         } catch (e) {
           done(e)

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

@@ -13,12 +13,11 @@ import {
   ITestRequest
 } from '../../types/FIX4.4/repo'
 
-export interface ObjectMutator { (description: ISessionDescription, type: string, o: ILooseObject): ILooseObject
-}
+export type 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) {
+  protected constructor (public readonly description: ISessionDescription, public mutator: ObjectMutator | null = null) {
   }
 
   public reject (msgType: string, seqNo: number, msg: string, reason: number): ILooseObject {

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

@@ -3,14 +3,15 @@ import moment = require('moment')
 import { TickAction } from '../tick-action'
 import { IFixSessionStateArgs } from './fix-session-state-args'
 import { SessionState } from './session-state'
+import { ILooseObject } from '../../collections/collection'
 
 export class FixSessionState {
   public nextTickAction: TickAction = TickAction.Nothing
 
-  public lastReceivedAt: Date = null
-  public LastSentAt: Date = null
-  public lastTestRequestAt: Date = null
-  public logoutSentAt: Date = null
+  public lastReceivedAt: Date | null = null
+  public LastSentAt: Date | null = null
+  public lastTestRequestAt: Date | null = null
+  public logoutSentAt: Date | null = null
   public now: Date = new Date()
   public compId: string = ''
   public peerCompId: string = ''
@@ -24,8 +25,9 @@ export class FixSessionState {
   private secondsSinceLogoutSent: number = -1
   private secondsSinceSent: number = -1
   private secondsSinceReceive: number = -1
+  public lastHeader: ILooseObject | null = null
 
-  public reset (resetSeqNo: boolean): void {
+  public reset (lastPeerMsgSeqNum: number = 0): void {
     this.lastReceivedAt = null
     this.LastSentAt = null
     this.lastTestRequestAt = null
@@ -35,16 +37,17 @@ export class FixSessionState {
     this.peerHeartBeatSecs = 0
     this.logoutSentAt = null
     this.nextTickAction = TickAction.Nothing
-    if (resetSeqNo) {
-      this.lastPeerMsgSeqNum = 0
-    }
+    this.lastPeerMsgSeqNum = lastPeerMsgSeqNum
+    this.lastHeader = null
   }
 
-  public constructor ({ heartBeat,
-                        state = SessionState.Idle,
-                        waitLogoutConfirmSeconds = 5,
-                        stopSeconds = 2,
-                        lastPeerMsgSeqNum = 0 }: IFixSessionStateArgs) {
+  public constructor ({
+    heartBeat,
+    state = SessionState.Idle,
+    waitLogoutConfirmSeconds = 5,
+    stopSeconds = 2,
+    lastPeerMsgSeqNum = 0
+  }: IFixSessionStateArgs) {
     this.heartBeat = heartBeat
     this.state = state
     this.waitLogoutConfirmSeconds = waitLogoutConfirmSeconds
@@ -52,15 +55,18 @@ export class FixSessionState {
     this.lastPeerMsgSeqNum = lastPeerMsgSeqNum
   }
 
-  private static dateAsString (d: Date) {
+  private static dateAsString (d: Date | null): string {
     if (!d) {
       return 'null'
     }
     return moment(d).format('HH:mm:ss.SSS')
   }
 
-  public toString (): string {
+  public lastSentSeqNum (): number {
+    return this?.lastHeader?.MsgSeqNum ?? 0
+  }
 
+  public toString (): string {
     const buffer = new ElasticBuffer(1024)
 
     buffer.writeString(`compId = ${this.compId}, `)
@@ -79,6 +85,7 @@ export class FixSessionState {
     buffer.writeString(`peerHeartBeatSecs = ${this.peerHeartBeatSecs}, `)
     buffer.writeString(`peerCompId = ${this.peerCompId}, `)
     buffer.writeString(`lastPeerMsgSeqNum = ${this.lastPeerMsgSeqNum}, `)
+    buffer.writeString(`LastSentSeqNum = ${this.lastSentSeqNum()}, `)
     buffer.writeString(`secondsSinceLogoutSent = ${this.secondsSinceLogoutSent}, `)
     buffer.writeString(`secondsSinceSent = ${this.secondsSinceSent}, `)
     buffer.writeString(`secondsSinceReceive = ${this.secondsSinceReceive}`)
@@ -91,7 +98,6 @@ export class FixSessionState {
     this.calcState()
 
     switch (this.state) {
-
       case SessionState.PeerLogonRejected: {
         if (this.secondsSinceSent >= this.stopSeconds) {
           this.nextTickAction = TickAction.Stop
@@ -154,7 +160,7 @@ export class FixSessionState {
     const time = this.now.getTime()
     this.nextTickAction = TickAction.Nothing
     this.secondsSinceLogoutSent = this.logoutSentAt ? (time - this.logoutSentAt.getTime()) / 1000 : -1
-    this.secondsSinceSent = (time - this.LastSentAt.getTime()) / 1000
-    this.secondsSinceReceive = (time - this.lastReceivedAt.getTime()) / 1000
+    this.secondsSinceSent = this.LastSentAt != null ? (time - this.LastSentAt.getTime()) / 1000 : 0
+    this.secondsSinceReceive = this.lastReceivedAt != null ? (time - this.lastReceivedAt.getTime()) / 1000 : 0
   }
 }