node-opcua-address-space 2.115.0 → 2.117.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.115.0",
+    "version": "2.117.0",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -16,42 +16,42 @@
         "c": "mocha --version"
     },
     "dependencies": {
-        "@types/lodash": "4.14.199",
-        "@types/semver": "^7.5.3",
-        "async": "^3.2.4",
+        "@types/lodash": "4.14.201",
+        "@types/semver": "^7.5.5",
+        "async": "^3.2.5",
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space-base": "2.114.0",
+        "node-opcua-address-space-base": "2.117.0",
         "node-opcua-assert": "2.105.0",
-        "node-opcua-basic-types": "2.114.0",
-        "node-opcua-binary-stream": "2.114.0",
-        "node-opcua-client-dynamic-extension-object": "2.114.0",
+        "node-opcua-basic-types": "2.117.0",
+        "node-opcua-binary-stream": "2.117.0",
+        "node-opcua-client-dynamic-extension-object": "2.117.0",
         "node-opcua-constants": "2.114.0",
         "node-opcua-crypto": "4.5.0",
-        "node-opcua-data-access": "2.114.0",
-        "node-opcua-data-model": "2.114.0",
-        "node-opcua-data-value": "2.114.0",
-        "node-opcua-date-time": "2.114.0",
-        "node-opcua-debug": "2.114.0",
-        "node-opcua-enum": "2.114.0",
-        "node-opcua-extension-object": "2.114.0",
-        "node-opcua-factory": "2.114.0",
-        "node-opcua-nodeid": "2.114.0",
-        "node-opcua-nodeset-ua": "2.114.0",
-        "node-opcua-numeric-range": "2.114.0",
-        "node-opcua-object-registry": "2.114.0",
-        "node-opcua-pseudo-session": "2.114.0",
-        "node-opcua-service-browse": "2.114.0",
-        "node-opcua-service-call": "2.114.0",
-        "node-opcua-service-history": "2.114.0",
-        "node-opcua-service-translate-browse-path": "2.114.0",
-        "node-opcua-service-write": "2.114.0",
-        "node-opcua-status-code": "2.114.0",
-        "node-opcua-types": "2.114.0",
-        "node-opcua-utils": "2.114.0",
-        "node-opcua-variant": "2.114.0",
-        "node-opcua-xml2json": "2.114.0",
+        "node-opcua-data-access": "2.117.0",
+        "node-opcua-data-model": "2.117.0",
+        "node-opcua-data-value": "2.117.0",
+        "node-opcua-date-time": "2.117.0",
+        "node-opcua-debug": "2.117.0",
+        "node-opcua-enum": "2.117.0",
+        "node-opcua-extension-object": "2.117.0",
+        "node-opcua-factory": "2.117.0",
+        "node-opcua-nodeid": "2.117.0",
+        "node-opcua-nodeset-ua": "2.117.0",
+        "node-opcua-numeric-range": "2.117.0",
+        "node-opcua-object-registry": "2.117.0",
+        "node-opcua-pseudo-session": "2.117.0",
+        "node-opcua-service-browse": "2.117.0",
+        "node-opcua-service-call": "2.117.0",
+        "node-opcua-service-history": "2.117.0",
+        "node-opcua-service-translate-browse-path": "2.117.0",
+        "node-opcua-service-write": "2.117.0",
+        "node-opcua-status-code": "2.117.0",
+        "node-opcua-types": "2.117.0",
+        "node-opcua-utils": "2.117.0",
+        "node-opcua-variant": "2.117.0",
+        "node-opcua-xml2json": "2.117.0",
         "semver": "^7.5.4",
         "set-prototype-of": "^1.0.0",
         "thenify": "^3.3.1",
@@ -59,14 +59,14 @@
     },
     "devDependencies": {
         "mocha": "^10.2.0",
-        "node-opcua-benchmarker": "2.114.0",
-        "node-opcua-leak-detector": "2.114.0",
+        "node-opcua-benchmarker": "2.117.0",
+        "node-opcua-leak-detector": "2.117.0",
         "node-opcua-nodesets": "2.110.0",
-        "node-opcua-packet-analyzer": "2.114.0",
-        "node-opcua-service-filter": "2.114.0",
-        "node-opcua-test-fixtures": "2.114.0",
+        "node-opcua-packet-analyzer": "2.117.0",
+        "node-opcua-service-filter": "2.117.0",
+        "node-opcua-test-fixtures": "2.117.0",
         "should": "^13.2.3",
-        "sinon": "^16.0.0",
+        "sinon": "^17.0.1",
         "source-map-support": "^0.5.21"
     },
     "author": "Etienne Rossignon",
