jspurefix 1.2.0 → 2.0.0

package/src/transport/make-config.ts

@@ -1,19 +0,0 @@
-import { AsciiChars } from '../buffer'
-import { ISessionDescription } from './session-description'
-import { ISessionMsgFactory } from './fix-msg-factory'
-import { IJsFixConfig, JsFixConfig, JsFixLoggerFactory } from '../config'
-import { FixDefinitions } from '../dictionary'
-import { getDefinitions } from '../util'
-
-export async function makeConfig (description: ISessionDescription, logFactory: JsFixLoggerFactory, msgFactory: ISessionMsgFactory): Promise<IJsFixConfig> {
-  return new Promise<IJsFixConfig>(async (accept, reject) => {
-    try {
-      const definitions: FixDefinitions = await getDefinitions(description.application.dictionary,
-        (t: string) => logFactory.logger(`${description.application.type}.${t}`))
-      const config = new JsFixConfig(msgFactory, definitions, description, AsciiChars.Soh, logFactory)
-      accept(config)
-    } catch (e) {
-      reject(e)
-    }
-  })
-}

package/src/transport/msg-transport.ts

@@ -1,67 +0,0 @@
-import { AsciiParser, FiXmlParser, MsgParser, AsciiChars } from '../buffer'
-import { AsciiMsgTransmitter } from './ascii'
-import { MsgTransmitter } from './msg-transmitter'
-import { FixmlMsgTransmitter } from './fixml'
-import { FixDuplex } from './duplex'
-import { IJsFixConfig } from '../config'
-
-export class MsgTransport {
-  public readonly transmitter: MsgTransmitter
-  public readonly receiver: MsgParser
-
-  constructor (public readonly id: number,
-               public readonly config: IJsFixConfig,
-               public readonly duplex: FixDuplex) {
-
-    const delimiter = config.delimiter
-    if (!delimiter) {
-      throw new Error(`no delimiter char given.`)
-    }
-    const logDelimiter = config.logDelimiter || AsciiChars.Pipe
-    const description = config.description
-    const definitions = config.definitions
-    const protocol = description.application.protocol
-    switch (protocol) {
-      case 'ascii': {
-        // let parser replace delimiter with Pipe so fix log does not require
-        // expensive replace
-        this.transmitter = new AsciiMsgTransmitter(config)
-        this.receiver = new AsciiParser(definitions, duplex.readable, delimiter, logDelimiter)
-        break
-      }
-
-      case 'fixml': {
-        this.transmitter = new FixmlMsgTransmitter(config)
-        this.receiver = new FiXmlParser(config, duplex.readable)
-        break
-      }
-
-      default: {
-        throw new Error(`session Protocol must ascii or fixml. got ${protocol}`)
-      }
-    }
-
-    // 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/session-description.ts

@@ -1,70 +0,0 @@
-export interface ITlsOptions {
-  readonly key: string,
-  readonly cert: string,
-  readonly ca?: string[],
-  readonly timeout?: number,
-  readonly sessionTimeout?: number,
-  readonly enableTrace?: boolean,
-  readonly requestCert?: boolean,
-  readonly rejectUnauthorized?: boolean
-}
-
-export interface ITcpTransportDescription {
-  readonly port: number
-  readonly host: string,
-  readonly tls?: ITlsOptions
-}
-
-export interface IHttpAdapter {
-  getOptions (data: Buffer): IHtmlOptions
-  beginMessage (msgType: string): void
-  endMessage (m: any): Buffer
-}
-
-export interface IHtmlOptions {
-  method: string,
-  uri: string,
-  json: boolean,
-  body: any,
-  headers: any,
-  resolveWithFullResponse: boolean
-}
-
-export interface IHtmlRoute {
-  name: string,
-  value: IHtmlOptions
-}
-
-export interface IHttpTransportDescription {
-  readonly port: number
-  readonly uri: string,
-  readonly options: IHtmlRoute[]
-  adapter: IHttpAdapter
-}
-
-export interface IMsgApplication {
-  readonly name: string
-  readonly type: string,
-  readonly reconnectSeconds: number
-  readonly tcp?: ITcpTransportDescription,
-  readonly http?: IHttpTransportDescription,
-  readonly protocol: string,
-  readonly dictionary: string
-}
-
-export interface ISessionDescription {
-  readonly application?: IMsgApplication
-  readonly Name: string
-  readonly Username: string
-  readonly Password: string
-  HeartBtInt: number
-  readonly SenderCompId: string
-  readonly TargetCompID: string
-  readonly ResetSeqNumFlag: boolean
-  readonly LastSentSeqNum?: number
-  readonly LastReceivedSeqNum?: number
-  readonly SenderSubID: string
-  readonly TargetSubID: string
-  readonly BeginString: string
-  readonly BodyLengthChars?: number,
-}

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

@@ -1,195 +0,0 @@
-import { ISessionMsgFactory } from './fix-msg-factory'
-import { ISessionDescription } from './session-description'
-import { ILooseObject } from '../collections/collection'
-import { MsgType } from '../types'
-
-import {
-  EncryptMethod,
-  IHeartbeat,
-  ILogon,
-  ILogout,
-  IReject,
-  IResendRequest,
-  ISequenceReset,
-  IStandardHeader,
-  IStandardTrailer,
-  ITestRequest
-} from '../types/FIX4.4/repo'
-
-import {
-  IStandardHeader as IStandardHeaderFixml,
-  IUserRequest,
-  IUserResponse,
-  UserRequestType,
-  UserStatus
-} from '../types/FIXML50SP2'
-
-export interface ObjectMutator { (description: ISessionDescription, type: string, o: ILooseObject): ILooseObject
-}
-
-export class SessionMsgFactory implements ISessionMsgFactory {
-
-  public isAscii: boolean
-
-  constructor (public readonly description: ISessionDescription, public mutator: ObjectMutator = null) {
-    this.isAscii = description.application.protocol === 'ascii'
-  }
-
-  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
-  }
-
-  public logon (userRequestId: string = '', isResponse: boolean = false): ILooseObject {
-    if (this.isAscii) {
-      return this.asciiLogon()
-    } else {
-      return this.fixmlLogon(userRequestId, isResponse)
-    }
-  }
-
-  public logout (msgType: string, text: string): ILooseObject {
-    if (this.isAscii) {
-      return this.asciiLogout(text)
-    } else {
-      return this.fixmlLogout(text, msgType !== 'UserReq')
-    }
-  }
-
-  public testRequest (reqId: string = `ping-${new Date().toUTCString()}`): ILooseObject {
-    const o: ITestRequest = {
-      TestReqID: reqId
-    } as ITestRequest
-    return this.mutator ? this.mutator(this.description, MsgType.TestRequest, o) : o
-  }
-
-  public heartbeat (testReqId: string): ILooseObject {
-    const o: IHeartbeat = {
-      TestReqID: testReqId
-    } as IHeartbeat
-    return this.mutator ? this.mutator(this.description, MsgType.Heartbeat, o) : o
-  }
-
-  public resendRequest (from: number, to: number): ILooseObject {
-    const o: IResendRequest = {
-      BeginSeqNo: from,
-      EndSeqNo: to
-    } as IResendRequest
-    return this.mutator ? this.mutator(this.description, MsgType.ResendRequest, o) : o
-  }
-
-  public sequenceReset (newSeqNo: number, gapFill?: boolean): ILooseObject {
-    const o: ISequenceReset = {
-      GapFillFlag: gapFill === true,
-      NewSeqNo: newSeqNo
-    } as ISequenceReset
-    return this.mutator ? this.mutator(this.description, MsgType.SequenceReset, o) : o
-  }
-
-  public header (msgType: string, seqNum: number = 0, time: Date = new Date(), overrideData?: Partial<IStandardHeader>): ILooseObject {
-    if (this.isAscii) {
-      return this.asciiHeader(msgType, seqNum, time, overrideData)
-    } else {
-      return this.fixmlHeader()
-    }
-  }
-
-  public trailer (checksum: number): ILooseObject {
-    const s = checksum.toString()
-    const padded = s.padStart(3, '0')
-    return {
-      CheckSum: padded
-    } as IStandardTrailer
-  }
-
-  private asciiLogon (): 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.mutator ? this.mutator(this.description, MsgType.Logon, o) : o
-  }
-
-  private asciiLogout (text: string): ILooseObject {
-    const o: ILogout = {
-      Text:  text
-    } as ILogout
-    return this.mutator ? this.mutator(this.description, MsgType.Logout, o) : o
-  }
-
-  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.mutator ? this.mutator(this.description, MsgType.Logon, o) : o
-    } else {
-      const o: IUserResponse = {
-        Username: description.Username,
-        UserRequestID: userRequestId,
-        UserStatus: UserStatus.LoggedIn
-      } as IUserResponse
-      return this.mutator ? this.mutator(this.description, MsgType.Logon, o) : o
-    }
-  }
-
-  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.mutator ? this.mutator(this.description, MsgType.Logon, o) : o
-    } else {
-      const o: IUserResponse = {
-        Username: this.description.Username,
-        UserRequestID: userRequestId,
-        UserStatus: UserStatus.NotLoggedIn
-      } as IUserResponse
-      return this.mutator ? this.mutator(this.description, MsgType.Logon, o) : o
-    }
-  }
-
-  private asciiHeader (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.mutator ? this.mutator(description, 'StandardHeader', o) : o
-  }
-
-  private fixmlHeader (): ILooseObject {
-    const description = this.description
-    const o: IStandardHeaderFixml = {
-      SenderCompID: description.SenderCompId,
-      TargetCompID: description.TargetCompID,
-      SenderSubID: description.SenderSubID,
-      TargetSubID: description.TargetSubID
-    } as IStandardHeaderFixml
-    return this.mutator ? this.mutator(this.description, MsgType.Logon, o) : o
-  }
-}

