xml-toolkit 0.0.8 → 1.0.2

package/README.md

@@ -1,4 +1,79 @@
 # node-xml-toolkit
 Collection of classes for dealing with XML
 
-This is a project template. The actual code is yet to be written.
+# Installation
+
+```
+npm i xml-toolkit
+```
+
+# Using
+* [Reading a Record List](https://github.com/do-/node-xml-toolkit/wiki/Use-Case:-Reading-a-Record-List)
+
+```js
+const {XMLReader, XMLNode} = require ('xml-toolkit')
+
+const records = new XMLReader ({
+  filterElements : 'Record', 
+  map            : XMLNode.toObject ({})
+}).process (xmlSource)
+
+// ...then:
+// await someLoader.load (records)
+
+// ...or
+// for await (const record of records) { // pull parser mode
+
+// ...or
+// records.on ('error', e => console.log (e))
+// records.pipe (nextStream)
+
+// ...or
+// records.on ('error', e => console.log (e))
+// records.on ('data', record => doSomethingWith (record))
+```
+
+* [Getting a Single Element](https://github.com/do-/node-xml-toolkit/wiki/Use-Case:-Getting-a-Single-Element)
+
+```js
+const {XMLReader, XMLNode} = require ('xml-toolkit')
+
+const data = await new XMLReader ({
+  filterElements : 'MyElementName', 
+  map            : XMLNode.toObject ({})
+}).process (xmlSource).findFirst ()
+```
+
+* [Patching XML](https://github.com/do-/node-xml-toolkit/wiki/Use-Case:-Patching-XML)
+
+```js
+const {XMLReader} = require ('xml-toolkit')
+
+let xmlResult = ''; for await (const node of new XMLReader ().process (xmlSource)) xmlResult += 
+    node.isCharacters && node.parent.localName === 'ThePlaceHolder' ? id : 
+    node.xml
+```
+
+* [Serializing an Object According to an XML Schema](https://github.com/do-/node-xml-toolkit/wiki/Use-Case:-Serializing-an-Object-According-to-an-XML-Schema)
+
+```js
+const {XMLSchemata} = require ('xml-toolkit')
+
+const data = {ExportDebtRequestsResponse: {	
+  "request-data": {
+   // ...
+  }
+}
+
+const xs = await XMLSchemata.fromFile ('xs.xsd')
+
+const xml = xs.stringify (data)
+
+/* result:
+<ns0:ExportDebtRequestsResponse xmlns:ns0="urn:...">
+  <ns0:request-data>
+    <!-- ... and so on ... -->
+*/
+```
+
+More information available in [wiki docs](https://github.com/do-/node-xml-toolkit/wiki).

package/index.js

@@ -1,7 +1,11 @@
-const XMLLexer            = require ('./lib/XMLLexer')
-const XMLReader           = require ('./lib/XMLReader')
-const SAXEvent            = require ('./lib/SAXEvent')
-const AttributesMap       = require ('./lib/AttributesMap')
-const MoxyLikeJsonEncoder = require ('./lib/MoxyLikeJsonEncoder')
+for (const name of [
 
-module.exports = {XMLLexer, XMLReader, SAXEvent, AttributesMap, MoxyLikeJsonEncoder}
+	'XMLLexer',
+	'XMLReader',
+	'SAXEvent',
+	'AttributesMap',
+	'MoxyLikeJsonEncoder',
+	'XMLNode',
+	'XMLSchemata',
+
+]) module.exports [name] = require ('./lib/' + name)

package/lib/MoxyLikeJsonEncoder.js

@@ -1,45 +1,63 @@
 const SAXEvent = require ('./SAXEvent.js'), {CHARACTERS, END_ELEMENT} = SAXEvent.TYPES
 
-const set = (o, k, nv) => {
+const GET_LOCAL_NAME = (localName, namespaceURI) => localName
 
-	if (!(k in o)) return o [k] = nv
+const MoxyLikeJsonEncoder = function (options = {}) {
 
-	const ov = o [k]; if (!Array.isArray (ov)) o [k] = [ov]
-	
-	o [k].push (nv)
+	let {getName} = options; if (!getName) getName = GET_LOCAL_NAME
 
-}
+	const xform = ({children, attributes}) => {
 
-const xform = ({children, attributes}) => {
+		let o = null
 
-	let o = null
+		const set = (nv, localName, namespaceURI) => {
+		
+			const k = getName (localName, namespaceURI)
 
-	if (attributes != null && attributes.size !== 0) o = Object.fromEntries (attributes.entries ())
+			if (o === null) return o = {[k]: nv}
 
-	if (children != null) for (const child of children) switch (child.type) {
+			if (!(k in o)) return o [k] = nv
 
-		case CHARACTERS:  return child.text
+			const ov = o [k]; if (!Array.isArray (ov)) return o [k] = [ov, nv]
 
-		case END_ELEMENT:
-		
-			if (o === null) o = {}
+			ov.push (nv)
+
+		}
+
+		if (attributes != null)
+					
+			for (const [name, value] of attributes.entries ())
 			
-			set (o, child.localName, xform (child))
+				set (value, attributes.getLocalName (name), attributes.getNamespaceURI (name))
 
-	}
-	
-	return o
+		if (children != null) for (const child of children) switch (child.type) {
 
-}
+			case CHARACTERS:
+			
+				return child.text
 
-const MoxyLikeJsonEncoder = function (options = {}) {
+			case END_ELEMENT:
+
+				set (xform (child), child.localName, child.namespaceURI)
+
+		}
+
+		return o
+
+	}
 
 	return function (node) {
 	
 		let result = xform (node)
-	
-		return options.wrap ? {[node.localName]: result} : result
-			
+		
+		const {wrap, map} = options
+
+		if (wrap) result = {[getName (node.localName, node.namespaceURI)]: result}
+		
+		if (map) result = map (result)
+
+		return result
+
 	}
 
 }

package/lib/NamespacePrefixesMap.js

@@ -0,0 +1,57 @@
+const assert = require ('assert')
+
+const NamespacePrefixesMap = class extends Map {
+
+	constructor (schemata, o) {
+	
+		assert.strictEqual (typeof o, 'object')
+
+		super ()
+		
+		this.schemata = schemata
+		
+		this.add (o)
+		
+	}
+	
+	add (o) {
+
+		if (this.isAddedAsNamespaceReference (o)) return
+		
+		for (let v of Object.values (o)) if (typeof v === 'object') this.add (v)
+	
+	}
+	
+	isAddedAsNamespaceReference (a) {
+
+		if (!Array.isArray (a)) return false
+		
+		if (a.length !== 2) return false
+		
+		const uri = a [1]
+		
+		if (!this.schemata.has (uri)) return false
+
+		if (this.has (uri)) return true
+		
+		this.set (uri, 'ns' + this.size)
+		
+	}
+	
+	QName (localName, namespaceURI) {
+	
+		if (namespaceURI == null || !this.has (namespaceURI)) return localName
+		
+		return this.get (namespaceURI) + ':' + localName
+	
+	}
+
+	appendTo (buf) {
+
+		for (let [k, v] of this.entries ()) buf [0] += ' xmlns:' + v + '="' + k + '"'
+
+	}
+
+}
+
+module.exports = NamespacePrefixesMap

package/lib/XMLMarshaller.js

@@ -0,0 +1,363 @@
+const assert       = require ('assert')
+const stringEscape = require ('string-escape-map')
+
+let esc = [
+  ['<', '&lt;'],
+  ['>', '&gt;'],
+  ['&', '&amp;'],
+  ['"', '&quot;']
+]
+
+//const XML_BODY = new stringEscape (esc)
+
+//esc.push (['"', '&quot;'])
+
+const XML_ATTR = new stringEscape (esc)
+
+const BOOL = new Map ([
+	['0',     'false'],
+	['false', 'false'],
+	['N',     'false'],
+	['1',     'true'],
+	['true',  'true'],
+	['Y',     'true'],
+])
+
+const XMLMarshaller = class {
+
+	constructor (xs, localName, namespaceURI) {
+	
+		this.xs = xs
+		
+		this.schema = xs.get (namespaceURI); assert (this.schema, 'No schema found for namespaceURI = ' + namespaceURI)
+
+		this.schemaElement = this.schema.get (localName); assert (this.schemaElement, 'No schema element found for namespaceURI = ' + namespaceURI + ', localName = ' + localName)
+
+		this.ns = this.xs.getNamespacePrefixesMap (this.schemaElement)
+
+	}
+	
+	stringify (content) {
+								
+		const qName = this.ns.QName (this.schemaElement.name, this.schema.targetNamespace)
+
+		const {complexType} = this.schemaElement
+
+		let buf = ['<' + qName]
+		
+		this.ns.appendTo (buf)
+		
+		if (complexType) this._aComplexType (buf, complexType, content)
+
+		buf [0] += '>'
+		
+		if (complexType) this._bComplexType (buf, complexType, content)
+
+		return buf [0] + '</' + qName + '>'
+
+	}	
+	
+	/// _a: attributes
+	
+	_aComplexType (buf, complexType, content) {
+		
+		const {complexContent, attribute} = complexType
+
+		if (attribute) 		
+			for (const e of Array.isArray (attribute) ? attribute : [attribute])		
+				this._aAttribute (buf, e, content [e.name])
+		
+		if (complexContent) this._aComplexContent (buf, complexContent, content)
+	
+	}	
+	
+	_aComplexContent (buf, complexContent, content) {
+			
+		const {extension} = complexContent
+
+		if (extension) this._aExtension (buf, extension, content)
+		
+	}
+	
+	_aExtension (buf, extension, content) {
+		
+		const {base, attribute} = extension
+
+		if (base) {
+		
+			const [localName, namespaceURI] = base
+		
+			const schema = this.xs.get (namespaceURI)
+		
+			const type = schema.get (localName)
+			
+			if (type._type === 'complexType') this._aComplexType (buf, type, content)
+					
+		}
+
+		if (attribute) 		
+			for (const a of Array.isArray (attribute) ? attribute : [attribute])		
+				this._aAttribute (buf, a, content [a.name])
+
+	}	
+	
+	_aAttribute (buf, attribute, content) {
+
+		if (content == null) return
+
+		let {name, targetNamespace, simpleType, type} = attribute
+		
+		if (type) {
+
+			type = this.xs.getByReference (type)
+
+			switch (type._type) {
+
+				case 'simpleType':
+					simpleType = type
+					break
+
+			}
+
+		}
+
+		const qName = this.ns.QName (name, targetNamespace)
+		
+		buf [0] += ' ' + qName + '="'
+			
+		if (simpleType)  this._bSimpleType  (buf, simpleType, content)
+			
+		buf [0] += '"'
+			
+	}	
+	
+	/// _b: body	
+	
+	_bComplexType (buf, complexType, content) {
+
+		const {complexContent, sequence, choice, all} = complexType, group = sequence || choice || all
+
+		if (group)          this._bSequence       (buf, group, content)
+		if (complexContent) this._bComplexContent (buf, complexContent, content)
+	
+	}
+
+	_bSimpleType (buf, simpleType, content, _restriction = {}) {
+	
+		let {restriction} = simpleType; if (restriction) {
+
+			for (const [k, v] of Object.entries (_restriction)) switch (k) {				
+				case 'base': case 'targetNamespace': break
+				default: restriction [k] = v
+			}
+			
+			this._bSimpleType (buf, this.xs.getByReference (restriction.base), content, restriction)
+
+		}
+		else {
+
+			buf [0] += this.to_string (content, simpleType.name, _restriction)
+
+		}
+	
+	}
+	
+	to_string (v, type, restriction = {}) {
+		
+		const carp = () => {throw new Error (`Invalid value for ${type} type: ${v} (${typeof v})`)}
+	
+		switch (type) {
+		
+			case 'boolean':
+				if (BOOL.has (v)) return BOOL.get (v)
+				return !v ? 'false' : 'true'
+
+			case 'date':
+				switch (typeof v) {
+					case 'string':
+						if (v.length === 10) return v
+					case 'number':
+					case 'bigint':
+						const d = new Date (v)
+						if (isNaN (d)) carp ()
+						v = d
+				}
+				if (v instanceof Date) {
+					return v.toJSON ().slice (0, 10)
+				}
+				else {
+					carp ()
+				}
+				
+			case 'dateTime':
+				switch (typeof v) {
+					case 'string':
+						return v
+					case 'number':
+					case 'bigint':
+						v = new Date (v)
+				}
+				if (v instanceof Date) {
+					return v.toJSON ()
+				}
+				else {
+					carp ()
+				}
+
+			case 'integer':
+			case 'nonNegativeInteger':
+			case 'positiveInteger':
+			case 'nonPositiveInteger':
+			case 'negativeInteger':
+			case 'long':
+				if (typeof v === 'string') v = BigInt (v)
+				switch (typeof v) {
+					case 'number':
+					case 'bigint':
+						return '' + v
+				}
+				carp ()
+
+			case 'int':
+			case 'short':
+			case 'byte':
+			case 'unsignedLong':
+			case 'unsignedInt':
+			case 'unsignedShort':
+			case 'unsignedByte':
+				if (typeof v === 'string') v = parseInt (v)
+				switch (typeof v) {
+					case 'number':
+						if (!Number.isInteger (v)) carp ()
+					case 'bigint':
+						return '' + v
+				}
+				carp ()
+
+			case 'float':
+			case 'double':
+				if (typeof v === 'string') v = parseFloat (v)
+				if (typeof v === 'number') switch (v) {
+					case Number.POSITIVE_INFINITY: return 'INF'
+					case Number.NEGATIVE_INFINITY: return '-INF'
+					default: return '' + v
+				}
+				carp ()
+
+			case 'decimal':
+				const {fractionDigits} = restriction
+				if (typeof v === 'string') v = parseFloat (v)
+				if (typeof v === 'number') return fractionDigits ? v.toFixed (fractionDigits.value) : '' + v
+				carp ()
+
+			default:
+				return XML_ATTR.escape ('' + v)
+			
+		}
+	
+	}
+	
+	_bComplexContent (buf, complexContent, content) {
+			
+		const {extension} = complexContent
+
+		if (extension) this._bExtension (buf, extension, content)
+		
+	}
+	
+	_bExtension (buf, _extension, content) {
+		
+		const {base, sequence, choice, all} = _extension, group = sequence || choice || all
+
+		if (base) {
+		
+			const [localName, namespaceURI] = base
+		
+			const schema = this.xs.get (namespaceURI)
+		
+			const type = schema.get (localName)
+			
+			if (type._type === 'complexType') this._bComplexType (buf, type, content)
+					
+		}
+
+		if (group) this._bSequence (buf, group, content)
+
+	}
+
+	_bSequence (buf, _sequence, content) {
+		
+		const {element, sequence, choice, all} = _sequence, group = sequence || choice || all
+
+		if (group) this._bSequence (buf, group, content)
+
+		if (element) {
+		
+			for (const e of Array.isArray (element) ? element : [element])
+		
+				this._bElement (buf, e, content [e.name])
+				
+		}
+
+	}
+	
+	_bElement_null (buf, element) {
+	
+		if (BOOL.get (element.nillable) !== 'true') return
+		
+		const {name, targetNamespace} = element, qName = this.ns.QName (name, targetNamespace)
+
+		buf [0] += `<${qName} xsi:nil="true" />`
+
+	}
+	
+	_bElement (buf, element, content) {
+
+		if (content == null) return this._bElement_null (buf, element)
+		
+		if (!Array.isArray (content)) content = [content]
+		
+		if (content.length === 0) return
+
+		let {name, targetNamespace, complexType, simpleType, type} = element
+		
+		if (type) {
+
+			type = this.xs.getByReference (type)
+
+			switch (type._type) {
+
+				case 'complexType':
+					complexType = type
+					break
+
+				case 'simpleType':
+					simpleType = type
+					break
+
+			}
+
+		}
+
+		const qName = this.ns.QName (name, targetNamespace)
+		
+		for (const i of content) {
+		
+			buf [0] += '<' + qName
+
+			if (complexType) this._aComplexType (buf, complexType, content)
+			
+			buf [0] += '>'
+			
+			if (complexType) this._bComplexType (buf, complexType, i)
+			if (simpleType)  this._bSimpleType  (buf, simpleType, i)
+			
+			buf [0] += '</' + qName + '>'
+
+		}
+			
+	}
+
+}
+
+module.exports = XMLMarshaller

package/lib/XMLNode.js

@@ -1,6 +1,7 @@
 const SAXEvent      = require ('./SAXEvent.js')
 const AttributesMap = require ('./AttributesMap')
 const NamespacesMap = require ('./NamespacesMap')
+const MoxyLikeJsonEncoder = require ('./MoxyLikeJsonEncoder')
 
 const XML_READER = Symbol ('_xmlReader')
 const ATTRIBUTES = Symbol ('_attributes')
@@ -31,8 +32,9 @@ const XMLNode = class extends SAXEvent {
 
 		e [PARENT]     = this [PARENT]
 		e [LEVEL]      = this [LEVEL]
-		e [ATTRIBUTES] = this [ATTRIBUTES]
-		e [NS_MAP]     = this [NS_MAP]
+
+		if (ATTRIBUTES in this) e [ATTRIBUTES] = this [ATTRIBUTES]
+		if (NS_MAP     in this) e [NS_MAP]     = this [NS_MAP]
 
 		return e
 
@@ -96,7 +98,9 @@ const XMLNode = class extends SAXEvent {
 
 	get namespaceURI () {
 	
-		return this.namespacesMap.getNamespaceURI (this.name, true)
+		const {namespacesMap} = this; if (namespacesMap == null) return null
+	
+		return namespacesMap.getNamespaceURI (this.name, true)
 
 	}
 	
@@ -138,4 +142,6 @@ XMLNode.getLocalName = name => {
 
 }
 
+XMLNode.toObject = MoxyLikeJsonEncoder
+
 module.exports = XMLNode