@@ -84,7 +84,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "2a65943304091de9876f69db24b289c157612880",
+    "gitHead": "99ed7589a203923985c25be8907b36485c798bbe",
     "files": [
         "dist",
         "distHelpers",

package/source/helpers/call_helpers.ts

@@ -8,6 +8,7 @@ import { CallMethodRequest } from "node-opcua-service-call";
 import { StatusCode, StatusCodes } from "node-opcua-status-code";
 import { CallMethodResultOptions } from "node-opcua-types";
 import { Variant } from "node-opcua-variant";
+import { ResponseCallback } from "node-opcua-pseudo-session";
 import { ISessionContext, IAddressSpace, UAMethod, UAObject } from "node-opcua-address-space-base";
 
 import { getMethodDeclaration_ArgumentList, verifyArguments_ArgumentList } from "./argument_list";
@@ -28,7 +29,6 @@ import { resolveOpaqueOnAddressSpace } from "./resolve_opaque_on_address_space";
 //                               A ByteString is structurally the same as a one dimensional array of Byte.
 //                               A server shall accept a ByteString if an array of Byte is expected.
 // BadNoCommunication
-type ResponseCallback<T> = (err: Error | null, result?: T) => void;
 
 export function callMethodHelper(
     context: ISessionContext,

package/source/index.ts

@@ -41,7 +41,7 @@ export { promoteToMultiStateDiscrete } from "../src/data_access/ua_multistate_di
 export { promoteToMultiStateValueDiscrete } from "../src/data_access/ua_multistate_value_discrete_impl";
 export { promoteToTwoStateDiscrete } from "../src/data_access/ua_two_state_discrete_impl";
 export { validateDataType } from "../src/data_access/ua_multistate_value_discrete_impl";
-
+export { validateDataTypeCorrectness  } from "../src/validate_data_type_correctness";
 export * from "./ua_root_folder";
 export * from "./session_context";
 export * from "./pseudo_session";

package/source/loader/generateAddressSpaceRaw.ts

@@ -1,15 +1,173 @@
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
 import { CallbackT } from "node-opcua-status-code";
-import { IAddressSpace } from "node-opcua-address-space-base";
-
+import { IAddressSpace, RequiredModel } from "node-opcua-address-space-base";
+import { ReaderStateParserLike, Xml2Json } from "node-opcua-xml2json";
+import { minDate } from "node-opcua-date-time";
 import { adjustNamespaceArray } from "../../src/nodeset_tools/adjust_namespace_array";
 import { NodeSetLoaderOptions } from "../interfaces/nodeset_loader_options";
+import { NamespacePrivate } from "../../src/namespace_private";
 import { NodeSetLoader } from "./load_nodeset2";
 
 const doDebug = checkDebugFlag(__filename);
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
 
+interface Model extends RequiredModel {
+    requiredModel: RequiredModel[];
+}
+interface NodesetInfo {
+    namespaceUris: string[];
+    models: Model[];
+}
+
+async function parseDependencies(xmlData: string): Promise<NodesetInfo> {
+    const namespaceUris: string[] = [];
+
+    const models: Model[] = [];
+    let currentModel: Model | undefined = undefined;
+    const state0: ReaderStateParserLike = {
+        parser: {
+            UANodeSet: {
+                parser: {
+                    NamespaceUris: {
+                        parser: {
+                            Uri: {
+                                finish() {
+                                    namespaceUris.push(this.text);
+                                }
+                            }
+                        }
+                    },
+                    Models: {
+                        parser: {
+                            Model: {
+                                init(elementName: string, attrs: any) {
+                                    const modelUri = attrs.ModelUri;
+                                    const version = attrs.Version;
+                                    const publicationDate = new Date(Date.parse(attrs.PublicationDate));
+                                    currentModel = {
+                                        modelUri,
+                                        version,
+                                        publicationDate,
+                                        requiredModel: []
+                                    };
+                                    doDebug && console.log(`currentModel = ${JSON.stringify(currentModel)}`);
+                                    models.push(currentModel);
+                                },
+                                parser: {
+                                    RequiredModel: {
+                                        init(elementName: string, attrs: any) {
+                                            const modelUri = attrs.ModelUri;
+                                            const version = attrs.Version;
+                                            const publicationDate = new Date(Date.parse(attrs.PublicationDate));
+
+                                            if (!currentModel) {
+                                                throw new Error("Internal Error");
+                                            }
+                                            currentModel.requiredModel.push({
+                                                modelUri,
+                                                version,
+                                                publicationDate
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+    const parser = new Xml2Json(state0);
+    parser.parseStringSync(xmlData);
+    if (models.length === 0 && namespaceUris.length >= 1) {
+        models.push({
+            modelUri: namespaceUris[0],
+            version: "1",
+            publicationDate: minDate,
+            requiredModel: []
+        });
+    }
+    return { models, namespaceUris: namespaceUris };
+}
+interface NodesetDesc {
+    index: number;
+    xmlData: string;
+    namespaceModel: NodesetInfo;
+}
+/**
+ * Detect order of namespace loading
+ */
+export async function preLoad(xmlFiles: string[], xmlLoader: (nodeset2xmlUri: string) => Promise<string>): Promise<NodesetDesc[]> {
+    // a nodeset2 file may define multiple namespaces
+    const namespaceDesc: NodesetDesc[] = [];
+    for (let index = 0; index < xmlFiles.length; index++) {
+        doDebug && console.log("---------------------------------------------", xmlFiles[index]);
+        const xmlData = await xmlLoader(xmlFiles[index]);
+
+        const indexStart = xmlData.match(/<UANodeSet/m)?.index;
+        const i1 = (xmlData.match(/<\/Models>/m)?.index || 0) + "</Models>".length;
+        const i2 = (xmlData.match(/<\/NamespaceUris>/m)?.index || 0) + "</NamespaceUris>".length;
+
+        const indexEnd = Math.max(i1, i2);
+        if (indexStart === undefined || indexEnd === undefined) {
+            throw new Error("Internal Error");
+        }
+        const xmlData2 = xmlData.substring(indexStart, indexEnd);
+        doDebug &&
+            console.log(
+                xmlData2
+                    .split("\n")
+                    .splice(0, 46)
+                    .map((x, i) => `${i + 0} ${x}`)
+                    .join("\n")
+            );
+        const namespaceModel = await parseDependencies(xmlData2);
+        namespaceDesc.push({ xmlData, namespaceModel, index });
+    }
+    return namespaceDesc;
+}
+export function findOrder(nodesetDescs: NodesetDesc[]): number[] {
+    // compute the order of loading of the namespaces
+    const order: number[] = [];
+    const visited: Set<string> = new Set<string>();
+
+    const findNodesetIndex = (namespaceUri: string) => {
+        const index = nodesetDescs.findIndex((x) => x.namespaceModel.models.findIndex((e) => e.modelUri === namespaceUri) !== -1);
+        return index;
+    };
+    const visit = (model: Model) => {
+        const key = model.modelUri;
+        if (visited.has(key)) {
+            return;
+        }
+        visited.add(key);
+        for (const requiredModel of model.requiredModel) {
+            const requiredModelIndex = findNodesetIndex(requiredModel.modelUri);
+            if (requiredModelIndex === -1) {
+                throw new Error("Cannot find namespace for " + requiredModel.modelUri);
+            }
+            const nd = nodesetDescs[requiredModelIndex];
+            for (const n of nd.namespaceModel.models) {
+                visit(n);
+            }
+        }
+        const nodesetIndex = findNodesetIndex(model.modelUri);
+        const alreadyIn = order.findIndex((x) => x === nodesetIndex) !== -1;
+        if (!alreadyIn) order.push(nodesetIndex);
+    };
+    const visit2 = (nodesetDesc: NodesetDesc) => {
+        for (const model of nodesetDesc.namespaceModel.models.values()) {
+            visit(model);
+        }
+    };
+    for (let index = 0; index < nodesetDescs.length; index++) {
+        const nodesetDesc = nodesetDescs[index];
+        visit2(nodesetDesc);
+    }
+    return order;
+}
 /**
  * @param addressSpace the addressSpace to populate
  * @xmlFiles: a lis of xml files
@@ -26,15 +184,32 @@ export async function generateAddressSpaceRaw(
     if (!Array.isArray(xmlFiles)) {
         xmlFiles = [xmlFiles];
     }
-    for (let index = 0; index < xmlFiles.length; index++) {
-        const xmlData = await xmlLoader(xmlFiles[index]);
+
+    const nodesetDesc = await preLoad(xmlFiles, xmlLoader);
+    const order = findOrder(nodesetDesc);
+
+    // register namespace in the same order as specified in the xmlFiles array
+    for (let index = 0; index < order.length; index++) {
+        const n = nodesetDesc[index];
+        for (const model of n.namespaceModel.models) {
+            const ns = addressSpace.registerNamespace(model.modelUri) as NamespacePrivate;
+            ns.setRequiredModels(model.requiredModel);
+        }
+    }
+
+
+    for (let index = 0; index < order.length; index++) {
+        const nodesetIndex = order[index];
+        const nodeset = nodesetDesc[nodesetIndex];
+        debugLog(" loading ", nodesetIndex, nodeset.xmlData.length);
         try {
-            await nodesetLoader.addNodeSetAsync(xmlData);
+            await nodesetLoader.addNodeSetAsync(nodeset.xmlData);
         } catch (err) {
             errorLog("generateAddressSpace:  Loading xml file ", xmlFiles[index], " failed with error ", (err as Error).message);
             throw err;
         }
     }
+
     await nodesetLoader.terminateAsync();
     adjustNamespaceArray(addressSpace);
     // however process them in series

package/source/loader/load_nodeset2.ts

@@ -194,8 +194,8 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
 
         // istanbul ignore next
         if (namespaceIndex === undefined) {
-            debugLog("Warning: namespace_uri_translation = ", namespace_uri_translation);
-            errorLog("namespace_uri_translation", namespace_uri_translation);
+            errorLog("Warning: namespace_uri_translation = ", namespace_uri_translation);
+            errorLog("Error; namespace_uri_translation", namespace_uri_translation);
             throw new Error("_translateNamespaceIndex() ! Cannot find namespace definition for index " + innerIndex);
         }
         return namespaceIndex;
@@ -306,13 +306,7 @@ function makeNodeSetParserEngine(addressSpace: IAddressSpace, options: NodeSetLo
         // Model must not be already registered
         const existingNamespace = addressSpace1.getNamespace(model.modelUri);
         if (existingNamespace) {
-            // special treatment for namespace 0
-            // istanbul ignore else
-            if (model.modelUri === "http://opcfoundation.org/UA/") {
-                namespace = existingNamespace;
-            } else {
-                throw new Error(" namespace already registered " + model.modelUri);
-            }
+            namespace = existingNamespace;
         } else {
             namespace = addressSpace1.registerNamespace(model.modelUri);
             namespace.setRequiredModels(model.requiredModels);

package/src/index_current.ts

@@ -12,8 +12,8 @@ export * from "../source/helpers/call_helpers";
 export * from "../source/helpers/ensure_secure_access";
 export * from "../source/helpers/resolve_opaque_on_address_space";
 export * from "../source/interfaces/alarms_and_conditions/condition_info_i";
-
 export * from "../src/nodeset_tools/construct_namespace_dependency";
+export * from "../src/validate_data_type_correctness";
 
 
 export * from "../source/set_namespace_meta_data";