node-opcua-address-space 2.86.1 → 2.87.0

package/src/nodeid_manager.ts

@@ -3,12 +3,12 @@
 import { assert } from "node-opcua-assert";
 import { NodeClass, QualifiedName } from "node-opcua-data-model";
 import { makeNodeId, NodeId, NodeIdLike, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
-import { make_debugLog } from "node-opcua-debug";
-
+import { make_debugLog, make_warningLog } from "node-opcua-debug";
 import { BaseNode, UAReference, UAReferenceType } from "node-opcua-address-space-base";
 import { getReferenceType } from "./base_node_impl";
 
 const debugLog = make_debugLog(__filename);
+const warningLog = make_warningLog(__filename);
 
 export const NamespaceOptions = {
     nodeIdNameSeparator: "-"
@@ -21,13 +21,17 @@ const regExp1 = /^(s|i|b|g)=/;
 const regExp2 = /^ns=[0-9]+;(s|i|b|g)=/;
 const hasPropertyRefId = resolveNodeId("HasProperty");
 const hasComponentRefId = resolveNodeId("HasComponent");
+const hasOrderedComponentRefId = resolveNodeId("HasOrderedComponent");
 const hasEncoding = resolveNodeId("HasEncoding");
 
-function _identifyParentInReference(references: UAReference[]): [NodeId, string] | null {
+type Suffix = string;
+
+function _identifyParentInReference(references: UAReference[]): [NodeId, Suffix] | null {
     const candidates = references.filter((r: UAReference) => {
         return (
             !r.isForward &&
             (sameNodeId(r.referenceType, hasComponentRefId) ||
+                sameNodeId(r.referenceType, hasOrderedComponentRefId) ||
                 sameNodeId(r.referenceType, hasPropertyRefId) ||
                 sameNodeId(r.referenceType, hasEncoding))
         );
@@ -43,6 +47,27 @@ function _identifyParentInReference(references: UAReference[]): [NodeId, string]
     return [ref.nodeId, ""];
 }
 
+function _findParentNodeId(addressSpace: AddressSpacePartial, options: ConstructNodeIdOptions): [NodeId, Suffix] | null {
+    if (!options.references) {
+        return null;
+    }
+    for (const ref of options.references) {
+        (ref as any)._referenceType = addressSpace.findReferenceType(ref.referenceType);
+        /* istanbul ignore next */
+        if (!getReferenceType(ref)) {
+            throw new Error("Cannot find referenceType " + JSON.stringify(ref));
+        }
+        (ref as any).referenceType = (ref as any)._referenceType.nodeId;
+    }
+    // find HasComponent, or has Property reverse
+    return _identifyParentInReference(options.references);
+}
+
+function prepareName(browseName: QualifiedName): string {
+    const m = browseName.name!.toString().replace(/[ ]/g, "").replace(/(<|>)/g, "");
+    return m;
+}
+
 export interface AddressSpacePartial {
     findNode(nodeId: NodeIdLike): BaseNode | null;
     findReferenceType(refType: NodeIdLike, namespaceIndex?: number): UAReferenceType | null;
@@ -58,8 +83,8 @@ export type NodeEntry = [string, number, NodeClass];
 export type NodeEntry1 = [string, number, string /*"Object" | "Variable" etc...*/];
 
 export class NodeIdManager {
-    private _cache: { [key: string]: number } = {};
-    private _reverseCache: { [key: number]: { name: string; nodeClass: NodeClass } } = {};
+    private _cacheSymbolicName: { [key: string]: [number,NodeClass] } = {};
+    private _cacheSymbolicNameRev: Set<number> = new Set<number>();
 
     private _internal_id_counter: number;
     private namespaceIndex: number;
@@ -71,14 +96,6 @@ export class NodeIdManager {
         this.addressSpace = addressSpace;
     }
 
-    public setCache(cache: NodeEntry[]): void {
-        this._cache = {};
-        this._reverseCache = {};
-        for (const [key, value, nodeClass] of cache) {
-            this._addInCache(key, value, nodeClass);
-        }
-    }
-
     public setSymbols(symbols: NodeEntry1[]): void {
         function convertNodeClass(nodeClass: string): NodeClass {
             return (NodeClass as any)[nodeClass as any] as NodeClass;
@@ -88,13 +105,17 @@ export class NodeIdManager {
             number,
             NodeClass
         ][];
-        this.setCache(symbols2);
+        for (const [name, value, nodeClass] of symbols2) {
+            this._cacheSymbolicName[name] = [value, nodeClass];
+            this._cacheSymbolicNameRev.add(value);
+        }
     }
 
     public getSymbols(): NodeEntry1[] {
         const line: NodeEntry1[] = [];
-        for (const [key, value] of Object.entries(this._cache)) {
-            const nodeClass = NodeClass[this._reverseCache[value].nodeClass];
+        for (const [key, [value, nodeClass1]] of Object.entries(this._cacheSymbolicName)) {
+            const node = this.addressSpace.findNode(makeNodeId(value, this.namespaceIndex));
+            const nodeClass = NodeClass[nodeClass1 || NodeClass.Unspecified];
             line.push([key, value, nodeClass]);
         }
         return line;
@@ -113,18 +134,51 @@ export class NodeIdManager {
         do {
             nodeId = makeNodeId(this._internal_id_counter, this.namespaceIndex);
             this._internal_id_counter += 1;
-        } while (this.addressSpace.findNode(nodeId) || this._isInCache(nodeId.value as number));
+        } while (this.addressSpace.findNode(nodeId) || this._isInCache(nodeId));
         return nodeId;
     }
 
     public constructNodeId(options: ConstructNodeIdOptions): NodeId {
-        function prepareName(browseName: QualifiedName): string {
-            const m = browseName.name!.toString().replace(/[ ]/g, "").replace(/(<|>)/g, "");
-            return m;
+
+        const compose = (left: string, right: string) => { return right ? (left ? left + '_' + right : right) : left };
+
+        const buildUpName2 = (nodeId: NodeId, suffix: string) => {
+            const namespaceIndex = nodeId.namespace;
+            let name = "";
+            let n: BaseNode | null = this.addressSpace.findNode(nodeId);
+            while (n && n.nodeId.namespace === namespaceIndex) {
+                const e = prepareName(n.browseName) + suffix;
+                name = compose(e, name);
+                n = n.parentNodeId ? this.addressSpace.findNode(n.parentNodeId) : null;
+            }
+            return name;
         }
-        let nodeId = options.nodeId;
-        const nodeClass = options.nodeClass;
 
+        if (!options.nodeId && options.registerSymbolicNames) {
+            const parentInfo = this.findParentNodeId(options);
+            let fullParentName = "";
+            if (parentInfo) {
+                const [parentNodeId, suffix] = parentInfo;
+                fullParentName = buildUpName2(parentNodeId, suffix);
+            }
+            const fullName = compose(fullParentName, prepareName(options.browseName));
+            if (this._cacheSymbolicName[fullName]) {
+                return makeNodeId(this._cacheSymbolicName[fullName][0], this.namespaceIndex);
+            }
+            const nodeId = this._constructNodeId(options);
+            if (nodeId.identifierType === NodeIdType.NUMERIC) {
+                this._cacheSymbolicName[fullName] = [nodeId.value as number, options.nodeClass];
+                this._cacheSymbolicNameRev.add(nodeId.value as number);
+            }
+            return nodeId;
+        }
+        return this._constructNodeId(options);
+    }
+ 
+    private _constructNodeId(options: ConstructNodeIdOptions): NodeId {
+
+        let nodeId = options.nodeId;
+  
         if (!nodeId) {
             const parentInfo = this.findParentNodeId(options);
             if (parentInfo) {
@@ -136,41 +190,7 @@ export class NodeIdManager {
                     const childName = parentNodeId.value + NamespaceOptions.nodeIdNameSeparator + name;
                     nodeId = new NodeId(NodeId.NodeIdType.STRING, childName, parentNodeId.namespace);
                     return nodeId;
-                } else if (parentNodeId.identifierType === NodeId.NodeIdType.NUMERIC) {
-                    //
-                    const baseNameInCache = this._reverseCache[parentNodeId.value as number];
-                    if (baseNameInCache) {
-                        const newName = baseNameInCache.name + linkName + "_" + name;
-                        const nodeIdValueInCache = this._cache[newName];
-                        if (nodeIdValueInCache) {
-                            return new NodeId(NodeIdType.NUMERIC, nodeIdValueInCache, this.namespaceIndex);
-                        } else {
-                            return this._getOrCreateFromName(newName, nodeClass);
-                        }
-                    } else {
-                        if (options.registerSymbolicNames) {
-                            const newName = name;
-                            const nodeIdValueInCache = this._cache[newName];
-                            if (nodeIdValueInCache) {
-                                return new NodeId(NodeIdType.NUMERIC, nodeIdValueInCache, this.namespaceIndex);
-                            } else {
-                                return this._getOrCreateFromName(newName, nodeClass);
-                            }
-                        }
-                    }
-                }
-                // }} has parent ...
-            } else {
-                const isRootType =
-                    options.nodeClass === NodeClass.DataType ||
-                    options.nodeClass === NodeClass.ObjectType ||
-                    options.nodeClass === NodeClass.ReferenceType ||
-                    options.nodeClass === NodeClass.VariableType;
-                // try to find
-                if (isRootType) {
-                    const baseName = options.browseName.name!.toString();
-                    return this._getOrCreateFromName(baseName, nodeClass);
-                }
+                } 
             }
         } else if (typeof nodeId === "string") {
             if (this.namespaceIndex !== 0) {
@@ -178,8 +198,8 @@ export class NodeIdManager {
                     // nothing
                 } else if (nodeId.match(regExp1)) {
                     nodeId = "ns=" + this.namespaceIndex + ";" + nodeId;
-                } else {
-                    nodeId = this._getOrCreateFromName(nodeId, nodeClass);
+                    // } else {
+                    //     nodeId = this._getOrCreateFromName(nodeId, nodeClass);
                 }
             }
         }
@@ -193,48 +213,12 @@ export class NodeIdManager {
         return nodeId;
     }
 
-    public findParentNodeId(options: ConstructNodeIdOptions): [NodeId, string] | null {
-        if (!options.references) {
-            return null;
-        }
-        for (const ref of options.references) {
-            (ref as any)._referenceType = this.addressSpace.findReferenceType(ref.referenceType);
-            /* istanbul ignore next */
-            if (!getReferenceType(ref)) {
-                throw new Error("Cannot find referenceType " + JSON.stringify(ref));
-            }
-            (ref as any).referenceType = (ref as any)._referenceType.nodeId;
-        }
-        // find HasComponent, or has Property reverse
-        return _identifyParentInReference(options.references);
-    }
-
-    private _addInCache(name: string, nodeIdValue: number, nodeClass: NodeClass) {
-        assert(!name.includes(":"), "Alias name should not contain special characters");
-        assert(typeof name === "string" && name[0] !== "[");
-        if (this._isInCache(nodeIdValue) || this._cache[name]) {
-            throw new Error("Already in Cache !" + name + " " + nodeIdValue + " = " + this._cache[name]);
-        }
-        this._cache[name] = nodeIdValue;
-        this._reverseCache[nodeIdValue] = { name, nodeClass };
-    }
-
-    private _isInCache(nodeIdValue: number) {
-        return this._reverseCache[nodeIdValue] ? true : false;
+    public findParentNodeId(options: ConstructNodeIdOptions): [NodeId, Suffix] | null {
+        return _findParentNodeId(this.addressSpace, options);
     }
 
-    private _getOrCreateFromName(aliasName: string, nodeClass: NodeClass): NodeId {
-        assert(isValidNodeClass(nodeClass), "invalid node class " + nodeClass);
-        if (aliasName.includes(":")) {
-            debugLog("alias name should not contain special characters");
-        }
-        assert(!aliasName.includes(":"), "Alias name should not contain special characters");
-        if (this._cache[aliasName]) {
-            return new NodeId(NodeIdType.NUMERIC, this._cache[aliasName], this.namespaceIndex);
-        } else {
-            const nodeIdResult = this.buildNewNodeId();
-            this._addInCache(aliasName, nodeIdResult.value as number, nodeClass);
-            return nodeIdResult;
-        }
+    private _isInCache(nodeId: NodeId): boolean {
+        if( nodeId.namespace !== this.namespaceIndex || nodeId.identifierType !== NodeIdType.NUMERIC) return false;
+        return this._cacheSymbolicNameRev.has(nodeId.value as number) ? true : false;
     }
 }

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -19,7 +19,7 @@ function _constructNamespaceDependency(
     // navigate all namespace recursively to
 
     function consider(namespaceIndex: number) {
-        if (hasHigherPriorityThan(namespaceIndex,namespace.index, priorityTable)) {
+        if (hasHigherPriorityThan(namespaceIndex, namespace.index, priorityTable)) {
             return;
         }
         if (!depMap.has(namespaceIndex)) {
@@ -48,7 +48,7 @@ function _constructNamespaceDependency(
         }
         // istanbul ignore next
         if (dataTypeNode.nodeClass !== NodeClass.DataType) {
-            warningLog("exploreDataTypes! ignoring ",dataTypeNode.toString());
+            warningLog("exploreDataTypes! ignoring ", dataTypeNode.toString());
             return;
         }
 
@@ -94,19 +94,33 @@ export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2:
     return order1 > order2;
 }
 
+/**
+ * 
+ * @param namespace 
+ * @returns the order 
+ * 
+ *      ---
+ *  ua, own , di  => 0 , 2,  1
+ * 
+ *      ---
+ *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3, 1
+ * 
+ *                           ---
+ *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3,  5, 1
+ */
 export function constructNamespacePriorityTable(namespace: INamespace): number[] {
 
     // Namespace 0 will always be 0 
     // Namespaces with no requiredModel will be considered as instance namespaces and will added at the end
     // in the same order as they appear,
     // Namespace with requiredModels are considered to be companion specification, so already loaded in the correct order
- 
+
     const addressSpace = namespace.addressSpace;
     const namespaces = addressSpace.getNamespaceArray();
 
-    const namespaceWithReq = namespaces.filter((n)=> (n.getRequiredModels() !== undefined)  && n.index !==0);
-    const namespaceWithoutReq = namespaces.filter((n)=>(n.getRequiredModels() === undefined) && n.index !==0);
-    
+    const namespaceWithReq = namespaces.filter((n) => (n.getRequiredModels() !== undefined) && n.index !== 0);
+    const namespaceWithoutReq = namespaces.filter((n) => (n.getRequiredModels() === undefined) && n.index !== 0);
+
     const priorityList: number[] = [0];
     let counter = 1;
     for (let i = 0; i < namespaceWithReq.length; i++) {
@@ -117,10 +131,10 @@ export function constructNamespacePriorityTable(namespace: INamespace): number[]
     }
     return priorityList;
 }
-
+const doDebug = false;
 export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
     const addressSpace = namespace.addressSpace;
-   
+
     priorityTable = priorityTable || constructNamespacePriorityTable(namespace);
 
     const dependency: INamespace[] = [];
@@ -137,5 +151,12 @@ export function constructNamespaceDependency(namespace: INamespace, priorityTabl
 
     _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
 
-    return dependency;
+    doDebug && console.log("namespace : ", namespace.index, namespace.namespaceUri);
+    doDebug && console.log("   ", dependency.map((d)=>d.index + " " + d.namespaceUri).join("\n   "));
+
+    const sorted = dependency.sort((a, b) => priorityTable![a.index] < priorityTable![b.index] ? -1 : 1);
+    doDebug && console.log("sorted:")
+    doDebug && console.log("   ", sorted.map((d)=>d.index + " " + d.namespaceUri).join("\n   "));
+
+    return sorted;
 }

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -61,6 +61,7 @@ const XMLWriter = require("xml-writer");
 const debugLog = make_debugLog(__filename);
 const warningLog = make_warningLog(__filename);
 const errorLog = make_errorLog(__filename);
+const doDebug = false;
 
 function _hash(node: BaseNode | UAReference): string {
     return node.nodeId.toString();
@@ -1036,11 +1037,11 @@ function dumpUAVariableType(xw: XmlWriter, node: UAVariableType) {
             // throw new Error(" cannot find datatype " + node.dataType);
             console.log(
                 " cannot find datatype " +
-                    node.dataType +
-                    " for node " +
-                    node.browseName.toString() +
-                    " id =" +
-                    node.nodeId.toString()
+                node.dataType +
+                " for node " +
+                node.browseName.toString() +
+                " id =" +
+                node.nodeId.toString()
             );
         } else {
             const dataTypeName = b(xw, resolveDataTypeName(addressSpace, dataTypeNode.nodeId));
@@ -1247,10 +1248,21 @@ function writeAliases(xw: XmlWriter, aliases: Record<string, NodeIdString>) {
     xw.endElement();
 }
 
-export function constructNamespaceTranslationTable(dependency: INamespace[]): ITranslationTable {
+function constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): ITranslationTable {
+
     const translationTable: ITranslationTable = {};
-    for (let i = 0; i < dependency.length; i++) {
-        translationTable[dependency[i].index] = i;
+    assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
+
+    let counter = 0;
+    translationTable[dependency[0].index] = counter++;
+    //
+    if (exportedNamespace) {
+        translationTable[exportedNamespace.index] = counter++;
+    }
+    for (let i = 1; i < dependency.length; i++) {
+        const dep = dependency[i];
+        if (exportedNamespace && exportedNamespace === dep) { continue; }
+        translationTable[dep.index] = counter++;
     }
     return translationTable;
 }
@@ -1342,7 +1354,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
 
     xw.priorityTable = constructNamespacePriorityTable(this);
     const dependency = constructNamespaceDependency(this, xw.priorityTable);
-    const translationTable = constructNamespaceTranslationTable(dependency);
+    const translationTable = constructNamespaceTranslationTable(dependency, this);
     xw.translationTable = translationTable;
 
     xw.startDocument({ encoding: "utf-8", version: "1.0" });
@@ -1372,12 +1384,17 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
     // xx xw.writeAttribute("LastModified", (new Date()).toISOString());
 
     // ------------- INamespace Uris
+    initXmlWriterEx(xw, namespacesMap, namespaceArray);
+
     xw.startElement("NamespaceUris");
 
-    initXmlWriterEx(xw, namespacesMap, namespaceArray);
+    // let's sort the dependencies in the same order as the translation table
+    const sortedDependencies = dependency.sort((a,b)=> translationTable[a.index] > translationTable[b.index] ? 1: -1);
+    
+    doDebug && console.log(sortedDependencies.map((a)=>a.index + " + "+ a.namespaceUri).join("\n"));
+    doDebug && console.log("translation table ", translationTable);
 
-    // xx const namespaceArray = namespace.addressSpace.getNamespaceArray();
-    for (const depend of dependency) {
+    for (const depend of sortedDependencies) {
         if (depend.index === 0) {
             continue; // ignore namespace 0
         }
@@ -1385,7 +1402,6 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
         xw.text(depend.namespaceUri);
         xw.endElement();
     }
-
     xw.endElement();
 
     // ------------- INamespace Uris
@@ -1395,7 +1411,7 @@ NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
         xw.writeAttribute("ModelUri", this.namespaceUri);
         xw.writeAttribute("Version", this.version);
         xw.writeAttribute("PublicationDate", this.publicationDate.toISOString());
-        for (const depend of dependency) {
+        for (const depend of sortedDependencies) {
             if (depend.index === this.index) {
                 continue; // ignore our namespace 0
             }

package/src/private_namespace.ts

@@ -0,0 +1,18 @@
+
+
+import { Namespace } from "../source/namespace";
+import { NodeEntry1, NodeIdManager } from "./nodeid_manager";
+
+export function getNodeIdManager(ns: Namespace): NodeIdManager {
+    const nodeIdManager = (ns as any)._nodeIdManager as NodeIdManager;
+    return nodeIdManager;
+}
+export function setSymbols(ns: Namespace, symbols: NodeEntry1[]) {
+    const nodeIdManager = getNodeIdManager(ns);
+    (ns.addressSpace.getOwnNamespace() as any).registerSymbolicNames = true;
+    nodeIdManager.setSymbols(symbols);
+}
+export function getSymbols(ns: Namespace): NodeEntry1[] {
+    const nodeIdManager = getNodeIdManager(ns);
+    return nodeIdManager?.getSymbols() || [];
+}