jspurefix 1.4.1 → 2.0.0

package/src/jsfix-cmd.ts

@@ -1,16 +1,24 @@
-import { ElasticBuffer, MsgView, MsgParser, AsciiParser, AsciiView, AsciiChars } from './buffer'
+import 'reflect-metadata'
+
+import { ElasticBuffer, MsgView, MsgParser } from './buffer'
+import { AsciiParser, AsciiView, AsciiChars } from './buffer/ascii'
 import { ILooseObject } from './collections/collection'
-import { SimpleFieldDefinition, FixDefinitions, MsgCompiler, EnumCompiler, ICompilerSettings } from './dictionary'
-import { MessageGenerator, JsonHelper, getDefinitions, getDictPath, getWords } from './util'
-import { AsciiMsgTransmitter, ISessionDescription, SessionMsgFactory, MsgTransport, FileDuplex, StringDuplex } from './transport'
+import { SimpleFieldDefinition, FixDefinitions } from './dictionary/definition'
+import { MessageGenerator, JsonHelper, getWords, DefinitionFactory } from './util'
+import { ISessionDescription, FileDuplex, StringDuplex } from './transport'
 
 import { MsgTag } from './types'
-import { JsFixConfig } from './config'
+import { IJsFixConfig } from './config'
 
 import * as util from 'util'
 const fs = require('node-fs-extra')
 import * as minimist from 'minimist'
 import * as path from 'path'
+import { MsgTransport } from './transport/factory'
+import { EnumCompiler, ICompilerSettings, MsgCompiler } from './dictionary/compiler'
+import { AsciiMsgTransmitter } from './transport/ascii/ascii-msg-transmitter'
+import { SessionContainer } from './runtime'
+import { DITokens } from './runtime/di-tokens'
 
 const argv: any = minimist(process.argv.slice(2))
 
