jspurefix 1.1.2 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jspurefix",
-  "version": "1.1.2",
+  "version": "1.4.1",
   "description": "pure node js fix engine",
   "keywords": [
     "typescript",
@@ -37,7 +37,9 @@
     "repo44-bench-sd": "cd dist && node jsfix-cmd --dict=repo44 --fix=data/examples/FIX.4.4/repo/security-definition/fix.txt --benchmark --delimiter=\"|\" --repeats=150000",
     "qf-bench-lo": "cd dist && node jsfix-cmd --session=data/session/test-initiator.json --fix=data/examples/FIX.4.4/quickfix/logon/fix.txt --benchmark --delimiter=\"|\" --repeats=250000",
     "fixml": "cd dist && node jsfix-cmd --dict=repofixml",
-    "tcp-tc": "cd dist/sample/tcp/trade_capture && node app",
+    "tcp-qf-md": "cd dist/sample/tcp/qf-md && node app",
+    "tcp-tls-tc": "cd dist/sample/tcp/tls-trade-capture && node app",
+    "tcp-tc": "cd dist/sample/tcp/trade-capture && node app",
     "tcp-sk": "cd dist/sample/tcp/skeleton && node app",
     "http-oms": "cd dist/sample/http/oms && node app",
     "repo40-compile": "cd dist && node jsfix-cmd \"--dict=repo40\" \"--compile\"",
@@ -59,38 +61,40 @@
   "dependencies": {
     "align-text": "^1.0.2",
     "express": "^4.17.1",
-    "lodash": "^4.17.20",
+    "lodash": "^4.17.21",
     "log4js": "^6.3.0",
-    "mathjs": "^7.5.1",
+    "mathjs": "^10.0.0",
     "minimist": "^1.2.5",
     "moment": "^2.29.1",
     "node-fs-extra": "^0.8.2",
-    "request-promise": "^4.2.6",
+    "request": "^2.88.2",
+    "request-promise-native": "^1.0.9",
     "sax": "^1.2.4",
-    "uuid": "^3.4.0",
+    "uuid": "^8.3.2",
     "winston": "^3.3.3",
     "word-wrap": "^1.2.3",
     "xml2js": "^0.4.23",
-    "xmlbuilder": "^10.1.1",
+    "xmlbuilder": "^15.1.1",
     "yauzl": "^2.10.0"
   },
   "devDependencies": {
-    "@types/express": "^4.17.9",
-    "@types/jest": "^26.0.15",
-    "@types/lodash": "^4.14.168",
-    "@types/mathjs": "^6.0.7",
-    "@types/minimist": "^1.2.1",
-    "@types/node": "^14.14.22",
-    "@types/request-promise": "^4.1.46",
-    "@types/sax": "^1.2.1",
-    "@types/uuid": "^3.4.7",
+    "@types/express": "^4.17.13",
+    "@types/express-serve-static-core": "^4.17.26",
+    "@types/jest": "^27.0.3",
+    "@types/lodash": "^4.14.177",
+    "@types/mathjs": "^9.4.1",
+    "@types/minimist": "^1.2.2",
+    "@types/node": "^16.11.11",
+    "@types/request-promise-native": "^1.0.18",
+    "@types/sax": "^1.2.3",
+    "@types/uuid": "^8.3.3",
     "@types/winston": "^2.4.4",
-    "@types/xmlbuilder": "0.0.34",
-    "jest": "^26.6.3",
-    "standard": "^16.0.3",
-    "ts-jest": "^26.4.4",
+    "@types/xmlbuilder": "0.0.35",
+    "jest": "^27.4.3",
+    "standard": "^16.0.4",
+    "ts-jest": "^27.0.7",
     "tslint": "^6.1.3",
     "tslint-config-standard": "^9.0.0",
-    "typescript": "^4.1.3"
+    "typescript": "^4.5.2"
   }
 }

package/script/build.sh

