node-opcua-client-dynamic-extension-object 2.76.2 → 2.78.0

package/source/private/populate_data_type_manager_103.ts

@@ -6,8 +6,8 @@
 import * as chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
-import { AttributeIds, makeNodeClassMask, makeResultMask, QualifiedName } from "node-opcua-data-model";
-import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog} from "node-opcua-debug";
+import { AttributeIds, makeNodeClassMask, makeResultMask, NodeClassMask, QualifiedName } from "node-opcua-data-model";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { ConstructorFuncWithSchema, DataTypeFactory, getStandardDataTypeFactory } from "node-opcua-factory";
 import { ExpandedNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { browseAll, BrowseDescriptionLike, IBasicSession } from "node-opcua-pseudo-session";
@@ -20,7 +20,7 @@ import {
 import { BrowseDescriptionOptions, BrowseDirection, BrowseResult, ReferenceDescription } from "node-opcua-service-browse";
 import { makeBrowsePath } from "node-opcua-service-translate-browse-path";
 import { StatusCodes } from "node-opcua-status-code";
-import { ReadValueIdOptions, StructureDefinition } from "node-opcua-types";
+import { BrowsePath, ReadValueIdOptions, StructureDefinition } from "node-opcua-types";
 
 import { ExtraDataTypeManager } from "../extra_data_type_manager";
 import {
@@ -122,13 +122,20 @@ async function _enrichWithDescriptionOf(session: IBasicSession, dataTypeDescript
     const binaryEncodings = [];
     const nodesToBrowseDataType: BrowseDescriptionOptions[] = [];
 
-    let i = 0;
-    for (const result3 of results3) {
-        const dataTypeDescription = dataTypeDescriptions[i++];
+    for (let i=0;i< results3.length;i++) {
+   
+        const result3 = results3[i];
+        const dataTypeDescription = dataTypeDescriptions[i];
 
         result3.references = result3.references || [];
+
+        if (result3.references.length === 0) {
+            // may be the dataType is abstract and as no need for DescriptionOF
+            continue;
+        }
         if (result3.references.length !== 1) {
             warningLog("_enrichWithDescriptionOf : expecting 1 reference for ", dataTypeDescription.browseName.toString());
+            warningLog(result3.toString()); 
             continue;
         }
         for (const ref of result3.references) {
@@ -144,34 +151,65 @@ async function _enrichWithDescriptionOf(session: IBasicSession, dataTypeDescript
             nodesToBrowseDataType.push({
                 browseDirection: BrowseDirection.Inverse,
                 includeSubtypes: false,
-                nodeClassMask: makeNodeClassMask("DataType"),
-                nodeId: ref.nodeId.toString(),
+                nodeClassMask: NodeClassMask.DataType,
+                nodeId: ref.nodeId,
                 referenceTypeId: resolveNodeId("HasEncoding"),
                 //            resultMask: makeResultMask("NodeId | ReferenceType | BrowseName | NodeClass | TypeDefinition")
                 resultMask: makeResultMask("NodeId | BrowseName")
             });
         }
     }
+
     const dataTypeNodeIds: NodeId[] = [];
+
     if (nodesToBrowseDataType.length > 0) {
         const results4 = await browseAll(session, nodesToBrowseDataType);
-        i = 0;
-        for (const result4 of results4) {
+        for (let i=0;i< results4.length; i++) {
+
+            const result4 =results4[i];
             result4.references = result4.references || [];
 
             /* istanbul ignore next */
             if (result4.references.length !== 1) {
-                console.log("What's going on ?", result4.toString());
+                errorLog("What's going on ?", result4.toString(), "result4.references.length = ", result4.references.length);
             }
 
-            for (const ref of result4.references) {
-                const dataTypeNodeId = ref.nodeId;
+            const ref = result4.references![0];
+            const dataTypeNodeId = ref.nodeId;
+            dataTypeNodeIds[i]= dataTypeNodeId;
+            const dataTypeDescription = dataTypeDescriptions[i];
+            dataTypeDescription.encodings!.dataTypeNodeId = dataTypeNodeId;
+        }
+    }
 
-                dataTypeNodeIds.push(dataTypeNodeId);
+    const otherEncodingBrowse = dataTypeNodeIds.map((dataTypeNodeId)=>({
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: false,
+        nodeClassMask: NodeClassMask.Object,
+        nodeId: dataTypeNodeId,
+        referenceTypeId: resolveNodeId("HasEncoding"),
+        //            resultMask: makeResultMask("NodeId | ReferenceType | BrowseName | NodeClass | TypeDefinition")
+        resultMask: makeResultMask("NodeId | BrowseName")
+    }));
 
-                const dataTypeDescription = dataTypeDescriptions[i++];
-                dataTypeDescription.encodings!.dataTypeNodeId = dataTypeNodeId;
-            }
+    const results5 = await browseAll(session, otherEncodingBrowse);
+    for (let i=0;i<results5.length;i++) {
+        const result5= results5[i];
+        const dataTypeDescription = dataTypeDescriptions[i];
+        for (const ref of result5.references || []) {
+            switch(ref.browseName.name) {
+                case "Default XML":
+                    dataTypeDescription.encodings!.xmlEncodingNodeId = ref.nodeId;
+                    break;
+                case "Default Binary":
+                    dataTypeDescription.encodings!.binaryEncodingNodeId = ref.nodeId;
+                    break;
+                case "Default JSON":
+                    dataTypeDescription.encodings!.jsonEncodingNodeId = ref.nodeId;
+                    break;
+                default:
+                    errorLog("Cannot handle unknown encoding", ref.browseName.name);
+            } 
         }
     }
     return dataTypeNodeIds;
@@ -181,6 +219,7 @@ interface IDataTypeDefInfo {
     className: string;
     dataTypeNodeId: NodeId;
     dataTypeDefinition: StructureDefinition;
+    isAbstract: boolean;
 }
 type DataTypeDefinitions = IDataTypeDefInfo[];
 
@@ -211,7 +250,7 @@ function sortStructure(dataTypeDefinitions: DataTypeDefinitions) {
             }
             _visit(ddd);
         }
-       
+
         dataTypeDefinitionsSorted.push(d);
     }
     for (const d of dataTypeDefinitions) {
@@ -255,7 +294,7 @@ async function _extractDataTypeDictionaryFromDefinition(
 
             if (dataTypeDefinition && dataTypeDefinition instanceof StructureDefinition) {
                 const className = dataTypeDescription.browseName.name!;
-                dataTypeDefinitions.push({ className, dataTypeNodeId, dataTypeDefinition });
+                dataTypeDefinitions.push({ className, dataTypeNodeId, dataTypeDefinition, isAbstract: false });
             }
         } else {
             debugLog(
@@ -272,12 +311,12 @@ async function _extractDataTypeDictionaryFromDefinition(
     if (doDebug) {
         debugLog("order ", dataTypeDefinitionsSorted.map((a) => a.className + " " + a.dataTypeNodeId).join(" ->  "));
     }
-    for (const { className, dataTypeNodeId, dataTypeDefinition } of dataTypeDefinitionsSorted) {
+    for (const { className, dataTypeNodeId, dataTypeDefinition, isAbstract } of dataTypeDefinitionsSorted) {
         // istanbul ignore next
         if (doDebug) {
             debugLog(chalk.yellow("--------------------------------------- "), className, dataTypeNodeId.toString());
         }
-        if (dataTypeFactory.hasStructuredType(className)) {
+        if (dataTypeFactory.hasStructureByTypeName(className)) {
             continue; // this structure has already been seen
         }
         // now fill typeDictionary
@@ -288,6 +327,7 @@ async function _extractDataTypeDictionaryFromDefinition(
                 className,
                 dataTypeDefinition,
                 dataTypeFactory,
+                isAbstract,
                 cache
             );
 
@@ -336,6 +376,11 @@ interface TypeDictionaryInfo {
     targetNamespace: string;
 }
 
+function _isOldDataTypeDictionary(d: TypeDictionaryInfo) {
+    const isDictionaryDeprecated = d.isDictionaryDeprecated; // await _readDeprecatedFlag(session, dataTypeDictionaryNodeId);
+    const rawSchema = d.rawSchema; // DataValue = await session.read({ nodeId: dataTypeDictionaryNodeId, attributeId: AttributeIds.Value });
+    return !isDictionaryDeprecated && rawSchema.length >=0;
+}
 async function _extractDataTypeDictionary(
     session: IBasicSession,
     d: TypeDictionaryInfo,
@@ -343,13 +388,10 @@ async function _extractDataTypeDictionary(
 ): Promise<void> {
     const dataTypeDictionaryNodeId = d.reference.nodeId;
 
-    const isDictionaryDeprecated = d.isDictionaryDeprecated; // await _readDeprecatedFlag(session, dataTypeDictionaryNodeId);
-    const rawSchema = d.rawSchema; // DataValue = await session.read({ nodeId: dataTypeDictionaryNodeId, attributeId: AttributeIds.Value });
-
     const name = await session.read({ nodeId: dataTypeDictionaryNodeId, attributeId: AttributeIds.BrowseName });
     const namespace = await _readNamespaceUriProperty(session, dataTypeDictionaryNodeId);
 
-    if (isDictionaryDeprecated || rawSchema.length === 0) {
+    if (!_isOldDataTypeDictionary(d)) {
         debugLog(
             "DataTypeDictionary is deprecated or BSD schema stored in dataValue is null !",
             chalk.cyan(name.value.value.toString()),
@@ -364,8 +406,8 @@ async function _extractDataTypeDictionary(
             throw new Error("cannot find dataTypeFactory for namespace " + dataTypeDictionaryNodeId.namespace);
         }
         await _extractDataTypeDictionaryFromDefinition(session, dataTypeDictionaryNodeId, dataTypeFactory2);
-        return;
     } else {
+        const rawSchema = d.rawSchema; // DataValue = await session.read({ nodeId: dataTypeDictionaryNodeId, attributeId: AttributeIds.Value });
         debugLog(" ----- Using old method for extracting schema => with BSD files");
         // old method ( until 1.03 )
         // one need to read the schema file store in the dataTypeDictionary node and parse it !
@@ -440,9 +482,12 @@ async function _exploreDataTypeDefinition(
             }
             // let's verify that constructor is operational
             try {
-                const constructor = dataTypeFactory.getStructureTypeConstructor(name);
+                const Constructor = dataTypeFactory.getStructureInfoByTypeName(name).constructor;
+                if (!Constructor) {
+                    throw new Error(`Cannot instantiate abstract DataType(name=${name})`);
+                }
                 // xx const constructor = getOrCreateConstructor(name, dataTypeFactory, defaultBinary);
-                const testObject = new constructor();
+                const testObject = new Constructor();
                 debugLog(testObject.toString());
             } catch (err) {
                 debugLog("         Error cannot construct Extension Object " + name);

package/source/private/populate_data_type_manager_104.ts

@@ -4,7 +4,7 @@ import { make_debugLog, make_errorLog } from "node-opcua-debug";
 import { DataTypeFactory } from "node-opcua-factory";
 import { NodeId, NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 import { IBasicSession, BrowseDescriptionLike } from "node-opcua-pseudo-session";
-import { createDynamicObjectConstructor } from "node-opcua-schemas";
+import { createDynamicObjectConstructor as createDynamicObjectConstructorAndRegister } from "node-opcua-schemas";
 import { StatusCodes } from "node-opcua-status-code";
 import { ReferenceDescription, BrowseResult, BrowseDescriptionOptions } from "node-opcua-types";
 
@@ -25,10 +25,22 @@ export async function readDataTypeDefinitionAndBuildType(
     cache: { [key: string]: CacheForFieldResolution }
 ) {
     try {
-        const dataTypeDefinitionDataValue = await session.read({
-            attributeId: AttributeIds.DataTypeDefinition,
-            nodeId: dataTypeNodeId
-        });
+        const [isAbstractDataValue, dataTypeDefinitionDataValue] = await session.read([
+            {
+                attributeId: AttributeIds.IsAbstract,
+                nodeId: dataTypeNodeId
+            },
+            {
+                attributeId: AttributeIds.DataTypeDefinition,
+                nodeId: dataTypeNodeId
+            }
+        ]);
+        /* istanbul ignore next */
+        if (isAbstractDataValue.statusCode !== StatusCodes.Good) {
+            throw new Error(" Cannot find dataType isAbstract ! with nodeId =" + dataTypeNodeId.toString());
+        }
+        const isAbstract = isAbstractDataValue.value.value as boolean;
+
         /* istanbul ignore next */
         if (dataTypeDefinitionDataValue.statusCode !== StatusCodes.Good) {
             throw new Error(" Cannot find dataType Definition ! with nodeId =" + dataTypeNodeId.toString());
@@ -41,11 +53,16 @@ export async function readDataTypeDefinitionAndBuildType(
             name,
             dataTypeDefinition,
             dataTypeFactory,
+            isAbstract,
             cache
         );
-
-        createDynamicObjectConstructor(schema, dataTypeFactory);
-
+        if (isAbstract) {
+            // cannot construct an abstract structure
+            dataTypeFactory.registerAbstractStructure(dataTypeNodeId, name, schema);
+    
+        } else {
+            const Constructor = createDynamicObjectConstructorAndRegister(schema, dataTypeFactory);
+        }
     } catch (err) {
         errorLog("Error", err);
     }
@@ -165,14 +182,13 @@ export async function populateDataTypeManager104(session: IBasicSession, dataTyp
                 return;
             }
             // if not found already
-            if (dataTypeFactory.getConstructorForDataType(dataTypeNodeId)) {
+            if (dataTypeFactory.getStructureInfoForDataType(dataTypeNodeId)) {
                 // already known !
                 return;
             }
             // extract it formally
             debugLog(" DataType => ", r.browseName.toString(), dataTypeNodeId.toString());
             await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, r.browseName.name!, dataTypeFactory, cache);
-            assert(dataTypeFactory.getConstructorForDataType(dataTypeNodeId));
         } catch (err) {
             errorLog("err=", err);
         }

package/source/resolve_dynamic_extension_object.ts

@@ -4,7 +4,7 @@ import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
 import { hexDump, make_warningLog } from "node-opcua-debug";
 import { IBasicSession } from "node-opcua-pseudo-session";
 import { NodeId } from "node-opcua-nodeid";
-import { ConstructorFunc } from "node-opcua-factory";
+import { ConstructorFunc, StructuredTypeField } from "node-opcua-factory";
 import { BrowseDirection, NodeClassMask, ResultMask } from "node-opcua-data-model";
 import { StatusCodes } from "node-opcua-status-code";
 //
@@ -19,6 +19,8 @@ async function getOrExtractConstructor(
     dataTypeManager: ExtraDataTypeManager
 ): Promise<ConstructorFunc> {
     const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(binaryEncodingNodeId.namespace);
+    
+    
     const Constructor = dataTypeFactory.getConstructor(binaryEncodingNodeId);
     if (Constructor) {
         return Constructor;
@@ -41,14 +43,99 @@ async function getOrExtractConstructor(
     const r = browseResult.references![0];
     const dataTypeNodeId = r.nodeId;
 
-    if (dataTypeFactory.getConstructorForDataType(dataTypeNodeId)) {
+    if (dataTypeFactory.getStructureInfoForDataType(dataTypeNodeId)) {
         throw new Error("Internal Error: we are not expecting this dataType to be processed already");
     }
     await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, r.browseName.name!, dataTypeFactory, {});
 
-    return dataTypeFactory.getConstructorForDataType(dataTypeNodeId)!;
+    const structureInfo  = dataTypeFactory.getStructureInfoForDataType(dataTypeNodeId)!;
+    if (!structureInfo.constructor) {
+        throw new Error("Cannot find constructor for abstract DataType");
+    }
+    return structureInfo.constructor;
 }
 
+export async function resolveOpaqueStructureInExtentionObject(
+    session: IBasicSession,
+    dataTypeManager: ExtraDataTypeManager,
+    object: ExtensionObject
+) {
+    const schema = object.schema;
+    interface D {
+        dataTypeManager: ExtraDataTypeManager;
+        promises: Promise<void>[];
+    }
+    async function fixOpaqueStructureOnElement(
+        element: Record<string, unknown>,
+        field: StructuredTypeField,
+        data: D,
+        args?: any
+    ): Promise<unknown> {
+        if (element instanceof Variant) {
+            await resolveDynamicExtensionObject(session, element, dataTypeManager);
+            return element;
+        }
+        if (!(element instanceof OpaqueStructure)) {
+            return element;
+        }
+        const variant = new Variant({ dataType: DataType.ExtensionObject, value: element });
+        await resolveDynamicExtensionObject(session, variant, dataTypeManager);
+        return variant.value as unknown;
+    }
+    function fixOpaqueStructure(object: any, field: StructuredTypeField, data: D, args?: any) {
+         if (field.category === "complex"  && !field.allowSubType) {
+             return;
+        }
+        if (field.category === "basic"  && field.fieldType !== "Variant") {
+            return;
+        }
+        console.log("field", field.name, field.category, field.fieldType);
+        const a = object[field.name];
+        if (!a) {
+            return;
+        }
+        if (field.isArray) {
+            for (let i = 0; i < a.length; i++) {
+                const x = a[i];
+                promises.push(
+                    (async () => {
+                        a[i] = await fixOpaqueStructureOnElement(x, field, data, args);
+                    })()
+                );
+            }
+        } else {
+            promises.push(
+                (async () => {
+                    object[field.name] = await fixOpaqueStructureOnElement(a, field, data, args);
+                })()
+            );
+        }
+    }
+    const promises: Promise<void>[] = [];
+    object.applyOnAllFields<D>(fixOpaqueStructure, { dataTypeManager, promises });
+    await Promise.all(promises);
+}
+
+// async function resolveInnerVariantType(session: IBasicSession, object: ExtensionObject, dataTypeManager: ExtraDataTypeManager) {
+//     console.log("object = ", object.constructor.name);
+
+//     const fields = object.schema.fields;
+//     const _object = object as unknown as Record<string, unknown>;
+//     for (const field of fields) {
+//         console.log("field = ", field.name);
+//         if (field.category !== "complex") continue;
+//         const p = _object[field.name];
+//         if (p === undefined || p === null) continue;
+//         console.log("=>", field.name, (p as any).toString());
+//         if (p instanceof ExtensionObject) {
+//             resolveInnerVariantType(session, p, dataTypeManager);
+//         }
+//         if (p instanceof Variant && p.value instanceof OpaqueStructure) {
+//             console.log("§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§§");
+//             p.value = resolveDynamicExtensionObjectV(session, p.value, dataTypeManager);
+//         }
+//     }
+// }
 async function resolveDynamicExtensionObjectV(
     session: IBasicSession,
     opaque: OpaqueStructure,
@@ -60,11 +147,12 @@ async function resolveDynamicExtensionObjectV(
         const stream = new BinaryStream(opaque.buffer);
         try {
             object.decode(stream);
-            return object as ExtensionObject;
+            await resolveOpaqueStructureInExtentionObject(session, dataTypeManager, object);
+            return object;
         } catch (err) {
             warningLog("Constructor = ", Constructor.name);
             warningLog("opaqueStructure = ", opaque?.nodeId?.toString());
-            warningLog("opaqueStructure = ", "0x" + opaque?.buffer?.toString("hex"));
+            warningLog("opaqueStructure = ", hexDump(opaque.buffer,132,100));
             warningLog(hexDump(opaque.buffer));
             warningLog("resolveDynamicExtensionObjectV err = ", err);
             // try again for debugging
@@ -74,7 +162,7 @@ async function resolveDynamicExtensionObjectV(
     } catch (err) {
         warningLog("err", err);
         warningLog("opaqueStructure = ", opaque.nodeId.toString());
-        warningLog("opaqueStructure = ", "0x" + opaque.buffer.toString("hex"));
+        warningLog("opaqueStructure = ", "0x" + hexDump(opaque.buffer,132,100));
         warningLog(hexDump(opaque.buffer));
         warningLog(dataTypeManager.toString());
         throw err;

package/test/test_convertStructureTypeSchemaToStructureDefinition.ts

@@ -0,0 +1,117 @@
+import "should";
+import * as should from "should";
+import { DataTypeFactory } from "node-opcua-factory";
+import { resolveNodeId } from "node-opcua-nodeid";
+import { parseBinaryXSDAsync } from "node-opcua-schemas";
+import { MockProvider } from "node-opcua-schemas/test/mock_id_provider";
+import { StructureType } from "node-opcua-types";
+import { DataType } from "node-opcua-variant";
+import { convertStructureTypeSchemaToStructureDefinition } from "..";
+
+const idProvider = new MockProvider();
+
+describe("test convertStructureTypeSchemaToStructureDefinition", function () {
+    it("should 1", async () => {
+        /**
+         *
+         */
+        const schema1 = `
+<?xml version="1.0" encoding="utf-8"?>
+<opc:TypeDictionary xmlns:opc="http://opcfoundation.org/BinarySchema/" TargetNamespace="urn:eclipse:milo:opcua:server:demo" DefaultByteOrder="LittleEndian">
+<opc:Import Namespace="http://opcfoundation.org/BinarySchema/"/>
+<opc:EnumeratedType LengthInBits="32" Name="CustomEnumType">
+    <opc:EnumeratedValue Name="Field0" Value="0"/>
+    <opc:EnumeratedValue Name="Field1" Value="1"/>
+    <opc:EnumeratedValue Name="Field2" Value="2"/>
+</opc:EnumeratedType>
+<opc:StructuredType Name="CustomUnionType">
+    <opc:Field Name="SwitchField" TypeName="opc:UInt32"/>
+    <opc:Field Name="foo" TypeName="opc:UInt32" SwitchField="SwitchField" SwitchValue="1"/>
+    <opc:Field Name="bar" TypeName="opc:String" SwitchField="SwitchField" SwitchValue="2"/>
+</opc:StructuredType>
+<opc:StructuredType Name="CustomStructType">
+    <opc:Field Name="foo" TypeName="opc:String"/>
+    <opc:Field Name="bar" TypeName="opc:UInt32"/>
+    <opc:Field Name="baz" TypeName="opc:Boolean"/>
+    <opc:Field Name="fiz" TypeName="CustomEnumType"/>
+    <opc:Field Name="poc" TypeName="CustomUnionType"/>
+</opc:StructuredType>
+<opc:StructuredType BaseType="ua:ExtensionObject" Name="StructWithOnlyOptionals">
+    <opc:Field TypeName="opc:Bit" Name="OptionalInt32Specified"/>
+    <opc:Field TypeName="opc:Bit" Name="OptionalStringArraySpecified"/>
+    <opc:Field Length="30" TypeName="opc:Bit" Name="Reserved1"/>
+    <opc:Field SwitchField="OptionalInt32Specified" TypeName="opc:Int32" Name="OptionalInt32"/>
+    <opc:Field SwitchField="OptionalStringArraySpecified" TypeName="opc:Int32" Name="NoOfOptionalStringArray"/>
+    <opc:Field SwitchField="OptionalStringArraySpecified" LengthField="NoOfOptionalStringArray" TypeName="opc:CharArray" Name="OptionalStringArray"/>
+</opc:StructuredType>
+<opc:StructuredType BaseType="ua:ExtensionObject" Name="StructureWithOptionalFields">
+    <opc:Field TypeName="opc:Bit" Name="OptionalInt32Specified"/>
+    <opc:Field TypeName="opc:Bit" Name="OptionalStringArraySpecified"/>
+    <opc:Field Length="30" TypeName="opc:Bit" Name="Reserved1"/>
+    <opc:Field TypeName="opc:Int32" Name="MandatoryInt32"/>
+    <opc:Field SwitchField="OptionalInt32Specified" TypeName="opc:Int32" Name="OptionalInt32"/>
+    <opc:Field TypeName="opc:Int32" Name="NoOfMandatoryStringArray"/>
+    <opc:Field LengthField="NoOfMandatoryStringArray" TypeName="opc:CharArray" Name="MandatoryStringArray"/>
+    <opc:Field SwitchField="OptionalStringArraySpecified" TypeName="opc:Int32" Name="NoOfOptionalStringArray"/>
+    <opc:Field LengthField="NoOfOptionalStringArray" SwitchField="OptionalStringArraySpecified" TypeName="opc:CharArray" Name="OptionalStringArray"/>
+</opc:StructuredType>
+
+</opc:TypeDictionary>
+`;
+
+        const dataTypeFactory = new DataTypeFactory([]);
+        await parseBinaryXSDAsync(schema1, idProvider, dataTypeFactory);
+
+        for (const f of dataTypeFactory.getStructureIterator()) {
+            const ss = convertStructureTypeSchemaToStructureDefinition(f.schema);
+        }
+
+        
+        // --------------------------------------------------------------------------
+        const a = dataTypeFactory.getStructureInfoByTypeName("CustomUnionType");
+        const customUnionType = convertStructureTypeSchemaToStructureDefinition(a.schema);
+        console.log(customUnionType.toString());
+
+        customUnionType.structureType.should.eql(StructureType.Union);
+        customUnionType.baseDataType.toString().should.eql("ns=0;i=0");
+
+        customUnionType.fields!.length.should.eql(2);
+       
+        customUnionType.fields![0].name!.should.eql("foo");
+        customUnionType.fields![0].dataType.toString().should.eql(resolveNodeId(DataType.UInt32).toString());
+        customUnionType.fields![0].valueRank.should.eql(-1);
+        customUnionType.fields![0].arrayDimensions!.should.eql([]);
+        customUnionType.fields![1].isOptional.should.eql(false);
+        should(customUnionType.fields![0].description.text).eql(null);
+        
+        customUnionType.fields![1].name!.should.eql("bar");
+        customUnionType.fields![1].dataType.toString().should.eql(resolveNodeId(DataType.String).toString());
+        customUnionType.fields![1].valueRank.should.eql(-1);
+        customUnionType.fields![1].arrayDimensions!.should.eql([]);
+        customUnionType.fields![1].isOptional.should.eql(false);        
+        should(customUnionType.fields![1].description.text).eql(null);
+        
+
+        // ----------------------------------------------------------------------- CustomStructType
+        const b = dataTypeFactory.getStructureInfoByTypeName("CustomStructType");
+        const customStructType = convertStructureTypeSchemaToStructureDefinition(b.schema);
+        console.log(customStructType.toString());
+
+        customStructType.structureType.should.eql(StructureType.Structure);
+        customStructType.baseDataType.toString().should.eql("ns=0;i=0");
+
+        customStructType.fields!.length.should.eql(5);
+     
+        customStructType.fields![0].name!.should.eql("foo");
+        customStructType.fields![0].dataType.toString().should.eql(resolveNodeId("String").toString());
+        customStructType.fields![1].name!.should.eql("bar");
+        customStructType.fields![1].dataType.toString().should.eql(resolveNodeId("UInt32").toString());
+        customStructType.fields![2].name!.should.eql("baz");
+        customStructType.fields![2].dataType.toString().should.eql(resolveNodeId("Boolean").toString());
+        customStructType.fields![3].name!.should.eql("fiz");
+        customStructType.fields![3].dataType.toString().should.eql("ns=0;i=0".toString());
+        customStructType.fields![4].name!.should.eql("poc");
+        customStructType.fields![4].dataType.toString().should.eql("ns=1;i=1".toString());
+    
+    });
+});