xml-toolkit 1.0.0 → 1.0.3

package/README.md

@@ -54,4 +54,26 @@ let xmlResult = ''; for await (const node of new XMLReader ().process (xmlSource
     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,8 +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')
-const XMLNode             = require ('./lib/XMLNode')
+for (const name of [
 
-module.exports = {XMLLexer, XMLReader, SAXEvent, AttributesMap, MoxyLikeJsonEncoder, XMLNode}
+	'XMLLexer',
+	'XMLReader',
+	'SAXEvent',
+	'AttributesMap',
+	'MoxyLikeJsonEncoder',
+	'XMLNode',
+	'XMLSchemata',
+
+]) module.exports [name] = require ('./lib/' + name)

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,369 @@
+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, name) {
+								
+		const qName = this.ns.QName (name || this.schemaElement.name, this.schema.targetNamespace)
+
+		const {complexType, sequence, choice, all} = this.schemaElement, group = sequence || choice || all
+
+		let buf = ['<' + qName]
+		
+		this.ns.appendTo (buf)
+		
+		if (complexType) this._aComplexType (buf, complexType, content)
+
+		buf [0] += '>'
+
+		if (complexType) this._bComplexType (buf, complexType, content)
+		if (group)       this._bSequence    (buf, group, 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':
+						if (v.length === 10) return v + 'T00:00:00'
+						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]) {
+
+				const c = content [e.name]
+
+				this._bElement (buf, e, c)
+				
+			}
+				
+		}
+
+	}
+	
+	_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/XMLSchema.js

@@ -0,0 +1,103 @@
+const XMLSchema = class extends Map {
+
+	constructor (parent, targetNamespace) {
+	
+		super ()
+	
+		this.parent = parent
+		this.targetNamespace = targetNamespace
+		
+		this.isDefaultElementFormQualified   = true
+		this.isAttributeElementFormQualified = false
+
+	}
+
+	add (node, options = {}) {
+
+		if (node.elementFormDefault === 'unqualified') this.isDefaultElementFormQualified = false
+		if (node.attributeFormDefault === 'qualified') this.isAttributeElementFormQualified = true
+
+		for (const type of [
+
+			'element',
+			'complexType',
+			'simpleType',
+
+		]) if (type in node) {
+
+			let list = node [type]
+
+			if (!Array.isArray (list)) list = [list]
+
+			for (const item of list) {
+			
+				delete item.annotation
+				
+				item._type = type
+				
+				this.copyTargetNamespace (item)				
+
+				this.set (item.name, item)
+				
+				this.parent.register (item.name, this.targetNamespace)
+				
+			}
+
+		}
+
+	}
+	
+	copyTargetNamespace (o) {
+
+		if (typeof o !== 'object') return		
+
+		if (Array.isArray (o)) {
+
+			for (const v of o) this.copyTargetNamespace (v)
+
+		}
+		else {
+
+			o.targetNamespace = this.targetNamespace
+			
+			for (const v of Object.values (o)) this.copyTargetNamespace (v)
+
+		}
+	
+	}
+
+}
+
+XMLSchema.adjustNode = node => {
+
+	if (node.children) node.children = node.children.filter (i => i.localName !== 'annotation')
+	
+	const {attributes, namespacesMap} = node, splitNs = name => {
+		
+		if (!attributes.has (name)) return
+	
+		const [local, prefix] = attributes.get (name).split (':').reverse ()
+		
+		attributes.set (name, [local, namespacesMap.get (prefix)])
+	
+	}
+
+	switch (node.localName) {
+
+		case 'attribute':
+		case 'element':
+			splitNs ('type')
+			break
+
+		case 'extension':
+		case 'restriction':
+			splitNs ('base')
+			break
+
+	}
+
+	return node
+
+}
+
+module.exports = XMLSchema

package/lib/XMLSchemata.js

