node-opcua-address-space 2.86.0 → 2.87.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-address-space",
-    "version": "2.86.0",
+    "version": "2.87.0",
     "description": "pure nodejs OPCUA SDK - module -address-space",
     "main": "./dist/src/index_current.js",
     "types": "./dist/source/index.d.ts",
@@ -22,35 +22,35 @@
         "chalk": "4.1.2",
         "dequeue": "^1.0.5",
         "lodash": "4.17.21",
-        "node-opcua-address-space-base": "2.86.0",
+        "node-opcua-address-space-base": "2.87.0",
         "node-opcua-assert": "2.77.0",
-        "node-opcua-basic-types": "2.86.0",
+        "node-opcua-basic-types": "2.86.1",
         "node-opcua-binary-stream": "2.86.0",
-        "node-opcua-client-dynamic-extension-object": "2.86.0",
+        "node-opcua-client-dynamic-extension-object": "2.87.0",
         "node-opcua-constants": "2.77.0",
         "node-opcua-crypto": "^2.1.2",
-        "node-opcua-data-access": "2.86.0",
-        "node-opcua-data-model": "2.86.0",
-        "node-opcua-data-value": "2.86.0",
+        "node-opcua-data-access": "2.87.0",
+        "node-opcua-data-model": "2.86.1",
+        "node-opcua-data-value": "2.87.0",
         "node-opcua-date-time": "2.86.0",
         "node-opcua-debug": "2.86.0",
         "node-opcua-enum": "2.86.0",
-        "node-opcua-extension-object": "2.86.0",
-        "node-opcua-factory": "2.86.0",
+        "node-opcua-extension-object": "2.86.1",
+        "node-opcua-factory": "2.86.1",
         "node-opcua-nodeid": "2.86.0",
-        "node-opcua-nodeset-ua": "2.86.0",
-        "node-opcua-numeric-range": "2.86.0",
+        "node-opcua-nodeset-ua": "2.87.0",
+        "node-opcua-numeric-range": "2.86.1",
         "node-opcua-object-registry": "2.86.0",
-        "node-opcua-pseudo-session": "2.86.0",
-        "node-opcua-service-browse": "2.86.0",
-        "node-opcua-service-call": "2.86.0",
-        "node-opcua-service-history": "2.86.0",
-        "node-opcua-service-translate-browse-path": "2.86.0",
-        "node-opcua-service-write": "2.86.0",
-        "node-opcua-status-code": "2.86.0",
-        "node-opcua-types": "2.86.0",
+        "node-opcua-pseudo-session": "2.87.0",
+        "node-opcua-service-browse": "2.87.0",
+        "node-opcua-service-call": "2.87.0",
+        "node-opcua-service-history": "2.87.0",
+        "node-opcua-service-translate-browse-path": "2.87.0",
+        "node-opcua-service-write": "2.87.0",
+        "node-opcua-status-code": "2.86.1",
+        "node-opcua-types": "2.87.0",
         "node-opcua-utils": "2.86.0",
-        "node-opcua-variant": "2.86.0",
+        "node-opcua-variant": "2.87.0",
         "node-opcua-xml2json": "2.86.0",
         "semver": "^7.3.8",
         "set-prototype-of": "^1.0.0",
@@ -62,9 +62,9 @@
         "node-opcua-benchmarker": "2.86.0",
         "node-opcua-leak-detector": "2.86.0",
         "node-opcua-nodesets": "2.77.0",
-        "node-opcua-packet-analyzer": "2.86.0",
-        "node-opcua-service-filter": "2.86.0",
-        "node-opcua-test-fixtures": "2.86.0",
+        "node-opcua-packet-analyzer": "2.86.1",
+        "node-opcua-service-filter": "2.87.0",
+        "node-opcua-test-fixtures": "2.87.0",
         "should": "^13.2.3",
         "sinon": "^14.0.2",
         "source-map-support": "^0.5.21"