@@ -294,7 +302,7 @@ export class JsfixCmd {
 
   private async compile () {
     let output = argv.output
-    const dp = getDictPath(argv.dict)
+    const dp = new DefinitionFactory().getDictPath(argv.dict)
     if (dp) {
       output = dp.output
     }
@@ -302,26 +310,33 @@ export class JsfixCmd {
     await this.compileDefinitions(output)
   }
 
+  sys: SessionContainer
+  config: IJsFixConfig
+
   private async init (): Promise<any> {
     let session: string = argv.session || 'data/session/test-initiator.json'
+    this.sys = new SessionContainer()
+    this.sys.registerGlobal('error')
     session = this.norm(session)
     this.sessionDescription = require(session)
+    const container = await this.sys.makeSystem(this.sessionDescription)
+    this.config = container.resolve<IJsFixConfig>(DITokens.IJsFixConfig)
+    this.definitions = this.config.definitions
     let dict: string
     if (argv.dict) {
       dict = argv.dict
-    } else {
-      dict = this.sessionDescription.application.dictionary
+      const df = await new DefinitionFactory().getDefinitions(dict)
+      this.config.definitions = df
+      this.definitions = df
     }
-    this.definitions = await getDefinitions(dict)
     const definitions = this.definitions
     if (argv.delimiter) {
       this.delimiter = AsciiChars.firstChar(argv.delimiter)
+      this.config.delimiter = this.delimiter
     }
     this.jsonHelper = new JsonHelper(definitions)
     if (argv.session) {
-      const description = this.sessionDescription
-      const config = new JsFixConfig(new SessionMsgFactory(description), definitions, description, this.delimiter)
-      this.session = new AsciiMsgTransmitter(config)
+      this.session = container.resolve<AsciiMsgTransmitter>(DITokens.MsgTransmitter)
     }
   }
 
@@ -428,7 +443,7 @@ export class JsfixCmd {
       return
     }
     const fix: string = this.norm(argv.fix)
-    const config = new JsFixConfig(null, this.definitions, this.sessionDescription, this.delimiter)
+    const config = this.config
     const ft: MsgTransport = new MsgTransport(1, config, new FileDuplex(fix))
     await this.dispatch(ft)
   }
@@ -441,8 +456,6 @@ export class JsfixCmd {
     return new Promise<any>((accept, reject) => {
       const fix: string = this.norm(argv.fix)
       const fs = require('fs')
-      const definitions = this.definitions
-      const delimiter = this.delimiter
       fs.readFile(fix, 'utf8', async (err: Error, contents: string) => {
         if (err) {
           reject(err)
@@ -450,7 +463,9 @@ export class JsfixCmd {
         const toParse = new StringDuplex(contents.repeat(repeats), false)
         const startsAt: Date = new Date()
         let i = 0
-        const asciiParser: MsgParser = new AsciiParser(definitions, toParse.readable, delimiter)
+        const config = this.config
+        const buffer = config.sessionContainer.resolve<ElasticBuffer>(DITokens.ParseBuffer)
+        const asciiParser: MsgParser = new AsciiParser(config, toParse.readable, buffer)
         asciiParser.on('msg', (msgType: string, v: MsgView) => {
           ++i
           if (i === repeats) {

package/src/runtime/di-tokens.ts

@@ -0,0 +1,48 @@
+
+export enum DITokens {
+  // the JSON representation defining header
+  ISessionDescription = 'ISessionDescription',
+  // the main config interface created from application JSON config
+  IJsFixConfig = 'IJsFixConfig',
+  // the data dictionary holding all field definitions - represented in quickfix or repo
+  Definitions = 'Definitions',
+  // the main application session object type
+  FixSession = 'FixSession',
+  // used to construct loggers e.g. in Winston
+  JsFixLoggerFactory = 'JsFixLoggerFactory',
+  // used to construct session protocol messages - logon / heartbeat / reset
+  ISessionMsgFactory = 'ISessionMsgFactory',
+  // a tcp socket or string / file for unit testing - abstraction of physical transport
+  FixDuplex = 'FixDuplex',
+  // ASCII: format messages from objects and send to socket
+  MsgTransmitter = 'MsgTransmitter',
+  // ASCII: write object attributes in txt to transmit buffer
+  MsgEncoder = 'MsgEncoder',
+  // ASCII: receive bytes from socket and parse to tags
+  MsgParser = 'MsgParser',
+  // FIXML: user defined adapter used in HTTP to manage a transaction
+  IHttpAdapter = 'IHttpAdapter',
+  // the listener or connector depending on entity type.
+  FixEntity = 'FixEntity',
+  // the transport listener to construct sessions on connection
+  Listener = 'Listener',
+  // used to initiate a connection to listener in order to establish a transport
+  Connector = 'Connector',
+  // a self adjusting buffer to allow messages to be formatted
+  ElasticBuffer = 'ElasticBuffer',
+  // parse into this buffer
+  ParseBuffer = 'ReceiveBuffer',
+  // format into and clone from this buffer to transmit stream
+  TransmitBuffer = 'SendBuffer',
+
+  elasticBufferSize = 'elasticBufferSize',
+  elasticBufferReturnSize = 'elasticBufferReturnSize',
+
+  logDelimiter = 'logDelimiter',
+  delimiter = 'delimiter',
+  sessionId = 'sessionId',
+  maxMessageLen = 'maxMessageLen',
+  readStream = 'readStream',
+  duplexParam = 'duplexParam',
+  maxMessageLocations = 'maxMessageLocations'
+}

package/src/runtime/engine-factory.ts

@@ -0,0 +1,5 @@
+import { MakeFixSession } from '../transport'
+
+export interface EngineFactory {
+  makeSession: MakeFixSession
+}

package/src/runtime/index.ts

@@ -0,0 +1,5 @@
+export * from './make-config'
+export * from './session-container'
+export * from './di-tokens'
+export * from './session-launcher'
+export * from './engine-factory'

package/src/runtime/make-config.ts

@@ -0,0 +1,35 @@
+import { AsciiChars } from '../buffer/ascii'
+import { ISessionDescription, ISessionMsgFactory } from '../transport/'
+import { IJsFixConfig, JsFixConfig, JsFixLoggerFactory } from '../config'
+import { FixDefinitions } from '../dictionary/definition'
+import { DefinitionFactory } from '../util/'
+import { injectable, inject } from 'tsyringe'
+import { DITokens } from './di-tokens'
+
+@injectable()
+export class RuntimeFactory {
+  constructor (
+    @inject(DefinitionFactory) public readonly definitionFactory: DefinitionFactory,
+    @inject(DITokens.JsFixLoggerFactory) public readonly logFactory: JsFixLoggerFactory,
+    @inject(DITokens.ISessionMsgFactory) public readonly msgFactory: ISessionMsgFactory,
+    @inject(DITokens.ISessionDescription) public readonly description: ISessionDescription) {}
+
+  makeConfig (): Promise<IJsFixConfig> {
+    const description = this.description
+    return new Promise<IJsFixConfig>((accept, reject) => {
+      try {
+        this.definitionFactory.getDefinitions(description.application.dictionary,
+          (t: string) => {
+            return this.logFactory.logger(`${description.application.type}.${t}`)
+          }).then((definitions: FixDefinitions) => {
+            const config = new JsFixConfig(this.msgFactory, definitions, description, AsciiChars.Soh, this.logFactory)
+            accept(config)
+          }).catch(e => {
+            reject(e)
+          })
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
+}

package/src/runtime/session-container.ts

@@ -0,0 +1,180 @@
+import { container, DependencyContainer } from 'tsyringe'
+import { DefinitionFactory } from '../util'
+import { IJsFixConfig, JsFixWinstonLogFactory, WinstonLogger } from '../config'
+import { DITokens } from './di-tokens'
+import { RuntimeFactory } from './make-config'
+
+import { TcpAcceptorListener, RecoveringTcpInitiator,
+  TcpInitiatorConnector, TcpInitiator } from '../transport/tcp'
+import { HttpInitiator, HttpAcceptorListener, HttpJsonSampleAdapter } from '../transport/http'
+import { ISessionMsgFactory, MsgTransmitter, ISessionDescription } from '../transport'
+import { AsciiMsgTransmitter } from '../transport/ascii/ascii-msg-transmitter'
+import { FixmlMsgTransmitter } from '../transport/fixml/fixml-msg-transmitter'
+import { FixmlSessionMsgFactory } from '../transport/fixml'
+import { AsciiSessionMsgFactory } from '../transport/ascii'
+import { ElasticBuffer, MsgEncoder, MsgParser } from '../buffer'
+import { AsciiParser, AsciiParserState, AsciiSegmentParser } from '../buffer/ascii'
+import { FixmlEncoder, FiXmlParser } from '../buffer/fixml'
+import { FixEntity } from '../transport/fix-entity'
+import { IHttpAdapter } from '../transport/http/http-adapter'
+
+export class SessionContainer {
+
+  public reset (): void {
+    container.reset()
+  }
+
+  public registerGlobal (level: string = 'info'): void {
+    container.registerInstance(DefinitionFactory, new DefinitionFactory())
+    const lf = new JsFixWinstonLogFactory(WinstonLogger.consoleOptions(level))
+    container.registerInstance(DITokens.JsFixLoggerFactory, lf)
+    container.register<RuntimeFactory>(RuntimeFactory, {
+      useClass: RuntimeFactory
+    })
+    container.register<ElasticBuffer>(DITokens.ElasticBuffer, {
+      useClass: ElasticBuffer
+    })
+  }
+
+  protected makeSessionFactory (description: ISessionDescription): ISessionMsgFactory {
+    const fixml = !this.isAscii(description)
+    return fixml ?
+      new FixmlSessionMsgFactory(description) :
+      new AsciiSessionMsgFactory(description)
+  }
+
+  public newChild (description: ISessionDescription): DependencyContainer {
+    const sessionContainer = container.createChildContainer()
+    const sf = this.makeSessionFactory(description)
+    sessionContainer.registerInstance(DITokens.ISessionDescription, description)
+    sessionContainer.registerInstance(DITokens.ISessionMsgFactory, sf)
+    return sessionContainer
+  }
+
+  public makeSystem (description: ISessionDescription): Promise<DependencyContainer> {
+    return new Promise<DependencyContainer>((resolve, reject) => {
+      const sessionContainer = this.newChild(description)
+      const factory = sessionContainer.resolve<RuntimeFactory>(RuntimeFactory)
+      factory.makeConfig().then((c: IJsFixConfig) => {
+        this.registerSession(c, sessionContainer)
+        resolve(sessionContainer)
+      }).catch(e => {
+        reject(e)
+      })
+    })
+  }
+
+  public isAscii (description: ISessionDescription): boolean {
+    return description.application.protocol === 'ascii'
+  }
+
+  public isInitiator (description: ISessionDescription): boolean {
+    return description.application.type === 'initiator'
+  }
+
+  public asAscii (description: ISessionDescription, sessionContainer: DependencyContainer) {
+    sessionContainer.register<MsgTransmitter>(DITokens.MsgTransmitter, {
+      useClass: AsciiMsgTransmitter
+    })
+    sessionContainer.register<MsgParser>(DITokens.MsgParser, {
+      useClass: AsciiParser
+    })
+    const parseSize = 160 * 1024
+    const sendSize = 10 * 1024
+
+    sessionContainer.register(DITokens.maxMessageLen, {
+      useValue: parseSize
+    })
+    sessionContainer.register<AsciiSegmentParser>(AsciiSegmentParser, {
+      useClass: AsciiSegmentParser
+    })
+    sessionContainer.register<AsciiParserState>(AsciiParserState, {
+      useClass: AsciiParserState
+    })
+
+    sessionContainer.registerInstance<ElasticBuffer>(DITokens.TransmitBuffer, new ElasticBuffer(sendSize))
+    sessionContainer.registerInstance<ElasticBuffer>(DITokens.ParseBuffer, new ElasticBuffer(parseSize))
+
+    if (this.isInitiator(description)) {
+      sessionContainer.register<TcpInitiator>(TcpInitiator, {
+        useClass: TcpInitiator
+      })
+      sessionContainer.register<RecoveringTcpInitiator>(RecoveringTcpInitiator, {
+        useClass: RecoveringTcpInitiator
+      })
+      sessionContainer.register<TcpInitiatorConnector>(TcpInitiatorConnector, {
+        useClass: TcpInitiatorConnector
+      })
+      if (description.application.resilient) {
+        sessionContainer.register<FixEntity>(DITokens.FixEntity, {
+          useClass: RecoveringTcpInitiator
+        })
+      } else {
+        sessionContainer.register<FixEntity>(DITokens.FixEntity, {
+          useClass: TcpInitiatorConnector
+        })
+      }
+    } else {
+      sessionContainer.register<FixEntity>(DITokens.FixEntity, {
+        useClass: TcpAcceptorListener
+      })
+    }
+  }
+
+  public asFixml (description: ISessionDescription, sessionContainer: DependencyContainer) {
+    sessionContainer.register<MsgTransmitter>(DITokens.MsgTransmitter, {
+      useClass: FixmlMsgTransmitter
+    })
+    const sendSize = 10 * 1024
+
+    sessionContainer.register<MsgParser>(DITokens.MsgParser, {
+      useClass: FiXmlParser
+    })
+    sessionContainer.register(DITokens.maxMessageLocations, {
+      useValue: sendSize
+    })
+    sessionContainer.register<MsgEncoder>(DITokens.MsgEncoder, {
+      useClass: FixmlEncoder
+    })
+    sessionContainer.registerInstance<ElasticBuffer>(DITokens.TransmitBuffer, new ElasticBuffer(sendSize))
+    sessionContainer.register<HttpAcceptorListener>(HttpAcceptorListener, {
+      useClass: HttpAcceptorListener
+    })
+    sessionContainer.register<HttpInitiator>(HttpInitiator, {
+      useClass: HttpInitiator
+    })
+    if (this.isInitiator(description)) {
+      sessionContainer.register<FixEntity>(DITokens.FixEntity, {
+        useClass: HttpInitiator
+      })
+      sessionContainer.register<IHttpAdapter>(DITokens.IHttpAdapter, {
+        useClass: HttpJsonSampleAdapter
+      })
+    } else {
+      sessionContainer.register<FixEntity>(DITokens.FixEntity, {
+        useClass: HttpAcceptorListener
+      })
+    }
+  }
+
+  protected asciiConstants (c: IJsFixConfig, sessionContainer: DependencyContainer) {
+    sessionContainer.register(DITokens.delimiter, {
+      useValue: c.delimiter
+    })
+    sessionContainer.register(DITokens.logDelimiter, {
+      useValue: c.logDelimiter
+    })
+  }
+
+  public registerSession (c: IJsFixConfig, sessionContainer: DependencyContainer) {
+    if (this.isAscii(c.description)) {
+      this.asAscii(c.description, sessionContainer)
+      this.asciiConstants(c, sessionContainer)
+    } else {
+      this.asFixml(c.description, sessionContainer)
+    }
+    c.sessionContainer = sessionContainer
+    sessionContainer.registerInstance(DITokens.IJsFixConfig, c)
+    sessionContainer.registerInstance(DITokens.Definitions, c.definitions)
+  }
+}

package/src/runtime/session-launcher.ts

@@ -0,0 +1,127 @@
+import * as path from 'path'
+import { IJsFixConfig, IJsFixLogger, JsFixWinstonLogFactory, WinstonLogger } from '../config'
+import { ISessionDescription, FixEntity, FixSession } from '../transport'
+import { DependencyContainer } from 'tsyringe'
+import { EngineFactory } from './engine-factory'
+import { SessionContainer } from './session-container'
+import { DITokens } from './di-tokens'
+
+const root = '../../'
+const logFactory = new JsFixWinstonLogFactory(WinstonLogger.consoleOptions('info'))
+
+export abstract class SessionLauncher {
+  protected readonly logger: IJsFixLogger
+  protected constructor (public readonly initiatorConfig: string,
+                         public readonly acceptorConfig: string = null) {
+    this.logger = logFactory.logger('launcher')
+  }
+  protected sessionContainer: SessionContainer = new SessionContainer()
+
+  private empty (): Promise<any> {
+    return new Promise((resolve, _) => {
+      setImmediate(() => {
+        this.logger.info('resolving an empty promise')
+        resolve(null)
+      })
+    })
+  }
+
+  protected getAcceptor (sessionContainer: DependencyContainer): Promise<any> {
+    if (sessionContainer.isRegistered<FixEntity>(DITokens.FixEntity)) {
+      const entity = sessionContainer.resolve<FixEntity>(DITokens.FixEntity)
+      return entity.start()
+    } else {
+      return this.empty()
+    }
+  }
+
+  protected getInitiator (sessionContainer: DependencyContainer): Promise<any> {
+    if (sessionContainer.isRegistered<FixEntity>(DITokens.FixEntity)) {
+      const entity = sessionContainer.resolve<FixEntity>(DITokens.FixEntity)
+      return entity.start()
+    } else {
+      return this.empty()
+    }
+  }
+
+  protected makeFactory (config: IJsFixConfig): EngineFactory {
+    return null
+  }
+
+  public run () {
+    return new Promise<any>((accept, reject) => {
+      const logger = this.logger
+      logger.info('launching ..')
+      this.setup().then(() => {
+        logger.info('.. done')
+        accept(true)
+      }).catch((e: Error) => {
+        logger.error(e)
+        reject(e)
+      })
+    })
+  }
+
+  public exec () {
+    this.run().then(() => {
+      console.log('finished.')
+    }).catch(e => {
+      console.error(e)
+    })
+  }
+
+  public isAscii (description: ISessionDescription): boolean {
+    return this.sessionContainer.isAscii(description)
+  }
+
+  public isInitiator (description: ISessionDescription): boolean {
+    return this.sessionContainer.isInitiator(description)
+  }
+
+  protected registerApplication (sessionContainer: DependencyContainer): void {
+    this.logger.info('bypass register via DI')
+  }
+
+  private makeSystem (description: ISessionDescription): Promise<DependencyContainer> {
+    this.logger.info(`creating app ${description.application.name} [protocol ${description.application.protocol}]`)
+    return this.sessionContainer.makeSystem(description)
+  }
+
+  private register (container: DependencyContainer): void {
+    const config = container.resolve<IJsFixConfig>(DITokens.IJsFixConfig)
+    const factory = this.makeFactory(config)
+    if (!factory) {
+      this.registerApplication(container)
+    } else {
+      if (factory.makeSession) {
+        container.register<FixSession>(DITokens.FixSession, {
+          useFactory: () => factory.makeSession(config)
+        })
+      }
+    }
+  }
+
+  private async makeClient (): Promise<any> {
+    const description: ISessionDescription = require(path.join(root, this.initiatorConfig))
+    const sessionContainer = await this.makeSystem(description)
+    this.register(sessionContainer)
+    this.logger.info('create initiator')
+    return this.getInitiator(sessionContainer)
+  }
+
+  private async makeServer (): Promise<any> {
+    const description: ISessionDescription = require(path.join(root, this.acceptorConfig))
+    const sessionContainer = await this.makeSystem(description)
+    this.register(sessionContainer)
+    this.logger.info('create acceptor')
+    return this.getAcceptor(sessionContainer)
+  }
+
+  private async setup () {
+    this.sessionContainer.registerGlobal()
+    const server = this.initiatorConfig ? this.makeServer() : this.empty()
+    const client = this.acceptorConfig ? this.makeClient() : this.empty()
+    this.logger.info('launching ....')
+    return Promise.all([server, client])
+  }
+}

package/src/sample/http/oms/app.ts

@@ -1,30 +1,36 @@
+import 'reflect-metadata'
+
 import { HttpServer } from './http-server'
 import { HttpClient } from './http-client'
 import { IJsFixConfig } from '../../../config'
-import { Launcher } from '../../launcher'
-import { httpInitiator, HttpJsonSampleAdapter } from '../../../transport/http'
-import { acceptor } from '../../../transport/fixml'
+import { DITokens, EngineFactory, SessionLauncher } from '../../../runtime'
+import { DependencyContainer } from 'tsyringe'
+import { FixEntity } from '../../../transport'
+import { IHttpAdapter } from '../../../transport/http/http-adapter'
 
-class AppLauncher extends Launcher {
+class AppLauncher extends SessionLauncher {
   public constructor () {
     super(
       'data/session/test-http-initiator.json',
       'data/session/test-http-acceptor.json')
   }
 
-  protected getAcceptor (config: IJsFixConfig): Promise<any> {
-    return acceptor(config, (c) => new HttpServer(c))
+  protected override makeFactory (config: IJsFixConfig): EngineFactory {
+    const isInitiator = this.isInitiator(config.description)
+    return {
+      makeSession: () => isInitiator ?
+        new HttpClient(config) :
+        new HttpServer(config)
+    } as EngineFactory
   }
 
-  protected getInitiator (config: IJsFixConfig): Promise<any> {
-    config.description.application.http.adapter = new HttpJsonSampleAdapter(config)
-    return httpInitiator(config, (c) => new HttpClient(c))
+  protected override getInitiator (sessionContainer: DependencyContainer): Promise<any> {
+    const config: IJsFixConfig = sessionContainer.resolve<IJsFixConfig>(DITokens.IJsFixConfig)
+    config.description.application.http.adapter = sessionContainer.resolve<IHttpAdapter>(DITokens.IHttpAdapter)
+    const initiator = sessionContainer.resolve<FixEntity>(DITokens.FixEntity)
+    return initiator.start()
   }
 }
 
 const l = new AppLauncher()
-l.run().then(() => {
-  console.log('finished.')
-}).catch(e => {
-  console.log(e)
-})
+l.exec()

package/src/sample/http/oms/http-client.ts

@@ -3,13 +3,16 @@ import { MsgView } from '../../../buffer'
 import { IJsFixLogger, IJsFixConfig } from '../../../config'
 import { OmsFactory } from './oms-factory'
 import { IExecutionReport, Side } from '../../../types/FIXML50SP2'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../../runtime'
 
+@injectable()
 export class HttpClient extends FixmlSession {
   private readonly logger: IJsFixLogger
   private readonly fixLog: IJsFixLogger
   private readonly factory: OmsFactory = new OmsFactory('TradersRUs')
-  constructor (public readonly config: IJsFixConfig,
-               public readonly logoutSeconds: number = 45) {
+  constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig,
+               @inject('logoutSeconds') public readonly logoutSeconds: number = 45) {
     super(config)
     this.logReceivedMsgs = true
     this.fixLog = config.logFactory.plain(`jsfix.${config.description.application.name}.txt`)

package/src/sample/http/oms/http-server.ts

@@ -3,12 +3,16 @@ import { FixmlSession } from '../../../transport/fixml'
 import { IJsFixLogger, IJsFixConfig } from '../../../config'
 import { INewOrderSingle, IExecutionReport } from '../../../types/FIXML50SP2'
 import { OmsFactory } from './oms-factory'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../../runtime'
 
+@injectable()
 export class HttpServer extends FixmlSession {
   private readonly logger: IJsFixLogger
   private readonly fixLog: IJsFixLogger
   private readonly factory: OmsFactory = new OmsFactory('server')
-  constructor (public readonly config: IJsFixConfig) {
+
+  constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config)
     this.logReceivedMsgs = true
     this.fixLog = config.logFactory.plain(`jsfix.${config.description.application.name}.txt`)

package/src/sample/tcp/qf-md/app.ts

@@ -1,26 +1,26 @@
+import 'reflect-metadata'
+
 import { MDClient } from './md-client'
 import { MDServer } from './md-server'
 import { IJsFixConfig } from '../../../config'
-import { initiator, acceptor } from '../../../transport'
-import { Launcher } from '../../launcher'
+import { EngineFactory, SessionLauncher } from '../../../runtime'
 
-class AppLauncher extends Launcher {
+class AppLauncher extends SessionLauncher {
   public constructor () {
     super(
       'data/session/test-qf44-initiator.json',
       'data/session/test-qf44-acceptor.json')
   }
 
-  protected getAcceptor (config: IJsFixConfig): Promise<any> {
-    return acceptor(config, c => new MDServer(c))
-  }
-
-  protected getInitiator (config: IJsFixConfig): Promise<any> {
-    return initiator(config, c => new MDClient(c))
+  protected override makeFactory (config: IJsFixConfig): EngineFactory {
+    const isInitiator = this.isInitiator(config.description)
+    return {
+      makeSession: () => isInitiator ?
+        new MDClient(config) :
+        new MDServer(config)
+    } as EngineFactory
   }
 }
 
 const l = new AppLauncher()
-l.run().then(() => {
-  console.log('finished.')
-})
+l.exec()

package/src/sample/tcp/qf-md/md-client.ts

@@ -4,12 +4,15 @@ import { MsgType } from '../../../types'
 import { IJsFixLogger, IJsFixConfig } from '../../../config'
 
 import { MDFactory } from './md-factory'
+import { inject, injectable } from 'tsyringe'
+import { DITokens } from '../../../runtime'
 
+@injectable()
 export class MDClient extends AsciiSession {
   private readonly logger: IJsFixLogger
   private readonly fixLog: IJsFixLogger
 
-  constructor (public readonly config: IJsFixConfig) {
+  constructor (@inject(DITokens.IJsFixConfig) public readonly config: IJsFixConfig) {
     super(config)
     this.logReceivedMsgs = true
     this.fixLog = config.logFactory.plain(`jsfix.${config!.description!.application!.name}.txt`)