@@ -1,3 +1,4 @@
+#!/bin/sh
 npm install
 npm run unzip-repo
 ./node_modules/.bin/tsc --version

package/src/buffer/ascii/ascii-encoder.ts

@@ -1,5 +1,8 @@
 import { ILooseObject } from '../../collections/collection'
-import { ContainedGroupField, ContainedSimpleField, ContainedFieldSet, ContainedField, ContainedFieldType, ContainedComponentField, SimpleFieldDefinition, FixDefinitions, dispatchFields } from '../../dictionary'
+import { ContainedGroupField, ContainedSimpleField,
+  ContainedFieldSet, ContainedField,
+  ContainedComponentField, SimpleFieldDefinition,
+  FixDefinitions, dispatchFields } from '../../dictionary'
 import { MsgEncoder } from '../msg-encoder'
 import { ElasticBuffer } from '../elastic-buffer'
 import { TimeFormatter } from './time-formatter'
@@ -11,50 +14,64 @@ export class AsciiEncoder extends MsgEncoder {
 
   public bodyLengthPos: number
   public msgTypePos: number
+  public tags: Tags
+  public checkGroups: boolean = true
 
   constructor (public readonly buffer: ElasticBuffer,
                public readonly definitions: FixDefinitions,
                public readonly timeFormatter: ITimeFormatter = new TimeFormatter(buffer),
-               public readonly delimiter: number = AsciiChars.Soh) {
+               public readonly delimiter: number = AsciiChars.Soh,
+               public readonly logDelimiter: number = AsciiChars.Pipe) {
     super(definitions)
+    this.tags = new Tags(definitions)
   }
 
-  private static checkGroupInstanceHasDelimiter (gf: ContainedGroupField, instance: ILooseObject): boolean {
-    const delimiterField: ContainedSimpleField = gf.definition.firstSimple
-    if (!delimiterField) {
-      throw new Error(`group definition has delimiter field ${delimiterField.definition.name}`)
-    }
-    // may have a group represented by a component where first simple field is further down.
-    while (instance != null) {
-      if (instance[delimiterField.definition.name] != null) {
-        return true
-      }
-      const first = gf.definition.fields[0]
-      switch (first.type) {
-        case ContainedFieldType.Component: {
-          const cf: ContainedComponentField = first as ContainedComponentField
-          instance = instance[cf.definition.name]
-          break
-        }
-        default:
-          instance = null
+  public trim (): Buffer {
+    const b = this.buffer.copy()
+    const delimiter = this.delimiter
+    const logDelimiter = this.logDelimiter
+    const tags = this.tags
+    if (delimiter !== logDelimiter) {
+      for (let p = 0; p < tags.nextTagPos; ++p) {
+        const tagPos = tags.tagPos[p]
+        b.writeUInt8(delimiter, tagPos.start + tagPos.len)
       }
     }
+
+    return b
+  }
+
+  // only reset tags after entire message is encoded - <hdr>body<trl>
+
+  public reset (): void {
+    this.buffer.reset()
+    this.tags.reset()
   }
 
   public encodeSet (objectToEncode: ILooseObject, set: ContainedFieldSet): void {
+    const summary: AsciiEncodeSetSummary = new AsciiEncodeSetSummary()
+    this.encodeObject(objectToEncode, set, summary)
+  }
+
+  private encodeObject (objectToEncode: ILooseObject, set: ContainedFieldSet, state: AsciiEncodeSetSummary): void {
     const fields: ContainedField[] = this.getFields(set, objectToEncode)
     dispatchFields(fields, {
       simple: (sf: ContainedSimpleField) => {
         const val: any = objectToEncode[sf.name]
-        if (val != null) {
+        // Empty strings are omitted as they result in empty values for tags, which are considered malformed.
+        if (val != null && val !== '') {
+          if (state.count === 0) {
+            state.firstSimple = sf
+          }
+          state.lastSimple = sf
+          state.count++
           this.encodeSimple(objectToEncode, set, sf, val)
         }
       },
       component: (cf: ContainedComponentField) => {
         const instance: ILooseObject = objectToEncode[cf.definition.name]
         if (instance) {
-          this.encodeSet(instance, cf.definition)
+          this.encodeObject(instance, cf.definition, state)
         }
       },
       group: (gf: ContainedGroupField) => {
@@ -80,23 +97,29 @@ export class AsciiEncoder extends MsgEncoder {
   private encodeInstances (o: ILooseObject, gf: ContainedGroupField): void {
     const noOfField: SimpleFieldDefinition = gf.definition.noOfField
     const instances: ILooseObject[] = o[gf.name] || o[noOfField.name]
+
     const buffer = this.buffer
     if (!Array.isArray(instances)) {
       throw new Error(`expected array instance for group ${noOfField.name}`)
     }
     if (instances) {
+      const validator = new GroupValidator(gf)
+      const test: AsciiEncodeSetSummary = validator.test
+
       // a repeated group has number of instances at the start of group
       this.WriteTagEquals(noOfField.tag)
+      const posValBegin = buffer.getPos()
       buffer.writeWholeNumber(instances.length)
-      buffer.writeChar(this.delimiter)
-      instances.forEach((i: ILooseObject) => {
-        if (AsciiEncoder.checkGroupInstanceHasDelimiter(gf, i)) {
-          this.encodeSet(i, gf.definition)
-        } else {
-          const delimiter: ContainedSimpleField = gf.definition.firstSimple
-          throw new Error(`group instance with no delimiter field ${delimiter.definition.name}`)
+      this.writeDelimiter(posValBegin, noOfField.tag)
+      for (let field = 0; field < instances.length; ++field) {
+        const instance: ILooseObject = instances[field]
+        test.reset()
+        const summary = validator.getSummary(field)
+        this.encodeObject(instance, gf.definition, summary)
+        if (this.checkGroups) {
+          validator.assertInstanceValid(field)
         }
-      })
+      }
     }
   }
 
@@ -106,13 +129,21 @@ export class AsciiEncoder extends MsgEncoder {
     buffer.writeChar(AsciiChars.Equal)
   }
 
+  private writeDelimiter (posValBegin: number, tag: number): void {
+    const delimiter = this.logDelimiter
+    const buffer = this.buffer
+    this.tags.store(posValBegin, buffer.getPos() - posValBegin, tag)
+    buffer.writeChar(delimiter)
+  }
+
   private encodeSimple (o: ILooseObject, set: ContainedFieldSet, sf: ContainedSimpleField, val: any): void {
     const definition = sf.definition
     const tag: number = definition.tag
     const buffer = this.buffer
-    const delimiter = this.delimiter
+    const delimiter = this.logDelimiter
     const tf = this.timeFormatter
     const pos = buffer.getPos()
+    let posValBegin = 0
 
     let tagType: TagType
     if (typeof val === 'string') {
@@ -141,6 +172,7 @@ export class AsciiEncoder extends MsgEncoder {
 
       default: {
         this.WriteTagEquals(tag)
+        posValBegin = buffer.getPos()
         break
       }
     }
@@ -197,6 +229,7 @@ export class AsciiEncoder extends MsgEncoder {
         }
         this.WriteTagEquals(tag)
         buffer.writeBuffer(b)
+        posValBegin = buffer.getPos()
         break
       }
 
@@ -206,7 +239,7 @@ export class AsciiEncoder extends MsgEncoder {
       }
     }
 
-    buffer.writeChar(delimiter)
+    this.writeDelimiter(posValBegin, tag)
 
     switch (tag) {
       case Tags.BodyLengthTag:
@@ -219,3 +252,47 @@ export class AsciiEncoder extends MsgEncoder {
     }
   }
 }
+
+class GroupValidator {
+  constructor (public readonly gf: ContainedGroupField,
+    public readonly first: AsciiEncodeSetSummary = new AsciiEncodeSetSummary(),
+    public readonly test: AsciiEncodeSetSummary = new AsciiEncodeSetSummary()) {
+  }
+
+  getSummary (field: number) {
+    return field === 0 ? this.first : this.test
+  }
+
+  assertInstanceValid (field: number): void {
+    const first = this.first
+    const test = this.test
+    if (field === 0 && first.empty()) {
+      throw new Error(`first group instance has no delimeter present ${this.gf.name}`)
+    }
+    if (field > 0 && test.empty()) {
+      throw new Error(`group instance [${field}] has no delimeter present ${this.gf.name}`)
+    }
+    if (field > 0) {
+      const firstTag = first.firstSimple.definition.tag
+      const tag = test.firstSimple.definition.tag
+      if (firstTag !== tag) {
+        throw new Error(`group instance [${field}] inconsisent delimeter ${tag} expected tag ${firstTag}`)
+      }
+    }
+  }
+}
+
+class AsciiEncodeSetSummary {
+  constructor (public firstSimple: ContainedSimpleField = null,
+    public lastSimple: ContainedSimpleField = null,
+    public count: number = 0) {
+  }
+  public reset (): void {
+    this.firstSimple = null
+    this.lastSimple = null
+    this.count = 0
+  }
+  public empty (): boolean {
+    return this.firstSimple === null || this.count === 0
+  }
+}

package/src/buffer/ascii/ascii-parser.ts

@@ -33,7 +33,9 @@ export class AsciiParser extends MsgParser {
     this.state = new AsciiParserState(this.receivingBuffer)
     this.state.locations = new Tags(definitions, maxMessageLen / 10)
     this.state.beginMessage()
-    this.subscribe()
+    if (readStream !== null) {
+      this.subscribe()
+    }
   }
 
   private subscribe (): void {
@@ -77,6 +79,11 @@ export class AsciiParser extends MsgParser {
     state.beginMessage()
   }
 
+  public parseText (text: string) {
+    const buff = Buffer.from(text)
+    this.parse(buff, buff.length)
+  }
+
   private parse (readBuffer: Buffer, end: number): void {
     const state = this.state
     const eq: number = AsciiChars.Eq

package/src/buffer/ascii/ascii-segment-parser.ts

@@ -1,61 +1,57 @@
-import { ContainedComponentField, ContainedFieldType, ContainedGroupField, ContainedSimpleField, ComponentFieldDefinition, FixDefinitions, MessageDefinition } from '../..'
+import {
+  ContainedComponentField,
+  ContainedFieldType,
+  ContainedGroupField,
+  ContainedSimpleField,
+  FixDefinitions,
+  MessageDefinition
+} from '../..'
 import { SegmentDescription, SegmentType } from '../segment-description'
 import { Structure } from '../structure'
 import { Tags } from '../tags'
-import { MsgTag } from '../../types'
 
-export class AsciiSegmentParser {
+// this takes linear time i.e. it constantly makes forward progress
+// one tag at a time
 
-  private readonly headerDefinition: ComponentFieldDefinition
-  private readonly trailerDefinition: ComponentFieldDefinition
+export class AsciiSegmentParser {
 
   constructor (public readonly definitions: FixDefinitions) {
-    this.headerDefinition = definitions.component.get('header')
-    this.trailerDefinition = definitions.component.get('trailer')
   }
 
   public parse (msgType: string, tags: Tags, last: number): Structure {
+    // completed segments in that they are fully parsed
     const segments: SegmentDescription[] = []
-    const tr = this.trailerDefinition
-    const hd = this.headerDefinition
     const msgDefinition: MessageDefinition = this.definitions.message.get(msgType)
     if (!msgDefinition) {
       return null
     }
+    // in process of being discovered and may have any amount of depth
+    // i.e. a component containing a repeated group of components
+    // with sub-groups of components
     const structureStack: SegmentDescription[] = []
     let currentTagPosition: number = 0
-    // let currentContainedField: ContainedField;
     let peek: SegmentDescription
 
-    function init (): void {
-      const firstTag: number = tags.tagPos[0].tag
-      structureStack[structureStack.length] = new SegmentDescription(tr.name, tags.tagPos[last].tag, tr,
-        currentTagPosition, structureStack.length, SegmentType.Component)
-      structureStack[structureStack.length] = new SegmentDescription(msgDefinition.name, firstTag, msgDefinition,
-        currentTagPosition, structureStack.length, SegmentType.Msg)
-      structureStack[structureStack.length] = new SegmentDescription(hd.name, firstTag, hd,
-        currentTagPosition, structureStack.length, SegmentType.Component)
-    }
-
     // having finished one segments keep unwinding until tag matches further up stack
     function unwind (tag: number): void {
       while (structureStack.length > 1) {
         const done: SegmentDescription = structureStack.pop()
         done.end(segments.length, currentTagPosition - 1, tags.tagPos[currentTagPosition - 1].tag)
-        segments[segments.length] = done
+        segments.push(done)
         peek = structureStack[structureStack.length - 1]
         if (peek.set.containedTag[tag]) {
           // unwound to point this tag lives in this set.
           break
         }
-        if (peek.type === SegmentType.Msg && !tr.localTag[tag]) {
+        if (peek.type === SegmentType.Msg) {
           // this is unknown tag and it is not part of trailer so raise unknown
           break
         }
       }
     }
 
-    function examine (tag: number): void {
+    function examine (tag: number): SegmentDescription {
+      let structure: SegmentDescription = null
       switch (peek.currentField.type) {
 
         case ContainedFieldType.Simple: {
@@ -68,16 +64,15 @@ export class AsciiSegmentParser {
         // moving deeper into structure, start a new context
         case ContainedFieldType.Component: {
           const cf: ContainedComponentField = peek.currentField as ContainedComponentField
-          structureStack[structureStack.length] = new SegmentDescription(cf.name, tag, cf.definition,
-                        currentTagPosition, structureStack.length - 1, SegmentType.Component)
+          structure = new SegmentDescription(cf.name, tag, cf.definition,
+                        currentTagPosition, structureStack.length, SegmentType.Component)
           break
         }
-
+        // for a group also need to know where all delimiters are positioned
         case ContainedFieldType.Group: {
           const gf: ContainedComponentField = peek.currentField as ContainedGroupField
-          const structure: SegmentDescription = new SegmentDescription(gf.name, tag, gf.definition,
-                        currentTagPosition, structureStack.length - 1, SegmentType.Group)
-          structureStack[structureStack.length] = structure
+          structure = new SegmentDescription(gf.name, tag, gf.definition,
+                        currentTagPosition, structureStack.length, SegmentType.Group)
           currentTagPosition = currentTagPosition + 1
           structure.startGroup(tags.tagPos[currentTagPosition].tag)
           break
@@ -86,6 +81,8 @@ export class AsciiSegmentParser {
         default:
           throw new Error(`unknown tag type ${tag}`)
       }
+
+      return structure
     }
 
     function groupDelimiter (tag: number): boolean {
@@ -104,7 +101,7 @@ export class AsciiSegmentParser {
       const gap = new SegmentDescription('.undefined', tag, peek.set,
         currentTagPosition, structureStack.length, SegmentType.Gap)
       gap.end(segments.length, currentTagPosition, tag)
-      segments[segments.length] = gap
+      segments.push(gap)
       currentTagPosition++
     }
 
@@ -114,7 +111,8 @@ export class AsciiSegmentParser {
         peek = structureStack[structureStack.length - 1]
         peek.setCurrentField(tag)
         if (!peek.set.containedTag[tag] || groupDelimiter(tag)) {
-          const unknown = peek.type === SegmentType.Msg && tag !== MsgTag.CheckSum
+          // unravelled all way back to root hence this is not recognised
+          const unknown = peek.type === SegmentType.Msg
           if (unknown) {
             gap(tag)
           } else if (structureStack.length > 1) {
@@ -123,27 +121,35 @@ export class AsciiSegmentParser {
           }
           continue
         }
-        examine(tag)
+        const structure = examine(tag)
+        if (structure) {
+          structureStack.push(structure)
+        }
       }
     }
 
     function clean (): void {
+      // any remainder components can be closed.
       while (structureStack.length > 0) {
         const done: SegmentDescription = structureStack.pop()
         done.end(segments.length, currentTagPosition - 1, tags.tagPos[currentTagPosition - 1].tag)
         segments[segments.length] = done
       }
-      const msg: SegmentDescription = segments[segments.length - 2]
-      const trl: SegmentDescription = segments[segments.length - 1]
-      msg.startTag = tags.tagPos[msg.startPosition].tag
-      trl.startPosition = msg.endPosition + 1
-      msg.endPosition = trl.endPosition
+      // logically reverse the trailer and message so trailer is last in list.
+      const m1 = segments.length - 1
+      const m2 = segments.length - 2
+      const tmp = segments[m1]
+      segments[m1] = segments[m2]
+      segments[m2] = tmp
     }
 
-    init()
+    const msgStructure = new SegmentDescription(msgDefinition.name, tags.tagPos[0].tag, msgDefinition,
+      currentTagPosition, structureStack.length, SegmentType.Msg)
+    structureStack.push(msgStructure)
     discover()
     clean()
 
+    // now know where all components and groups are positioned within message
     return new Structure(tags, segments)
   }
 }

package/src/buffer/ascii/ascii-view.ts

@@ -8,6 +8,7 @@ import { ITimeFormatter } from './itime-formatter'
 import { TimeFormatter } from './time-formatter'
 import { TagPos } from '../tag-pos'
 import { MsgTag } from '../../types'
+import { FixMsgStoreRecord, IFixMsgStoreRecord } from '../../store'
 
 export class AsciiView extends MsgView {
   private readonly timeFormatter: ITimeFormatter = new TimeFormatter(this.buffer)
@@ -34,6 +35,10 @@ export class AsciiView extends MsgView {
     return new AsciiView(segment, buffer, null, this.ptr, delimiter, writeDelimiter)
   }
 
+  public toMsgStoreRecord (): IFixMsgStoreRecord {
+    return new FixMsgStoreRecord(this.getString(MsgTag.MsgType), this.getTyped(MsgTag.SendingTime), this.getTyped(MsgTag.MsgSeqNum), this.toObject())
+  }
+
   public checksum (): number {
     const t = this.getPosition(MsgTag.CheckSum)
     const structure = this.structure

package/src/buffer/ascii/time-formatter.ts

@@ -23,13 +23,13 @@ export class TimeFormatter implements ITimeFormatter {
   public writeUtcTimestamp (v: Date): void {
     this.writeUtcDate(v)
     this.buffer.writeChar(AsciiChars.Hyphen)
-    this.writeUtcTime(v as Date)
+    this.writeUtcTime(v)
   }
 
   public writeLocalTimestamp (v: Date): void {
     this.writeLocalDate(v)
     this.buffer.writeChar(AsciiChars.Hyphen)
-    this.writeLocalTime(v as Date)
+    this.writeLocalTime(v)
   }
 
   public writeUtcTime (v: Date): void {

package/src/buffer/ascii-chars.ts

@@ -8,6 +8,7 @@ export abstract class AsciiChars {
   public static readonly Colon: number = ':'.charCodeAt(0)
   public static readonly Hyphen: number = '-'.charCodeAt(0)
   public static readonly Pipe: number = '|'.charCodeAt(0)
+  public static readonly Carat: number = '^'.charCodeAt(0)
   public static readonly N: number = 'N'.charCodeAt(0)
   public static readonly Y: number = 'Y'.charCodeAt(0)
   public static readonly Zero: number = '0'.charCodeAt(0)

package/src/buffer/elastic-buffer.ts

@@ -37,6 +37,14 @@ export class ElasticBuffer {
     return this.ptr
   }
 
+  public setPos (ptr: number): number {
+    const r = this.ptr
+    if (ptr >= 0 && ptr < this.size) {
+      this.ptr = ptr
+    }
+    return r
+  }
+
   public get (pos: number): number {
     return this.buffer[pos]
   }
@@ -140,6 +148,7 @@ export class ElasticBuffer {
   public clone (): ElasticBuffer {
     const cloned = new ElasticBuffer(this.ptr)
     this.buffer.copy(cloned.buffer, 0, 0, this.ptr)
+    cloned.setPos(this.ptr)
     return cloned
   }
 

package/src/buffer/encode-proxy.ts

@@ -7,7 +7,7 @@ export class EncodeProxy {
   }
 
   private static SimpleFieldCheck (field: ContainedSimpleField, val: any): void {
-    const sf: ContainedSimpleField = field as ContainedSimpleField
+    const sf: ContainedSimpleField = field
     const definition: SimpleFieldDefinition = sf.definition
     if (definition.isEnum()) {
       const resolved: boolean = definition.containsEnum(val)
@@ -73,7 +73,7 @@ export class EncodeProxy {
     if (!isComplex) {
       throw new Error(`type ${field.name} is a component but is given type "${typeof val}"`)
     }
-    const cf: ContainedComponentField = field as ContainedComponentField
+    const cf: ContainedComponentField = field
     return EncodeProxy.checkProperties(new Proxy({}, EncodeProxy.handler(cf.definition)), val)
   }
 

package/src/buffer/fixml/fixml-encoder.ts

@@ -212,4 +212,12 @@ export class FixmlEncoder extends MsgEncoder {
       this.toXml(instance, cf.name, def, depth + 1)
     }
   }
+
+  reset (): void {
+    this.buffer.reset()
+  }
+
+  trim (): Buffer {
+    return this.buffer.copy()
+  }
 }

package/src/buffer/fixml/fixml-view.ts

@@ -5,6 +5,7 @@ import { SegmentDescription } from '../segment-description'
 import { TagType } from '../tags'
 import { AsciiChars } from '../ascii-chars'
 import * as moment from 'moment'
+import { IFixMsgStoreRecord } from '../../store'
 
 export class FixmlView extends MsgView {
 
@@ -108,4 +109,8 @@ export class FixmlView extends MsgView {
     }
     return this.stringAtPosition(position)
   }
+
+  public toMsgStoreRecord (): IFixMsgStoreRecord {
+    return null
+  }
 }

package/src/buffer/msg-encoder.ts

@@ -15,5 +15,7 @@ export abstract class MsgEncoder extends events.EventEmitter {
     this.encodeSet(o, set)
   }
 
+  public abstract reset (): void
+  public abstract trim (): Buffer
   public abstract encodeSet (o: ILooseObject, set: ContainedFieldSet): void
 }

package/src/buffer/msg-view.ts

@@ -6,6 +6,7 @@ import { Tags } from './tags'
 import { ContainedGroupField, ContainedComponentField, ContainedField, ContainedFieldSet, ContainedSimpleField, SimpleFieldDefinition, GroupFieldDefinition, ITypeDispatcher, reduceSet, ContainedSetType } from '../dictionary'
 import { ILooseObject } from '../collections/collection'
 import { ElasticBuffer } from './elastic-buffer'
+import { IFixMsgStoreRecord } from '../store'
 
 export abstract class MsgView {
   protected sortedTagPosForwards: TagPos[]
@@ -414,4 +415,6 @@ export abstract class MsgView {
 
     return buffer.toString()
   }
+
+  abstract toMsgStoreRecord (): IFixMsgStoreRecord
 }

package/src/buffer/tags.ts

@@ -1,6 +1,6 @@
 import { FixDefinitions, ContainedSimpleField } from '../dictionary'
 import { TagPos } from './tag-pos'
-import { MsgTag } from '../types/enum'
+import { MsgTag } from '../types'
 
 export enum TagType {
     String = 1,