@@ -84,5 +84,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "36afc46fe2c91aa5664a8c5418f4db5a354670c3"
+    "gitHead": "cf789b56916b6c0974c17337352ef9581d50ddb0"
 }

package/source/index.ts

@@ -63,6 +63,7 @@ export * from "./loader/register_node_promoter";
 
 export * from "./namespace";
 export * from "./namespace_data_access";
+export * from "../src/private_namespace";
 
 export { instantiateCertificateExpirationAlarm } from "../src/alarms_and_conditions/ua_certificate_expiration_alarm_impl";
 

package/src/base_node_private.ts

@@ -13,7 +13,7 @@ import {
     NodeClass,
     ResultMask
 } from "node-opcua-data-model";
-import { checkDebugFlag, make_warningLog } from "node-opcua-debug";
+import { checkDebugFlag, make_warningLog, make_errorLog } from "node-opcua-debug";
 import { NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { ReferenceDescription } from "node-opcua-types";
 import {
@@ -43,8 +43,9 @@ import { AddressSpacePrivate } from "./address_space_private";
 import { wipeMemorizedStuff } from "./tool_isSupertypeOf";
 
 // eslint-disable-next-line prefer-const
-let doTrace = checkDebugFlag("INSTANTIATE");
-const traceLog = console.log.bind(console);
+const errorLog = make_errorLog(__filename);
+const doTrace = checkDebugFlag("INSTANTIATE");
+const traceLog = errorLog;
 
 const g_weakMap = new WeakMap();
 
@@ -189,8 +190,8 @@ export function BaseNode_toString(this: BaseNode, options: ToStringOption): void
     options.add(options.padding + chalk.yellow("          browseName          : ") + this.browseName.toString());
     options.add(
         options.padding +
-            chalk.yellow("          displayName         : ") +
-            this.displayName.map((f) => f.locale + " " + f.text).join(" | ")
+        chalk.yellow("          displayName         : ") +
+        this.displayName.map((f) => f.locale + " " + f.text).join(" | ")
     );
 
     options.add(
@@ -209,9 +210,9 @@ export function BaseNode_References_toString(this: BaseNode, options: ToStringOp
 
     options.add(
         options.padding +
-            chalk.yellow("    references                : ") +
-            "  length =" +
-            Object.keys(_private._referenceIdx).length
+        chalk.yellow("    references                : ") +
+        "  length =" +
+        Object.keys(_private._referenceIdx).length
     );
 
     function dump_reference(follow: boolean, reference: UAReference | null) {
@@ -250,12 +251,12 @@ export function BaseNode_References_toString(this: BaseNode, options: ToStringOp
             })();
         options.add(
             options.padding +
-                chalk.yellow("      +-> ") +
-                reference.toString(displayOptions) +
-                " " +
-                chalk.cyan(name.padEnd(25, " ")) +
-                " " +
-                chalk.magentaBright(extra)
+            chalk.yellow("      +-> ") +
+            reference.toString(displayOptions) +
+            " " +
+            chalk.cyan(name.padEnd(25, " ")) +
+            " " +
+            chalk.magentaBright(extra)
         );
 
         // ignore HasTypeDefinition as it has been already handled
@@ -284,10 +285,10 @@ export function BaseNode_References_toString(this: BaseNode, options: ToStringOp
 
     options.add(
         options.padding +
-            chalk.yellow("    back_references                 : ") +
-            chalk.cyan("  length =") +
-            br.length +
-            chalk.grey(" ( references held by other nodes involving this node)")
+        chalk.yellow("    back_references                 : ") +
+        chalk.cyan("  length =") +
+        br.length +
+        chalk.grey(" ( references held by other nodes involving this node)")
     );
     // backward reference
     br.forEach(dump_reference.bind(null, false));
@@ -297,11 +298,11 @@ function _UAType_toString(this: UAReferenceType | UADataType | UAObjectType | UA
     if (this.subtypeOfObj) {
         options.add(
             options.padding +
-                chalk.yellow("          subtypeOf           : ") +
-                this.subtypeOfObj.browseName.toString() +
-                " (" +
-                this.subtypeOfObj.nodeId.toString() +
-                ")"
+            chalk.yellow("          subtypeOf           : ") +
+            this.subtypeOfObj.browseName.toString() +
+            " (" +
+            this.subtypeOfObj.nodeId.toString() +
+            ")"
         );
     }
 }
@@ -310,11 +311,11 @@ function _UAInstance_toString(this: UAVariable | UAMethod | UAObject, options: T
     if (this.typeDefinitionObj) {
         options.add(
             options.padding +
-                chalk.yellow("          typeDefinition      : ") +
-                this.typeDefinitionObj.browseName.toString() +
-                " (" +
-                this.typeDefinitionObj.nodeId.toString() +
-                ")"
+            chalk.yellow("          typeDefinition      : ") +
+            this.typeDefinitionObj.browseName.toString() +
+            " (" +
+            this.typeDefinitionObj.nodeId.toString() +
+            ")"
         );
     }
 }
@@ -421,9 +422,9 @@ export function VariableOrVariableType_toString(this: UAVariableType | UAVariabl
         if (_dataValue) {
             options.add(
                 options.padding +
-                    chalk.yellow("          value               : ") +
-                    "\n" +
-                    options.indent(_dataValue.toString(), options.padding + "                        | ")
+                chalk.yellow("          value               : ") +
+                "\n" +
+                options.indent(_dataValue.toString(), options.padding + "                        | ")
             );
         }
     }
@@ -440,19 +441,19 @@ export function VariableOrVariableType_toString(this: UAVariableType | UAVariabl
     if (this.minimumSamplingInterval !== undefined) {
         options.add(
             options.padding +
-                chalk.yellow(" minimumSamplingInterval      : ") +
-                " " +
-                this.minimumSamplingInterval.toString() +
-                " ms"
+            chalk.yellow(" minimumSamplingInterval      : ") +
+            " " +
+            this.minimumSamplingInterval.toString() +
+            " ms"
         );
     }
     if (this.arrayDimensions) {
         options.add(
             options.padding +
-                chalk.yellow(" arrayDimension               : ") +
-                " [" +
-                this.arrayDimensions.join(",").toString() +
-                " ]"
+            chalk.yellow(" arrayDimension               : ") +
+            " [" +
+            this.arrayDimensions.join(",").toString() +
+            " ]"
         );
     }
 }
@@ -494,11 +495,11 @@ function _clone_collection_new(
             // tslint:disable-next-line:no-console
             warningLog(
                 chalk.red("Warning : cannot clone node ") +
-                    node.browseName.toString() +
-                    " of class " +
-                    NodeClass[node.nodeClass].toString() +
-                    " while cloning " +
-                    newParent.browseName.toString()
+                node.browseName.toString() +
+                " of class " +
+                NodeClass[node.nodeClass].toString() +
+                " while cloning " +
+                newParent.browseName.toString()
             );
             continue;
         }
@@ -535,6 +536,11 @@ function _clone_collection_new(
         extraInfo.level += 4;
         const clone = (node as UAVariable | UAMethod | UAObject).clone(options, optionalFilter, extraInfo);
         extraInfo.level -= 4;
+        doTrace &&
+            traceLog(
+                extraInfo.pad(),
+                "cloning => ", node.browseName.toString(), "nodeId", clone.nodeId.toString()
+            );
 
         // also clone or instantiate interface members that may be required in the optionals
         extraInfo.level++;
@@ -610,7 +616,7 @@ function _extractInterfaces2(typeDefinitionNode: UAObjectType | UAVariableType,
     }
     const dedupedInterfaces = [...new Set(interfaces)];
 
-    doTrace &&
+    doTrace && dedupedInterfaces.length &&
         traceLog(
             extraInfo.pad(),
             chalk.yellow("Interface for ", typeDefinitionNode.browseName.toString()),
@@ -693,9 +699,7 @@ function _cloneInterface(
     }
     const interfaces = _extractInterfaces2(typeDefinitionNode, extraInfo);
     if (interfaces.length === 0) {
-        if (doTrace) {
-            traceLog(extraInfo.pad(), chalk.yellow("No interface for ", node.browseName.toString(), node.nodeId.toString()));
-        }
+        doTrace && false && traceLog(extraInfo.pad(), chalk.yellow("No interface for ", node.browseName.toString(), node.nodeId.toString()));
         return;
     }
     doTrace && traceLog(extraInfo?.pad(), chalk.green("-------------------- interfaces are  ", interfaces.length));

package/src/index_current.ts

@@ -51,6 +51,7 @@ export * from "./data_access/ua_two_state_discrete_impl";
 
 export { VariableHistorian } from "./historical_access/address_space_historical_data_node";
 export { NodeIdManager } from "../src/nodeid_manager";
+export * from "../src/private_namespace";
 
 export * from "./alarms_and_conditions";
 export * from "./event_data";

package/src/namespace_impl.ts

@@ -640,7 +640,7 @@ export class NamespaceImpl implements NamespacePrivate {
         const node = this.internalCreateNode(options) as UADataType;
 
         node.propagate_back_references();
-        
+
         return node;
     }
 
@@ -1659,32 +1659,35 @@ export class NamespaceImpl implements NamespacePrivate {
     public _register(node: BaseNode): void {
         assert(node instanceof BaseNodeImpl, "Expecting a instance of BaseNode in _register");
         assert(node.nodeId instanceof NodeId, "Expecting a NodeId");
+        // istanbul ignore next
         if (node.nodeId.namespace !== this.index) {
             throw new Error("node must belongs to this namespace");
         }
         assert(node.nodeId.namespace === this.index, "node must belongs to this namespace");
         assert(Object.prototype.hasOwnProperty.call(node, "browseName"), "Node must have a browseName");
-        // assert(node.browseName.namespaceIndex === this.index,"browseName must belongs to this namespace");
 
         const hashKey = _makeHashKey(node.nodeId);
 
         // istanbul ignore next
         if (this._nodeid_index.has(hashKey)) {
+
+            const exstingNode = this.findNode(node.nodeId)!;
             throw new Error(
                 "node " +
-                    node.browseName.toString() +
-                    "nodeId = " +
-                    node.nodeId.displayText() +
-                    " already registered " +
-                    node.nodeId.toString() +
-                    "\n" +
-                    " in namespace " +
-                    this.namespaceUri +
-                    " index = " +
-                    this.index +
-                    "\n" +
-                    " browseName = " +
-                    node.browseName.toString()
+                node.browseName.toString() +
+                " nodeId = " +
+                node.nodeId.displayText() +
+                " already registered " +
+                node.nodeId.toString() +
+                "\n" +
+                " in namespace " +
+                this.namespaceUri +
+                " index = " +
+                this.index +
+                "\n" +
+                "existing node = " +
+                exstingNode.toString() +
+                "this parent : " + node.parentNodeId?.toString() 
             );
         }
 
@@ -1747,15 +1750,15 @@ export class NamespaceImpl implements NamespacePrivate {
                     errorLog(
                         chalk.red.bold(
                             "Error: namespace index used at the front of the browseName " +
-                                indexVerif +
-                                " do not match the index of the current namespace (" +
-                                this.index +
-                                ")"
+                            indexVerif +
+                            " do not match the index of the current namespace (" +
+                            this.index +
+                            ")"
                         )
                     );
                     errorLog(
                         " Please fix your code so that the created node is inserted in the correct namespace," +
-                            " please refer to the NodeOPCUA documentation"
+                        " please refer to the NodeOPCUA documentation"
                     );
                 }
             }

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;
     }
 }