jspurefix 3.2.0 → 3.4.0

package/src/dictionary/definition/fix-version-parser.ts

@@ -0,0 +1,57 @@
+import { FixVersion } from '../fix-versions'
+
+export class FixVersionParser {
+  public static getMajor (version: FixVersion): number {
+    switch (version) {
+      case FixVersion.FIX50:
+      case FixVersion.FIX50SP1:
+      case FixVersion.FIX50SP2:
+      case FixVersion.FIXML50SP2:
+        return 5
+
+      case FixVersion.FIX40:
+      case FixVersion.FIX41:
+      case FixVersion.FIX42:
+      case FixVersion.FIX43:
+      case FixVersion.FIX44:
+        return 4
+    }
+
+    return 0
+  }
+
+  public static getMinor (version: FixVersion): number {
+    switch (version) {
+      case FixVersion.FIX50:
+      case FixVersion.FIX50SP1:
+      case FixVersion.FIX50SP2:
+      case FixVersion.FIXML50SP2:
+        return 0
+
+      case FixVersion.FIX40:
+        return 0
+      case FixVersion.FIX41:
+        return 1
+      case FixVersion.FIX42:
+        return 2
+      case FixVersion.FIX43:
+        return 3
+      case FixVersion.FIX44:
+        return 4
+    }
+
+    return 0
+  }
+
+  public static getServicePack (version: FixVersion): number {
+    switch (version) {
+      case FixVersion.FIX50SP1:
+        return 1
+      case FixVersion.FIX50SP2:
+      case FixVersion.FIXML50SP2:
+        return 2
+    }
+
+    return 0
+  }
+}

package/src/dictionary/definition/simple-field-definition.ts

@@ -68,6 +68,7 @@ export class SimpleFieldDefinition {
       this.enums = enums = new Dictionary<FieldEnum>()
       this.enumVals = enumVals = new Dictionary<boolean>()
     }
+    if (!description) description = val
     val = this.patchEnumValue(val)
     enums.add(key, new FieldEnum(key, val, description ?? ''))
     enumVals.add(val, true)

package/src/dictionary/parser/fix-repository/repository.ts