package/src/transport/tcp/acceptor.ts

@@ -1,31 +0,0 @@
-import { IJsFixConfig } from '../../config'
-import { FixAcceptor } from '../fix-acceptor'
-import { TcpAcceptor } from './tcp-acceptor'
-import { MsgTransport } from '../msg-transport'
-import { MakeFixSession } from '../make-fixl-session'
-
-export function acceptor (config: IJsFixConfig, sessionFactory: MakeFixSession): Promise<any> {
-  return new Promise<any>(async (accept, reject) => {
-    const logger = config.logFactory.logger('acceptor')
-    logger.info('starting.')
-    const acceptor: FixAcceptor = new TcpAcceptor(config)
-    acceptor.on('transport', (t: MsgTransport) => {
-      logger.info('creates new transport.')
-      const acceptorSession = sessionFactory(config)
-      acceptorSession.run(t).then(() => {
-        logger.info('ends')
-        acceptor.close(() => {
-          logger.info('acceptor closed.')
-          accept(true)
-        })
-      }).catch((e: Error) => {
-        logger.info(`error in session - close listener ${e.message}`)
-        acceptor.close(() => {
-          logger.info('acceptor closed.')
-          reject(e)
-        })
-      })
-    })
-    acceptor.listen()
-  })
-}

package/src/transport/tcp/initiator.ts

