hl7v2 0.14.0 → 1.1.0

package/README.md

@@ -1,18 +1,13 @@
-  
+# HL7v2
+
 [![NPM Version][npm-image]][npm-url]
 [![NPM Downloads][downloads-image]][downloads-url]
-[![Build Status][travis-image]][travis-url]
+[![CI Tests][ci-test-image]][ci-test-url]
 [![Test Coverage][coveralls-image]][coveralls-url]
 
-[![Dependencies][dependencies-image]][dependencies-url]
-[![DevDependencies][devdependencies-image]][devdependencies-url]
-[![Package Quality][quality-image]][quality-url]
-
-
 ## About
 
-HL7 v2 parser, serializer, validator and tcp client/server for NodeJS
-
+HL7 v2.x parser, serializer and validator
 
 ## Installation
 
@@ -22,29 +17,40 @@ $ npm install hl7v2 --save
 
 ## Node Compatibility
 
-  - node >= 6.x
-  
-## Change log
-
-To see changelog click [here](https://github.com/panates/hl7v2/commits/master)
+- node >= 18.x
 
-  
 ### License
+
 HL7v2 is available under [MIT](LICENSE) license.
 
 [npm-image]: https://img.shields.io/npm/v/hl7v2.svg
+
 [npm-url]: https://npmjs.org/package/hl7v2
-[travis-image]: https://img.shields.io/travis/panates/hl7v2/master.svg
-[travis-url]: https://travis-ci.org/panates/hl7v2
+
+[ci-test-image]: https://github.com/panates/hl7v2/actions/workflows/test.yml/badge.svg
+
+[ci-test-url]: https://github.com/panates/hl7v2/actions/workflows/test.yml
+
 [coveralls-image]: https://img.shields.io/coveralls/panates/hl7v2/master.svg
+
 [coveralls-url]: https://coveralls.io/r/panates/hl7v2
+
 [downloads-image]: https://img.shields.io/npm/dm/hl7v2.svg
+
 [downloads-url]: https://npmjs.org/package/hl7v2
+
 [gitter-image]: https://badges.gitter.im/panates/hl7v2.svg
+
 [gitter-url]: https://gitter.im/panates/hl7v2?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+
 [dependencies-image]: https://david-dm.org/panates/hl7v2/status.svg
+
 [dependencies-url]:https://david-dm.org/panates/hl7v2
+
 [devdependencies-image]: https://david-dm.org/panates/hl7v2/dev-status.svg
+
 [devdependencies-url]:https://david-dm.org/panates/hl7v2?type=dev
+
 [quality-image]: http://npm.packagequality.com/shield/hl7v2.png
+
 [quality-url]: http://packagequality.com/#?package=hl7v2

package/cjs/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FS = exports.VT = exports.LF = exports.CR = exports.SUBCOMPONENT_SEPARATOR = exports.ESCAPE_CHARACTER = exports.REPETITION_SEPARATOR = exports.COMPONENT_SEPARATOR = exports.FIELD_SEPARATOR = void 0;
+exports.FIELD_SEPARATOR = '|';
+exports.COMPONENT_SEPARATOR = '^';
+exports.REPETITION_SEPARATOR = '~';
+exports.ESCAPE_CHARACTER = '\\';
+exports.SUBCOMPONENT_SEPARATOR = '&';
+exports.CR = '\x0D';
+exports.LF = '\x0A';
+exports.VT = '\x0B';
+exports.FS = '\x1C';

package/cjs/hl7-component.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hl7Component = void 0;
+const hl7v2_dictionary_1 = require("hl7v2-dictionary");
+const hl7_error_js_1 = require("./hl7-error.js");
+const hl7_sub_component_js_1 = require("./hl7-sub-component.js");
+const hl7_escape_js_1 = require("./utils/hl7-escape.js");
+class Hl7Component {
+    constructor(repetition, position, def) {
+        this.repetition = repetition;
+        this.position = position;
+        this._definition = def;
+        this._typeDef = this.message.dictionary.types[this._definition.type];
+        if (!this._typeDef)
+            throw new Error(`Unknown data type: ${this._definition.type}`);
+        if (this.isPrimitive) {
+            this._data = new hl7_sub_component_js_1.Hl7SubComponent(this, 1, this.definition);
+        }
+        this.clear();
+    }
+    get message() {
+        return this.field.message;
+    }
+    get segment() {
+        return this.field.segment;
+    }
+    get field() {
+        return this.repetition.field;
+    }
+    get definition() {
+        return this._definition;
+    }
+    get typeDef() {
+        return this._typeDef;
+    }
+    get isPrimitive() {
+        return !this.typeDef.fields;
+    }
+    get subComponents() {
+        return this._subComponents;
+    }
+    clear() {
+        if (this.field.isPrimitive) {
+            this._data.value = undefined;
+        }
+        else
+            this._subComponents = [];
+    }
+    subcomp(position) {
+        if (this.field.isPrimitive)
+            throw new Error('Primitive fields have no sub-component');
+        if (position < 1)
+            throw new Error('Invalid sub-component position');
+        let subComponent = this._subComponents[position - 1];
+        if (!subComponent) {
+            let fDef = this.typeDef.fields?.[String(position)];
+            if (!fDef) {
+                if (position === 1)
+                    fDef = this.definition;
+                else
+                    fDef = {
+                        type: 'ST',
+                    };
+            }
+            subComponent = new hl7_sub_component_js_1.Hl7SubComponent(this, position, fDef);
+            this._subComponents[position - 1] = subComponent;
+        }
+        return subComponent;
+    }
+    getValue(subComponent) {
+        if (this._data)
+            return subComponent && subComponent > 1 ? undefined : this._data.value;
+        return this._subComponents[(subComponent ?? 1) - 1]?.value;
+    }
+    setValue(value, subComponent) {
+        if (subComponent || !this._data) {
+            this.subcomp(subComponent || 1).value = value;
+            return this;
+        }
+        this._data.value = value;
+        return this;
+    }
+    fromHL7String(value) {
+        if (value === '') {
+            this.setValue(undefined);
+            return;
+        }
+        if (this._data) {
+            const decode = this.definition.decode || this.typeDef.decode;
+            const unescaped = (0, hl7_escape_js_1.hl7UnEscape)(value, this.field.message);
+            try {
+                if (Buffer.isBuffer(unescaped) || unescaped == null)
+                    this._data.value = unescaped;
+                else
+                    this._data.value = decode ? decode(unescaped) : unescaped;
+            }
+            catch (e) {
+                const location = `${this.segment.segmentType}.${this.field.position}.${this.position}[${this.repetition.index}]`;
+                let segmentIndex = this.segment.index;
+                if (segmentIndex < 0)
+                    segmentIndex = this.message.segments.length;
+                throw new hl7_error_js_1.HL7Error(`The field (${location}) contained data of the wrong data type. ${e.message}.`, {
+                    segmentType: this.segment.segmentType,
+                    segmentSequence: segmentIndex,
+                    fieldPosition: this.field.position,
+                    componentPosition: this.position,
+                    repetitionIndex: this.repetition.index,
+                    hl7ErrorCode: 102,
+                });
+            }
+            return;
+        }
+        else {
+            this._subComponents = [];
+            const subComponents = value.split(this.field.message.subComponentSeparator);
+            let pos = 1;
+            for (const subComponent of subComponents) {
+                this.subcomp(pos++).fromHL7String(subComponent);
+            }
+        }
+    }
+    toHL7String(options) {
+        let str;
+        if (this._data) {
+            let v = this._data.value;
+            if (v === null)
+                return '""';
+            if (v === undefined)
+                return '';
+            const encode = this.definition.encode || this.typeDef.encode;
+            if (encode)
+                v = encode(v);
+            else {
+                if (typeof v === 'object' && v instanceof Date)
+                    v = (0, hl7v2_dictionary_1.encodeHL7DateTime)(v);
+            }
+            str = (0, hl7_escape_js_1.hl7Escape)(v, this.field.message);
+        }
+        else {
+            const { subComponentSeparator } = this.segment.message;
+            str = this._subComponents.map(subComponent => subComponent.toHL7String(options)).join(subComponentSeparator);
+            while (str.endsWith(subComponentSeparator))
+                str = str.substring(0, str.length - 1);
+        }
+        if (options?.serializeComponent)
+            return String(options?.serializeComponent(this, str, options) || '');
+        return str;
+    }
+    [Symbol.toStringTag]() {
+        return this.toHL7String();
+    }
+}
+exports.Hl7Component = Hl7Component;

package/cjs/hl7-error.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7Error = void 0;
+class HL7Error extends Error {
+    constructor(message, args) {
+        super(message);
+        this.severity = 'E';
+        if (args?.hl7ErrorCode)
+            this.hl7ErrorCode = args?.hl7ErrorCode;
+        if (args?.severity)
+            this.severity = args?.severity;
+        if (args?.appErrorCode)
+            this.appErrorCode = args?.appErrorCode;
+        if (args?.segmentType)
+            this.segmentType = args?.segmentType;
+        if (args?.segmentSequence != null)
+            this.segmentSequence = args?.segmentSequence;
+        if (args?.fieldPosition != null)
+            this.fieldPosition = args?.fieldPosition;
+        if (args?.componentPosition != null)
+            this.componentPosition = args?.componentPosition;
+        if (args?.subComponentPosition != null)
+            this.subComponentPosition = args?.subComponentPosition;
+        if (args?.repetitionIndex != null)
+            this.repetitionIndex = args?.repetitionIndex;
+    }
+}
+exports.HL7Error = HL7Error;

package/cjs/hl7-field.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7Field = void 0;
+const hl7_repetition_js_1 = require("./hl7-repetition.js");
+class HL7Field {
+    constructor(segment, position, def) {
+        this.segment = segment;
+        this.position = position;
+        this._definition = def;
+        this._typeDef = this.message.dictionary.types[this._definition.type];
+        if (!this._typeDef)
+            throw new Error(`Unknown data type: ${this._definition.type}`);
+        this.clear();
+    }
+    get message() {
+        return this.segment.message;
+    }
+    get definition() {
+        return this._definition;
+    }
+    get typeDef() {
+        return this._typeDef;
+    }
+    get isPrimitive() {
+        return !this.typeDef.fields;
+    }
+    get repetitions() {
+        return this._repetitions;
+    }
+    add() {
+        const rep = new hl7_repetition_js_1.HL7Repetition(this);
+        this._repetitions.push(rep);
+        return rep;
+    }
+    clear() {
+        this._repetitions = [];
+    }
+    repetition(repetitionIndex = 0) {
+        while (repetitionIndex >= this._repetitions.length)
+            this.add();
+        return this._repetitions[repetitionIndex];
+    }
+    component(position) {
+        return this.repetition(0).comp(position);
+    }
+    subComponent(componentPos, subComponentPos) {
+        return this.repetition(0).comp(componentPos).subcomp(subComponentPos);
+    }
+    /**
+     * Alias of .repetition()
+     */
+    rep(repetitionIndex = 0) {
+        return this.repetition(repetitionIndex);
+    }
+    /**
+     * Alias of .component()
+     */
+    comp(position) {
+        return this.component(position);
+    }
+    /**
+     * Alias of .subComponent()
+     */
+    subcomp(componentPos, subComponentPos) {
+        return this.subComponent(componentPos, subComponentPos);
+    }
+    getValue(component, subComponent) {
+        return this._repetitions[0]?.getValue(component, subComponent);
+    }
+    setValue(value, component, subComponent) {
+        return this.repetition(0).setValue(value, component, subComponent);
+    }
+    fromHL7String(value) {
+        const components = value.split(this.message.repetitionSeparator);
+        this._repetitions = [];
+        for (const cmp of components) {
+            this.add().fromHL7String(cmp);
+        }
+    }
+    toHL7String(options) {
+        if (!this._repetitions.length)
+            return '';
+        const { repetitionSeparator } = this.segment.message;
+        let str = this._repetitions
+            .map(component => component.toHL7String(options))
+            .join(repetitionSeparator);
+        while (str.endsWith(repetitionSeparator))
+            str = str.substring(0, str.length - 1);
+        if (options?.serializeField) {
+            return options.serializeField(this, str, options) || '';
+        }
+        return str;
+    }
+    [Symbol.toStringTag]() {
+        return this.toHL7String();
+    }
+}
+exports.HL7Field = HL7Field;

package/cjs/hl7-message.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HL7Message = void 0;
+const tslib_1 = require("tslib");
+const hl7v2_dictionary_1 = require("hl7v2-dictionary");
+const iconv_lite_1 = tslib_1.__importDefault(require("iconv-lite"));
+const uid_1 = require("uid");
+const constants_js_1 = require("./constants.js");
+const hl7_error_js_1 = require("./hl7-error.js");
+const hl7_segment_js_1 = require("./hl7-segment.js");
+class HL7Message {
+    constructor(version = hl7v2_dictionary_1.HL7Version.v2_7_1, dictionaries) {
+        this.fieldSeparator = constants_js_1.FIELD_SEPARATOR;
+        this.componentSeparator = constants_js_1.COMPONENT_SEPARATOR;
+        this.subComponentSeparator = constants_js_1.SUBCOMPONENT_SEPARATOR;
+        this.repetitionSeparator = constants_js_1.REPETITION_SEPARATOR;
+        this.escapeCharacter = constants_js_1.ESCAPE_CHARACTER;
+        this.carriageReturn = constants_js_1.CR;
+        this._dictionaries = dictionaries || hl7v2_dictionary_1.dictionaries;
+        this._version = version;
+        this.clear(version);
+    }
+    get dictionary() {
+        return this._dictionary;
+    }
+    get segments() {
+        return this._segments;
+    }
+    get header() {
+        return this.getSegment('MSH');
+    }
+    get version() {
+        return this._version;
+    }
+    get messageType() {
+        return this.header.field(hl7v2_dictionary_1.MSHSegment.MessageType).toHL7String();
+    }
+    get controlId() {
+        return this.header.field(hl7v2_dictionary_1.MSHSegment.MessageControlID).toHL7String();
+    }
+    clear(version) {
+        if (!version)
+            version = this._version || hl7v2_dictionary_1.HL7Version.v2_7_1;
+        this._version = version;
+        const nearestVersion = (0, hl7v2_dictionary_1.findNearestHL7Version)(version);
+        this._dictionary = this._dictionaries[nearestVersion];
+        this._segments = [];
+        const msh = this.addSegment('MSH');
+        msh.field(hl7v2_dictionary_1.MSHSegment.DateTimeOfMessage).setValue(new Date());
+        msh.field(hl7v2_dictionary_1.MSHSegment.MessageControlID).setValue((0, uid_1.uid)(8));
+        msh.field(hl7v2_dictionary_1.MSHSegment.VersionID).setValue(version);
+        msh.field(hl7v2_dictionary_1.MSHSegment.CharacterSet).setValue('UTF-8');
+    }
+    addSegment(segmentType) {
+        const segment = new hl7_segment_js_1.HL7Segment(this, segmentType);
+        this.segments.push(segment);
+        return segment;
+    }
+    /**
+     * Searches for a segment of a given type
+     */
+    getSegment(segmentType, index = 0) {
+        let k = 0;
+        for (const seg of this.segments) {
+            if (seg.segmentType === segmentType) {
+                if (!index || index === k)
+                    return seg;
+                k++;
+            }
+        }
+    }
+    /**
+     * Searches for a segment of a given type in reverse order
+     */
+    getSegmentFromLast(segmentType, index = 0) {
+        for (let k = this.segments.length - 1; k >= 0; k--) {
+            const seg = this.segments[k];
+            if (seg.segmentType === segmentType) {
+                if (!index || index === k)
+                    return seg;
+                k++;
+            }
+        }
+    }
+    toHL7String(options) {
+        return (this.segments
+            .map(segment => segment.toHL7String(options))
+            .filter(v => v)
+            .join(this.carriageReturn) + this.carriageReturn);
+    }
+    parse(input) {
+        let headerStr = '';
+        if (Buffer.isBuffer(input)) {
+            let crIdx = input.indexOf(constants_js_1.CR);
+            if (crIdx < 0)
+                crIdx = input.length;
+            headerStr = input.toString('utf8', 0, crIdx);
+        }
+        else if (typeof input === 'string') {
+            let crIdx = input.indexOf(constants_js_1.CR);
+            if (crIdx < 0)
+                crIdx = input.length;
+            headerStr = input.substring(0, crIdx);
+        } /* c8 ignore else */
+        else {
+            throw new TypeError('You must provide string or Buffer argument');
+        }
+        if (headerStr.startsWith(constants_js_1.VT))
+            headerStr = headerStr.substring(1);
+        if (!headerStr.startsWith('MSH'))
+            throw new hl7_error_js_1.HL7Error('Message must start with (MSH) segment', {
+                line: 1,
+                hl7ErrorCode: 100,
+            });
+        const fieldSeparator = headerStr[3];
+        /* Detect version and charset */
+        const headerItems = headerStr.split(fieldSeparator);
+        const version = headerItems[11];
+        const encoding = headerItems[17]?.split('^')[0];
+        let str = Buffer.isBuffer(input) ? iconv_lite_1.default.decode(input, encoding) : input;
+        if (str.startsWith(constants_js_1.VT))
+            str = str.substring(1);
+        const k = str.indexOf(constants_js_1.FS);
+        if (k >= 0)
+            str = str.substring(0, k);
+        this.clear(version);
+        this.fieldSeparator = fieldSeparator;
+        this.componentSeparator = headerItems[1][0];
+        this.repetitionSeparator = headerItems[1][1];
+        this.escapeCharacter = headerItems[1][2];
+        this.subComponentSeparator = headerItems[1][3];
+        this._segments = [];
+        const lines = str.split(constants_js_1.CR);
+        for (const [i, line] of lines.entries()) {
+            if (!line)
+                continue;
+            try {
+                const segment = hl7_segment_js_1.HL7Segment.parse(this, line);
+                this._segments.push(segment);
+            }
+            catch (e) {
+                if (!this.header) {
+                    this.addSegment('MSH');
+                }
+                this.header
+                    .field(hl7v2_dictionary_1.MSHSegment.SendingApplication)
+                    .setValue(headerItems[2]);
+                this.header.field(hl7v2_dictionary_1.MSHSegment.SendingFacility).setValue(headerItems[3]);
+                this.header
+                    .field(hl7v2_dictionary_1.MSHSegment.ReceivingApplication)
+                    .setValue(headerItems[4]);
+                this.header
+                    .field(hl7v2_dictionary_1.MSHSegment.ReceivingFacility)
+                    .setValue(headerItems[5]);
+                this.header.field(hl7v2_dictionary_1.MSHSegment.EncodingCharacters).setValue(encoding);
+                this.header.field(hl7v2_dictionary_1.MSHSegment.MessageControlID).setValue(headerItems[9]);
+                this.header.field(hl7v2_dictionary_1.MSHSegment.VersionID).setValue(version);
+                /* c8 ignore next */
+                const e1 = e instanceof hl7_error_js_1.HL7Error ? e : new hl7_error_js_1.HL7Error(e.message);
+                if (e1.segmentType) {
+                    const lastSeg = this.getSegmentFromLast(e.segmentType);
+                    if (lastSeg)
+                        e1.segmentSequence = lastSeg.index;
+                }
+                e1.line = i + 1;
+                throw e1;
+            }
+        }
+    }
+    createAck(ackCode = 'AA', textMessage) {
+        const out = new HL7Message(this.version);
+        const msh = out.header;
+        // Sending Application
+        msh
+            .field(hl7v2_dictionary_1.MSHSegment.ReceivingApplication)
+            .setValue(msh.field(hl7v2_dictionary_1.MSHSegment.SendingFacility).getValue());
+        msh
+            .field(hl7v2_dictionary_1.MSHSegment.ReceivingFacility)
+            .setValue(this.header.field(hl7v2_dictionary_1.MSHSegment.SendingFacility).getValue());
+        msh.field(hl7v2_dictionary_1.MSHSegment.MessageType).setValue('ACK');
+        msh
+            .field(hl7v2_dictionary_1.MSHSegment.MessageType)
+            .comp(2)
+            .setValue(this.header.field(hl7v2_dictionary_1.MSHSegment.MessageType).getValue(2));
+        msh
+            .field(hl7v2_dictionary_1.MSHSegment.MessageControlID)
+            .setValue(String(Date.now() + (0, uid_1.uid)(5)));
+        const msa = out.addSegment('MSA');
+        msa.field(hl7v2_dictionary_1.MSASegment.AcknowledgmentCode).setValue(ackCode);
+        msa
+            .field(hl7v2_dictionary_1.MSASegment.MessageControlID)
+            .setValue(this.header.field(hl7v2_dictionary_1.MSHSegment.MessageControlID).getValue());
+        if (textMessage) {
+            if (textMessage instanceof hl7_error_js_1.HL7Error) {
+                msa.field(hl7v2_dictionary_1.MSASegment.TextMessage).setValue(textMessage.message);
+                const err = out.addSegment('ERR');
+                err
+                    .field(hl7v2_dictionary_1.ERRSegment.HL7ErrorCode)
+                    .setValue(textMessage.hl7ErrorCode || 207);
+                err.field(hl7v2_dictionary_1.ERRSegment.Severity).setValue(textMessage.severity);
+                err
+                    .field(hl7v2_dictionary_1.ERRSegment.ApplicationErrorCode)
+                    .setValue(textMessage.appErrorCode);
+                const errLocation = err.field(hl7v2_dictionary_1.ERRSegment.ErrorLocation);
+                errLocation.comp(hl7v2_dictionary_1.ERLType.SegmentID).setValue(textMessage.segmentType);
+                errLocation
+                    .comp(hl7v2_dictionary_1.ERLType.SegmentSequence)
+                    .setValue(textMessage.segmentSequence);
+                errLocation
+                    .comp(hl7v2_dictionary_1.ERLType.FieldPosition)
+                    .setValue(textMessage.fieldPosition);
+                errLocation
+                    .comp(hl7v2_dictionary_1.ERLType.ComponentNumber)
+                    .setValue(textMessage.componentPosition);
+                errLocation
+                    .comp(hl7v2_dictionary_1.ERLType.FieldRepetition)
+                    .setValue(textMessage.repetitionIndex);
+                errLocation
+                    .comp(hl7v2_dictionary_1.ERLType.SubComponentNumber)
+                    .setValue(textMessage.subComponentPosition);
+            }
+            else if (textMessage instanceof Error) {
+                msa.field(hl7v2_dictionary_1.MSASegment.TextMessage).setValue(textMessage.message);
+                const err = out.addSegment('ERR');
+                err.field(hl7v2_dictionary_1.ERRSegment.HL7ErrorCode).setValue(207);
+                err.field(hl7v2_dictionary_1.ERRSegment.Severity).setValue('E');
+                if (textMessage.code)
+                    err
+                        .field(hl7v2_dictionary_1.ERRSegment.ApplicationErrorCode)
+                        .setValue(textMessage);
+            }
+            else {
+                msa.field(hl7v2_dictionary_1.MSASegment.TextMessage).setValue(textMessage);
+            }
+        }
+        return out;
+    }
+    /**
+     *
+     * @static
+     */
+    static parse(input, dictionaries) {
+        const message = new HL7Message(undefined, dictionaries);
+        message.parse(input);
+        return message;
+    }
+}
+exports.HL7Message = HL7Message;