@@ -166,7 +166,7 @@ export class Repository {
     const nativeType = Repository.isNative(f)
     let type = f.Type
     const mapped = !nativeType && types.get(type)
-    if (mapped) {
+    if (f.Type !== 'Length' && mapped) {
       type = mapped.BaseType ?? type
     }
     return type

package/src/dictionary/parser/quickfix/quick-fix-xml-file-builder.ts

@@ -0,0 +1,179 @@
+import { FixDefinitions, SimpleFieldDefinition } from '../../definition'
+import { ElasticBuffer } from '../../../buffer'
+import { INumericKeyed } from '../../../collections/collection'
+import {
+  ContainedComponentField,
+  ContainedField,
+  ContainedGroupField,
+  ContainedSimpleField,
+  FieldsDispatch
+} from '../../contained'
+import { keys } from 'lodash'
+import { Dictionary } from '../../../collections'
+import { QuickFixXmlFormatter } from './quick-fix-xml-formatter'
+
+export class QuickFixXmlFileBuilder {
+  private readonly usedTags: INumericKeyed<string> = {}
+  private readonly requiredComponents: string[] = []
+  private readonly seenComponents: Dictionary<boolean> = new Dictionary<boolean>()
+  private readonly indent: number = 2
+  private readonly dispatcher: FieldsDispatch = new FieldsDispatch()
+  public readonly elasticBuffer: ElasticBuffer = new ElasticBuffer(10 * 1024)
+
+  /**
+   * given an input parsed dictionary, build a new file based on only the input set of message types
+   * providing a way of producing a fix file containing only those needed messages.
+   * @param definitions parsed definitions from existing quick fix file
+   */
+  constructor (public readonly definitions: FixDefinitions) {
+  }
+
+  /**
+   *
+   * @param msgTypes the required message types represented in the new file
+   */
+  public write (msgTypes: string[]): void {
+    const eb = this.elasticBuffer
+    if (msgTypes == null || msgTypes.length === 0) return
+    eb.reset()
+    const m0def = this.definitions.message.get(msgTypes[0])
+    // <fix major='4' type='FIX' servicepack='0' minor='4'>
+    eb.writeString(QuickFixXmlFormatter.startFix(this.definitions.getMajor(), this.definitions.getMinor(), this.definitions.getServicePack()))
+    const header = this.writeComponent(`${m0def?.name}.StandardHeader`, 'header')
+    eb.writeString(header)
+    const trailer = this.writeComponent(`${m0def?.name}.StandardTrailer`, 'trailer')
+    eb.writeString(trailer)
+    const messages = this.writeMessages(msgTypes, this.indent)
+    eb.writeString(messages)
+    const components = this.writeComponents(this.indent)
+    eb.writeString(components)
+    const fields = this.writeFieldDefinitions(this.indent)
+    eb.writeString(fields)
+    eb.writeString(QuickFixXmlFormatter.endFix())
+  }
+
+  private writeComponents (leadingIndent: number): string {
+    const eb: ElasticBuffer = new ElasticBuffer(2 * 1024)
+    eb.writeString(QuickFixXmlFormatter.startEntity('components', leadingIndent))
+    const components = this.requiredComponents
+    while (components.length > 0) {
+      const k = components.pop()
+      if (!k) continue
+      const component = this.definitions.component.get(k)
+      if (!component) continue
+      eb.writeString(QuickFixXmlFormatter.startComponent(component.name, leadingIndent + this.indent))
+      const def = this.writeFields(component.fields, leadingIndent + this.indent + this.indent)
+      eb.writeString(def)
+      eb.writeString(QuickFixXmlFormatter.endComponent(leadingIndent + this.indent))
+    }
+    eb.writeString(QuickFixXmlFormatter.endEntity('components', leadingIndent))
+    return eb.toString()
+  }
+
+  /*
+   <message name='Heartbeat' msgcat='admin' msgtype='0'>
+   <field name='TestReqID' required='N' />
+  </message>
+   */
+  private writeMessages (msgTypes: string[], leadingIndent: number): string {
+    const eb: ElasticBuffer = new ElasticBuffer(2 * 1024)
+    eb.writeString(QuickFixXmlFormatter.startEntity('messages', leadingIndent))
+    msgTypes.forEach(mt => {
+      const md = this.definitions.message.get(mt)
+      if (!md) return
+      eb.writeString(QuickFixXmlFormatter.defineMessage(md, leadingIndent + this.indent))
+      const fields = this.writeFields(md.fields.slice(1, md.fields.length - 1), leadingIndent + this.indent + this.indent)
+      eb.writeString(fields)
+      eb.writeString(QuickFixXmlFormatter.endEntity('message', leadingIndent + this.indent))
+    })
+    eb.writeString(QuickFixXmlFormatter.endEntity('messages', leadingIndent))
+    return eb.toString()
+  }
+
+  private writeFieldDefinitions (leadingIndent: number): string {
+    const eb: ElasticBuffer = new ElasticBuffer(2 * 1024)
+
+    const tags = keys(this.usedTags).map(s => parseInt(s))
+    tags.sort(function (a, b) {
+      return a - b
+    })
+    eb.writeString(QuickFixXmlFormatter.startEntity('fields', leadingIndent))
+    tags.forEach(t => {
+      const sf = this.definitions.tagToSimple[t]
+      if (!sf) return
+      //   <field number='1' name='Account' type='STRING' />
+      eb.writeString(QuickFixXmlFormatter.defineField(sf, leadingIndent + this.indent))
+      if (sf.isEnum()) {
+        const en = this.writeEnumDefinition(sf, leadingIndent + this.indent + this.indent)
+        eb.writeString(en)
+        eb.writeString(QuickFixXmlFormatter.endEntity('field', leadingIndent + this.indent))
+      }
+    })
+    eb.writeString(QuickFixXmlFormatter.endEntity('fields', leadingIndent))
+    return eb.toString()
+  }
+
+  /*
+   <value enum='B' description='BUY' />
+   <value enum='S' description='SELL' />
+   <value enum='X' description='CROSS' />
+   <value enum='T' description='TRADE' />
+   */
+  private writeEnumDefinition (sf: SimpleFieldDefinition, leadingIndent: number): string {
+    const eb: ElasticBuffer = new ElasticBuffer(2 * 1024)
+    const keys = sf.enums.keys()
+    keys.sort()
+    keys.forEach(k => {
+      eb.writeString(QuickFixXmlFormatter.addEnum(sf.enums.get(k), leadingIndent))
+    })
+    return eb.toString()
+  }
+
+  private writeComponent (name: string, destName: string): string {
+    const eb: ElasticBuffer = new ElasticBuffer(2 * 1024)
+    const set = this.definitions.getSet(name)
+    if (set == null) return ''
+    eb.writeString(QuickFixXmlFormatter.startEntity(destName, this.indent))
+    eb.writeString(this.writeFields(set.fields, this.indent + this.indent))
+    eb.writeString(QuickFixXmlFormatter.endEntity(destName, this.indent))
+    return eb.toString()
+  }
+
+  private writeSimpleField (sf: ContainedSimpleField, eb: ElasticBuffer, leadingIndent: number): void {
+    eb.writeString(QuickFixXmlFormatter.addField(sf, leadingIndent))
+    this.usedTags[sf.definition.tag] = sf.name
+  }
+
+  private writeComponentField (cf: ContainedComponentField, eb: ElasticBuffer, leadingIndent: number): void {
+    eb.writeString(QuickFixXmlFormatter.addComponent(cf, leadingIndent))
+    if (!this.seenComponents.containsKey(cf.name)) {
+      this.seenComponents.add(cf.name, true)
+      this.requiredComponents.push(cf.name)
+    }
+  }
+
+  private writeGroupField (gf: ContainedGroupField, eb: ElasticBuffer, leadingIndent: number): void {
+    this.usedTags[gf.definition.noOfField?.tag ?? 0] = gf.name
+    eb.writeString(QuickFixXmlFormatter.addGroup(gf, leadingIndent))
+    const groupDef = this.writeFields(gf.definition.fields, leadingIndent + this.indent)
+    eb.writeString(groupDef)
+    eb.writeString(QuickFixXmlFormatter.endGroup(leadingIndent))
+  }
+
+  /*
+  <trailer>
+    <field name='SignatureLength' required='N' />
+    <field name='Signature' required='N' />
+    <field name='CheckSum' required='Y' />
+ </trailer>
+   */
+  private writeFields (fields: ContainedField[], leadingIndent: number): string {
+    const eb: ElasticBuffer = new ElasticBuffer(2 * 1024)
+    this.dispatcher.dispatchFields(fields, {
+      simple: (sf: ContainedSimpleField) => { this.writeSimpleField(sf, eb, leadingIndent) },
+      component: (cf: ContainedComponentField) => { this.writeComponentField(cf, eb, leadingIndent) },
+      group: (gf: ContainedGroupField) => { this.writeGroupField(gf, eb, leadingIndent) }
+    })
+    return eb.toString()
+  }
+}

package/src/dictionary/parser/quickfix/quick-fix-xml-file-parser.ts

@@ -15,12 +15,13 @@ import { FixDefinitionSource } from '../../fix-definition-source'
 import { VersionUtil } from '../../version-util'
 import { ParseState } from './parse-state'
 import { ParseProgress } from './parse-progress'
+import { MakeDuplex } from '../../../transport'
 
 export class QuickFixXmlFileParser extends FixParser {
   private readonly singlePass = promisify(QuickFixXmlFileParser.subscribe)
   private readonly state: ParseProgress = new ParseProgress()
 
-  constructor (public readonly xmlPath: string, public getLogger: GetJsFixLogger) {
+  constructor (public readonly make: MakeDuplex, public getLogger: GetJsFixLogger) {
     super()
   }
 
@@ -56,8 +57,9 @@ export class QuickFixXmlFileParser extends FixParser {
           switch (progress.parseState) {
             case ParseState.FieldDefinitions: {
               const major = saxNode.attributes.major
-              const minor = saxNode.attributes.major
-              const description: string = `FIX.${major}.${minor}`
+              const minor = saxNode.attributes.minor
+              const servicepack = saxNode.attributes.servicepack
+              const description: string = (major !== '5' || !servicepack) ? `FIX.${major}.${minor}` : `FIX.${major}.${minor}SP${servicepack}`
               progress.definitions = new FixDefinitions(FixDefinitionSource.QuickFix, VersionUtil.resolve(description))
               break
             }
@@ -168,6 +170,7 @@ export class QuickFixXmlFileParser extends FixParser {
   public async parse (): Promise<FixDefinitions> {
     return await new Promise<FixDefinitions>(async (resolve, reject) => {
       try {
+        this.state.next()
         while (this.state.parseState !== ParseState.End) {
           this.state.reset()
           await this.onePass()
@@ -183,7 +186,8 @@ export class QuickFixXmlFileParser extends FixParser {
   }
 
   private async onePass (): Promise<FixDefinitions | undefined | null> {
-    const pass: fs.ReadStream = fs.createReadStream(this.xmlPath)
+    const duplex = this.make()
+    const pass = duplex.readable
     const saxStream: SAXStream = require('sax').createStream(true, {})
     pass.pipe(saxStream)
     return await this.singlePass(this.state, saxStream)

package/src/dictionary/parser/quickfix/quick-fix-xml-formatter.ts

@@ -0,0 +1,67 @@
+import { EOL as newLine } from 'os'
+import { ContainedComponentField, ContainedGroupField, ContainedSimpleField } from '../../contained'
+import { FieldEnum } from '../../field-enum'
+import { MessageDefinition, SimpleFieldDefinition } from '../../definition'
+
+export class QuickFixXmlFormatter {
+  private static isRequired (r: boolean): string {
+    return r ? 'Y' : 'N'
+  }
+
+  private static whitespace (n: number): string {
+    return ' '.repeat(n)
+  }
+
+  public static startFix (major: number, minor: number, servicePack: number): string {
+    return `<fix major='${major}' type='FIX' servicepack='${servicePack}' minor='${minor}'>${newLine}`
+  }
+
+  public static endFix (): string {
+    return `</fix>${newLine}`
+  }
+
+  public static startEntity (name: string, ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)}<${name}>${newLine}`
+  }
+
+  public static endEntity (name: string, ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)}</${name}>${newLine}`
+  }
+
+  public static startComponent (name: string, ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)}<component name='${name}'>${newLine}`
+  }
+
+  public static endComponent (ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)}</component>${newLine}`
+  }
+
+  public static addField (sf: ContainedSimpleField, ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)} <!-- ${sf.definition.tag} ${sf.definition.type} -->${newLine}${QuickFixXmlFormatter.whitespace(ws)}<field name='${sf.name}' required='${QuickFixXmlFormatter.isRequired(sf.required)}'/>${newLine}`
+  }
+
+  public static addComponent (cf: ContainedComponentField, ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)}<component name='${cf.name}' required='${QuickFixXmlFormatter.isRequired(cf.required)}'/>${newLine}`
+  }
+
+  public static addGroup (gf: ContainedGroupField, ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)} <!-- ${gf.definition.noOfField?.tag ?? -1} ${gf.definition.noOfField?.type} -->${newLine}${QuickFixXmlFormatter.whitespace(ws)}<group name='${gf.name}' required='${QuickFixXmlFormatter.isRequired(gf.required)}'>${newLine}`
+  }
+
+  public static endGroup (ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)}</group>${newLine}`
+  }
+
+  public static addEnum (fe: (FieldEnum | null), ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)}<value enum='${fe?.key}' description='${fe?.description ?? fe?.val}'/>${newLine}`
+  }
+
+  public static defineField (sf: SimpleFieldDefinition, ws: number): string {
+    const term = sf.isEnum() ? '>' : '/>'
+    return (`${QuickFixXmlFormatter.whitespace(ws)}<field number='${sf.tag}' name='${sf.name}' type='${sf.type}'${term}${newLine}`)
+  }
+
+  public static defineMessage (def: MessageDefinition, ws: number): string {
+    return `${QuickFixXmlFormatter.whitespace(ws)}<message name='${def.name}' msgcat='${def.category}' msgtype='${def.msgType}'>${newLine}`
+  }
+}

package/src/dictionary/version-util.ts

@@ -2,26 +2,15 @@ import { FixVersion } from './fix-versions'
 
 export abstract class VersionUtil {
   public static resolve (description: string): FixVersion {
-    let version: FixVersion = FixVersion.Unknown
-    if (description.includes('FIX.4.0')) {
-      version = FixVersion.FIX40
-    } else if (description.includes('FIX.4.1')) {
-      version = FixVersion.FIX41
-    } else if (description.includes('FIX.4.2')) {
-      version = FixVersion.FIX42
-    } else if (description.includes('FIX.4.3')) {
-      version = FixVersion.FIX43
-    } else if (description.includes('FIX.4.4')) {
-      version = FixVersion.FIX44
-    } else if (description.includes('FIX.5.0')) {
-      version = FixVersion.FIX50
-    } else if (description.includes('FIX.5.0SP1')) {
-      version = FixVersion.FIX50SP1
-    } else if (description.includes('FIX.5.0SP2')) {
-      version = FixVersion.FIX50SP2
-    } else if (description.includes('FIXML.5.0SP2')) {
-      version = FixVersion.FIXML50SP2
-    }
-    return version
+    if (description === 'FIX.4.0') return FixVersion.FIX40
+    if (description === 'FIX.4.1') return FixVersion.FIX41
+    if (description === 'FIX.4.2') return FixVersion.FIX42
+    if (description === 'FIX.4.3') return FixVersion.FIX43
+    if (description === 'FIX.4.4') return FixVersion.FIX44
+    if (description === 'FIX.5.0') return FixVersion.FIX50
+    if (description === 'FIX.5.0SP1') return FixVersion.FIX50SP1
+    if (description === 'FIX.5.0SP2') return FixVersion.FIX50SP2
+    if (description === 'FIXML.5.0SP2') return FixVersion.FIXML50SP2
+    return FixVersion.Unknown
   }
 }