@@ -1,59 +0,0 @@
-import { IJsFixConfig } from '../../config'
-import { FixInitiator } from '../fix-initiator'
-import { TcpInitiator } from './tcp-initiator'
-import { MsgTransport } from '../msg-transport'
-import { MakeFixSession } from '../make-fixl-session'
-import { FixSession } from '../fix-session'
-
-export function initiator (config: IJsFixConfig, sessionFactory: MakeFixSession, reconnectTimeout: number = 0): Promise<any> {
-  return new Promise<any>(async (accept, reject) => {
-    const logger = config.logFactory.logger('initiator')
-    logger.info('create session')
-    const initiatorSession = sessionFactory(config)
-    let connecting: boolean = true
-    while (connecting) {
-      try {
-        await once(config, initiatorSession)
-        logger.info('session has ended')
-        connecting = false
-        accept(true)
-      } catch (e) {
-        if (!reconnectTimeout) {
-          connecting = false
-          reject(e)
-        } else {
-          logger.info(`waiting ${reconnectTimeout} to reconnect following error`)
-          await delay(reconnectTimeout)
-        }
-      }
-    }
-  })
-}
-
-function delay (p: number): Promise<any> {
-  return new Promise<any>((accept) => {
-    if (!p) {
-      accept(true)
-    }
-    setTimeout(() => {
-      accept(true)
-    }, p)
-  })
-}
-
-function once (config: IJsFixConfig, initiatorSession: FixSession): Promise<any> {
-  return new Promise<any>(async (accept, reject) => {
-    const logger = config.logFactory.logger('initiator')
-    const initiator: FixInitiator = new TcpInitiator(config)
-    logger.info('connecting ...')
-    const initiatorTransport: MsgTransport = await initiator.connect(22)
-    logger.info('... connected, run session')
-    initiatorSession.run(initiatorTransport).then(() => {
-      logger.info('ends')
-      accept(true)
-    }).catch((e: Error) => {
-      logger.error(e)
-      reject(e)
-    })
-  })
-}

package/src/util/dictionary-definitions.ts

@@ -1,41 +0,0 @@
-import { FixXsdParser, FixDefinitions, FixParser, QuickFixXmlFileParser, RepositoryXmlParser } from '../dictionary'
-import { GetJsFixLogger, makeEmptyLogger } from '../config'
-import * as path from 'path'
-import * as fs from 'fs'
-
-export interface IDictionaryPath {
-  output: string,
-  dict: string
-}
-
-const root: string = path.join(__dirname, '../../')
-
-export function getDictPath (p: string): IDictionaryPath {
-  const dictionary = require(path.join(root, 'data/dictionary.json'))
-  return dictionary[p]
-}
-
-export async function getDefinitions (path: string, getLogger: GetJsFixLogger = makeEmptyLogger): Promise<FixDefinitions> {
-  let parser: FixParser
-  const dp: IDictionaryPath = getDictPath(path)
-  if (dp) {
-    path = dp.dict
-  }
-  path = norm(path)
-  if (fs.lstatSync(path).isDirectory() && path.indexOf('fixml') >= 0) {
-    parser = new FixXsdParser(path, getLogger)
-  } else if (fs.lstatSync(path).isDirectory()) {
-    parser = new RepositoryXmlParser(path, getLogger)
-  } else {
-    parser = new QuickFixXmlFileParser(path, getLogger)
-  }
-  return parser.parse()
-}
-
-function norm (p: string): string {
-  let f: string = p
-  if (!path.isAbsolute(p)) {
-    f = path.join(root, f)
-  }
-  return f
-}