@@ -0,0 +1,143 @@
+const assert = require ('assert')
+
+const fs   = require ('fs')
+const path = require ('path')
+
+const XMLReader = require ('./XMLReader.js')
+const XMLNode   = require ('./XMLNode.js')
+const XMLSchema = require ('./XMLSchema.js'), {adjustNode} = XMLSchema
+const NamespacePrefixesMap = require ('./NamespacePrefixesMap.js')
+const XMLMarshaller = require ('./XMLMarshaller.js')
+
+const IDX = Symbol ('_index')
+
+const XMLSchemata = class extends Map {
+
+	constructor () {
+	
+		super ()
+		
+		this [IDX] = new Map ()
+	
+	}
+	
+	register (name, targetNamespace) {
+	
+		const idx = this [IDX]
+		
+		if (!idx.has (name)) idx.set (name, new Set ())
+		
+		idx.get (name).add (targetNamespace)
+	
+	}
+	
+	getByReference (ref) {
+
+		const [localName, namespaceURI] = ref
+		
+		if (namespaceURI === 'http://www.w3.org/2001/XMLSchema') return {
+			_type: 'simpleType',
+			name: localName
+		}
+		
+		return this.get (namespaceURI).get (localName)
+
+	}
+	
+	getSchemaByLocalName (localName) {
+	
+		const ns = this [IDX].get (localName)
+		
+		if (!ns) throw new Error ('Unknown name: ' + localName)
+
+		if (ns.size !== 1) throw new Error ('Ambiguous name ' + localName + ' belongs to: ' + Array.from (ns.values ()).map (s => `"${s}"`).join (', '))
+
+		for (const uri of ns) return this.get (uri)
+	
+	}
+
+	getNamespacePrefixesMap (o) {
+	
+		return new NamespacePrefixesMap (this, o)
+	
+	}
+	
+	createMarshaller (localName, namespaceURI) {
+	
+		if (arguments.length === 1) namespaceURI = this.getSchemaByLocalName (localName).targetNamespace
+		
+		return new XMLMarshaller (this, localName, namespaceURI)
+	
+	}
+	
+	stringify (o) {
+	
+		assert.strictEqual (typeof o, 'object')
+		
+		assert.strictEqual (Object.keys (o).length, 1)
+		
+		for (let [localName, content] of Object.entries (o)) 
+		
+			return this.createMarshaller (localName).stringify (content)
+	
+	}
+			
+	async addSchema (node, options = {}) {
+	
+		let {targetNamespace} = node; if (!targetNamespace) targetNamespace = options.targetNamespace
+
+		if (!this.has (targetNamespace)) this.set (targetNamespace, new XMLSchema (this, targetNamespace))
+		
+		let imp = node.import; if (imp) {
+		
+			const {addLocation} = options
+		
+			if (!Array.isArray (imp)) imp = [imp]
+			
+			for (const {schemaLocation, namespace} of imp) await addLocation (schemaLocation, namespace)
+		
+		}
+
+		this.get (targetNamespace).add (node)
+
+	}
+	
+	async addFile (fn, options = {}) {
+			
+		const dirname = path.dirname (fn), that = this, addLocation = async function (schemaLocation, namespace) {
+			
+			await that.addFile (path.join (dirname, schemaLocation), options = {targetNamespace: namespace})
+			
+		}
+
+		const {targetNamespace} = options, mapper = XMLNode.toObject ({})
+
+		for await (const node of 
+
+			new XMLReader ({
+				filterElements: e => e.namespaceURI === 'http://www.w3.org/2001/XMLSchema',
+				map: adjustNode,
+			})
+			.process (fs.createReadStream (fn))
+
+		) 
+
+			if (node.localName === 'schema')
+			
+				await this.addSchema (mapper (node), {addLocation, targetNamespace})
+	
+	}
+
+}
+
+XMLSchemata.fromFile = async function (fn, options = {}) {
+
+	let xs = new XMLSchemata ()
+	
+	await xs.addFile (fn, options)
+	
+	return xs
+
+}
+
+module.exports = XMLSchemata