node-opcua-address-space 2.115.0 → 2.116.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.115.0",
+    "version": "2.116.0",
     "description": "pure nodejs OPCUA SDK - module address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -26,7 +26,7 @@
         "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-client-dynamic-extension-object": "2.116.0",
         "node-opcua-constants": "2.114.0",
         "node-opcua-crypto": "4.5.0",
         "node-opcua-data-access": "2.114.0",
@@ -41,7 +41,7 @@
         "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-pseudo-session": "2.116.0",
         "node-opcua-service-browse": "2.114.0",
         "node-opcua-service-call": "2.114.0",
         "node-opcua-service-history": "2.114.0",
@@ -84,7 +84,7 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "2a65943304091de9876f69db24b289c157612880",
+    "gitHead": "713ad387571a323c8d886ad1c907f50ad96a5e76",
     "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,26 @@ 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);
+    for (let index = 0; index < order.length; index++) {
+        const nodesetIndex = order[index];
+        const nodeset = nodesetDesc[nodesetIndex];
+        debugLog(" loading ", nodesetIndex, nodeset.xmlData.length);
+        for (const model of nodeset.namespaceModel.models) {
+            const ns = addressSpace.registerNamespace(model.modelUri) as NamespacePrivate;
+            ns.setRequiredModels(model.requiredModel);
+        }
+
         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

@@ -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";

package/src/ua_variable_impl.ts

@@ -94,6 +94,7 @@ import {
 } from "./ua_variable_impl_ext_obj";
 import { adjustDataValueStatusCode } from "./data_access/adjust_datavalue_status_code";
 import { _getBasicDataType } from "./get_basic_datatype";
+import { validateDataTypeCorrectness} from "./validate_data_type_correctness";
 
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
@@ -149,94 +150,6 @@ function is_Variant_or_StatusCode(v: any): boolean {
     return is_Variant(v) || is_StatusCode(v);
 }
 
-function _dataType_toUADataType(addressSpace: IAddressSpace, dataType: DataType): UADataType {
-    assert(addressSpace);
-    assert(dataType !== DataType.Null);
-
-    const dataTypeNode = addressSpace.findDataType(DataType[dataType]);
-    /* istanbul ignore next */
-    if (!dataTypeNode) {
-        throw new Error(" Cannot find DataType " + DataType[dataType] + " in address Space");
-    }
-    return dataTypeNode as UADataType;
-}
-/*=
- *
- * @param addressSpace
- * @param dataTypeNodeId : the nodeId matching the dataType of the destination variable.
- * @param variantDataType: the dataType of the variant to write to the destination variable
- * @param nodeId
- * @return {boolean} true if the variant dataType is compatible with the Variable DataType
- */
-function validateDataType(
-    addressSpace: IAddressSpace,
-    dataTypeNodeId: NodeId,
-    variantDataType: DataType,
-    nodeId: NodeId,
-    allowNulls: boolean
-): boolean {
-    if (variantDataType === DataType.ExtensionObject) {
-        return true;
-    }
-    if (variantDataType === DataType.Null && allowNulls) {
-        return true;
-    }
-    if (variantDataType === DataType.Null && !allowNulls) {
-        return false;
-    }
-    let builtInType: DataType;
-    let builtInUADataType: UADataType;
-
-    const destUADataType = addressSpace.findDataType(dataTypeNodeId)!;
-    assert(destUADataType instanceof UADataTypeImpl);
-
-    if (destUADataType.isAbstract || destUADataType.nodeId.namespace !== 0) {
-        builtInUADataType = destUADataType;
-    } else {
-        builtInType = addressSpace.findCorrespondingBasicDataType(destUADataType);
-        builtInUADataType = addressSpace.findDataType(builtInType)!;
-    }
-    assert(builtInUADataType instanceof UADataTypeImpl);
-
-    const enumerationUADataType = addressSpace.findDataType("Enumeration");
-    if (!enumerationUADataType) {
-        throw new Error("cannot find Enumeration DataType node in standard address space");
-    }
-    if (destUADataType.isSubtypeOf(enumerationUADataType)) {
-        // istanbul ignore next
-        if (doDebug) {
-            debugLog("destUADataType.", destUADataType.browseName.toString(), destUADataType.nodeId.toString());
-            debugLog(
-                "enumerationUADataType.",
-                enumerationUADataType.browseName.toString(),
-                enumerationUADataType.nodeId.toString()
-            );
-        }
-        return true;
-    }
-
-    // The value supplied for the attribute is not of the same type as the  value.
-    const variantUADataType = _dataType_toUADataType(addressSpace, variantDataType);
-    assert(variantUADataType instanceof UADataTypeImpl);
-
-    const dest_isSubTypeOf_variant = variantUADataType.isSubtypeOf(builtInUADataType);
-
-    /* istanbul ignore next */
-    if (doDebug) {
-        if (dest_isSubTypeOf_variant) {
-            /* istanbul ignore next*/
-            debugLog(chalk.green(" ---------- Type match !!! "), " on ", nodeId.toString());
-        } else {
-            /* istanbul ignore next*/
-            debugLog(chalk.red(" ---------- Type mismatch "), " on ", nodeId.toString());
-        }
-        debugLog(chalk.cyan(" Variable data Type is    = "), destUADataType.browseName.toString());
-        debugLog(chalk.cyan(" which matches basic Type = "), builtInUADataType.browseName.toString());
-        debugLog(chalk.yellow("        Actual   dataType = "), variantUADataType.browseName.toString());
-    }
-
-    return dest_isSubTypeOf_variant;
-}
 
 function default_func(this: UAVariable, dataValue1: DataValue, callback1: CallbackT<StatusCode>) {
     return _default_writable_timestamped_set_func.call(this, dataValue1, callback1);
@@ -1707,7 +1620,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
     }
 
     public _validate_DataType(variantDataType: DataType): boolean {
-        return validateDataType(this.addressSpace, this.dataType, variantDataType, this.nodeId, /* allow Nulls */ false);
+        return validateDataTypeCorrectness(this.addressSpace, this.dataType, variantDataType, /* allow Nulls */ false, this.nodeId);
     }
 
     public _internal_set_value(value: Variant): void {

package/src/validate_data_type_correctness.ts

@@ -0,0 +1,115 @@
+import chalk from "chalk";
+import { assert } from "node-opcua-assert";
+import { IAddressSpace, UADataType } from "node-opcua-address-space-base";
+import { DataType } from "node-opcua-basic-types";
+import { make_debugLog, make_warningLog, checkDebugFlag, make_errorLog } from "node-opcua-debug";
+import { NodeId } from "node-opcua-nodeid";
+
+const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
+
+function _dataType_toUADataType(addressSpace: IAddressSpace, dataType: DataType): UADataType {
+    assert(addressSpace);
+    assert(dataType !== DataType.Null);
+
+    const dataTypeNode = addressSpace.findDataType(DataType[dataType]);
+    /* istanbul ignore next */
+    if (!dataTypeNode) {
+        throw new Error(" Cannot find DataType " + DataType[dataType] + " in address Space");
+    }
+    return dataTypeNode as UADataType;
+}
+
+const validDataTypeForEnumValue = [DataType.Int32];
+// , DataType.UInt32, DataType.Int64, DataType.UInt64];
+
+/*=
+ *
+ * @param addressSpace
+ * @param dataTypeNodeId : the nodeId matching the dataType of the destination variable.
+ * @param variantDataType: the dataType of the variant to write to the destination variable
+ * @param nodeId
+ * @return {boolean} true if the variant dataType is compatible with the Variable DataType
+ */
+export function validateDataTypeCorrectness(
+    addressSpace: IAddressSpace,
+    dataTypeNodeId: NodeId,
+    variantDataType: DataType,
+    allowNulls: boolean,
+    context?: { toString(): string }
+): boolean {
+    if (variantDataType === DataType.Null && allowNulls) {
+        return true;
+    }
+    if (variantDataType === DataType.Null && !allowNulls) {
+        return false;
+    }
+    let builtInType: DataType;
+    let builtInUADataType: UADataType;
+
+    const destUADataType = addressSpace.findDataType(dataTypeNodeId)!;
+
+    // istanbul ignore next
+    if (!destUADataType) {
+        throw new Error("Cannot find UADataType " + dataTypeNodeId.toString() + " in address Space");
+    }
+
+    if (variantDataType === DataType.ExtensionObject) {
+        const structure = addressSpace.findDataType("Structure")!;
+        if (destUADataType.isSubtypeOf(structure)) {
+            return true;
+        }
+        return false;
+    }
+
+    if (destUADataType.isAbstract) {
+        builtInUADataType = destUADataType;
+    } else {
+        builtInType = addressSpace.findCorrespondingBasicDataType(destUADataType);
+        if (builtInType === DataType.ExtensionObject) {
+            // it should have been trapped earlier
+            return false;
+        }
+        builtInUADataType = addressSpace.findDataType(builtInType)!;
+    }
+
+    const enumerationUADataType = addressSpace.findDataType("Enumeration");
+    // istanbul ignore next
+    if (!enumerationUADataType) {
+        throw new Error("cannot find Enumeration DataType node in standard address space");
+    }
+    if (destUADataType.isSubtypeOf(enumerationUADataType)) {
+        // istanbul ignore next
+        if (doDebug) {
+            debugLog("destUADataType.", destUADataType.browseName.toString(), destUADataType.nodeId.toString());
+            debugLog(
+                "enumerationUADataType.",
+                enumerationUADataType.browseName.toString(),
+                enumerationUADataType.nodeId.toString()
+            );
+        }
+
+        return validDataTypeForEnumValue.indexOf(variantDataType) >= 0;
+    }
+
+    // The value supplied for the attribute is not of the same type as the  value.
+    const variantUADataType = _dataType_toUADataType(addressSpace, variantDataType);
+
+    const dest_isSubTypeOf_variant = variantUADataType.isSubtypeOf(builtInUADataType);
+
+    // istanbul ignore next
+    if (doDebug) {
+        if (dest_isSubTypeOf_variant) {
+            /* istanbul ignore next*/
+            debugLog(chalk.green(" ---------- Type match !!! "), " on ", context?.toString());
+        } else {
+            /* istanbul ignore next*/
+            debugLog(chalk.red(" ---------- Type mismatch "), " on ", context?.toString());
+        }
+        debugLog(chalk.cyan(" Variable data Type is    = "), destUADataType.browseName.toString());
+        debugLog(chalk.cyan(" which matches basic Type = "), builtInUADataType.browseName.toString());
+        debugLog(chalk.yellow("        Actual   dataType = "), variantUADataType.browseName.toString());
+    }
+
+    return dest_isSubTypeOf_variant;
+}