node-opcua-client-dynamic-extension-object 2.162.0 → 2.163.1

package/source/get_extra_data_type_manager.ts

@@ -23,7 +23,7 @@ export interface IBasicSessionAsync2Private extends IBasicSessionAsync2 {
 
     $$getSessionForDataTypeExtraction?: () => IBasicSessionAsync2;
 
-    on?: (this: IBasicSessionAsync2Private,  event: "session_restored", func: () => void)=> void;
+    on?: (this: IBasicSessionAsync2Private, event: "session_restored", func: () => void) => void;
 
     sessionId?: NodeId;
 
@@ -38,7 +38,7 @@ export async function invalidateExtraDataTypeManager(session: IBasicSessionAsync
     }
 }
 
-export async function extractDataTypeManagerPrivate(session: IBasicSessionAsync2, strategy: DataTypeExtractStrategy): Promise<ExtraDataTypeManager> {
+async function extractDataTypeManagerPrivate(session: IBasicSessionAsync2, strategy: DataTypeExtractStrategy): Promise<ExtraDataTypeManager> {
     const namespaceArray = await readNamespaceArray(session);
     // istanbul ignore next
     if (namespaceArray.length === 0) {
@@ -49,11 +49,13 @@ export async function extractDataTypeManagerPrivate(session: IBasicSessionAsync2
         debugLog("Namespace Array = ", namespaceArray.join("\n                   "));
     }
     const dataTypeManager = new ExtraDataTypeManager();
+    dataTypeManager.setSession(session);
     dataTypeManager.setNamespaceArray(namespaceArray);
     for (let namespaceIndex = 1; namespaceIndex < namespaceArray.length; namespaceIndex++) {
         const dataTypeFactory1 = new DataTypeFactory([getStandardDataTypeFactory()]);
         dataTypeManager.registerDataTypeFactory(namespaceIndex, dataTypeFactory1);
     }
+
     await populateDataTypeManager(session, dataTypeManager, strategy);
     // istanbul ignore next
     if (dataTypeManager.namespaceArray.length === 0) {
@@ -67,14 +69,19 @@ function getStrategy(session: IBasicSessionAsync2, strategy?: DataTypeExtractStr
     if (strategy !== undefined) {
         return strategy;
     }
-    const client =  (session as any).client;
-    if (client && client.dataTypeExtractStrategy!== undefined) {
+    const client = (session as IBasicSessionAsync2 & { _client: { dataTypeExtractStrategy: DataTypeExtractStrategy } })._client;
+    if (client && client.dataTypeExtractStrategy !== undefined) {
         return client.dataTypeExtractStrategy;
     }
     return DataTypeExtractStrategy.Auto;
 }
 
-function getSessionForDataTypeManagerExtraction(session: IBasicSessionAsync2): IBasicSessionAsync2 {
+
+export function hasBoostedSession(session: IBasicSessionAsync2): boolean {
+    const _session: IBasicSessionAsync2Private = session as IBasicSessionAsync2Private;
+    return !!_session.$$getSessionForDataTypeExtraction || !!(_session as any).session;
+}
+export function getSessionForDataTypeManagerExtraction(session: IBasicSessionAsync2): IBasicSessionAsync2 {
     const _session: IBasicSessionAsync2Private = session as IBasicSessionAsync2Private;
     if (_session.$$getSessionForDataTypeExtraction) {
         return _session.$$getSessionForDataTypeExtraction();
@@ -90,8 +97,8 @@ function followSession(session: IBasicSessionAsync2Private & ICascadingSession):
     return session;
 }
 
-export async function getExtraDataTypeManager(session: IBasicSessionAsync2, strategy?: DataTypeExtractStrategy ): Promise<ExtraDataTypeManager> {
-    
+export async function getExtraDataTypeManager(session: IBasicSessionAsync2, strategy?: DataTypeExtractStrategy): Promise<ExtraDataTypeManager> {
+
     const sessionPriv: IBasicSessionAsync2Private = followSession(session) as IBasicSessionAsync2Private;
 
     if (sessionPriv.$$extraDataTypeManager) {
@@ -111,6 +118,7 @@ export async function getExtraDataTypeManager(session: IBasicSessionAsync2, stra
         (async () => {
             try {
                 strategy = getStrategy(session, strategy);
+
                 const sessionToUse = getSessionForDataTypeManagerExtraction(session);
 
                 const dataTypeManager = await extractDataTypeManagerPrivate(sessionToUse, strategy);

package/source/populate_data_type_manager.ts

@@ -2,7 +2,8 @@ import { AttributeIds, BrowseDirection, NodeClassMask, ResultMask } from "node-o
 import { resolveNodeId } from "node-opcua-nodeid";
 import {
     IBasicSessionAsync2,
-    browseAll
+    browseAll,
+    readNamespaceArray
 } from "node-opcua-pseudo-session";
 import { DataTypeIds, ObjectIds, VariableIds, VariableTypeIds } from "node-opcua-constants";
 import { DataType } from "node-opcua-variant";
@@ -12,131 +13,106 @@ import { makeBrowsePath } from "node-opcua-service-translate-browse-path";
 import { ExtraDataTypeManager } from "./extra_data_type_manager";
 import { populateDataTypeManager103 } from "./private/populate_data_type_manager_103";
 import { populateDataTypeManager104 } from "./private/populate_data_type_manager_104";
+import { DataTypeFactory } from "node-opcua-factory";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
 
 
+const doDebug = checkDebugFlag("populateDataTypeManager");
+const debugLog = make_debugLog("populateDataTypeManager");
+
 const ComplexTypes2017 = "http://opcfoundation.org/UA-Profile/Server/ComplexTypes2017";
-/**
- * @private
- */
+
 export async function serverImplementsDataTypeDefinition(
     session: IBasicSessionAsync2
 ): Promise<boolean> {
 
-
     const dataValueServerCapabilities = await session.read({
         nodeId: resolveNodeId(VariableIds.Server_ServerCapabilities_ServerProfileArray),
         attributeId: AttributeIds.Value
     });
-    const serverCapabilities = dataValueServerCapabilities.value.value as string[] ?? [];
+    const serverCapabilities = dataValueServerCapabilities.value?.value as string[] ?? [];
 
-    //read the capabilities
-    // https://profiles.opcfoundation.org/profile/1725
-    // and find http://opcfoundation.org/UA-Profile/Server/ComplexTypes2017
-   if (serverCapabilities.indexOf(ComplexTypes2017) >= 0) {
+    if (serverCapabilities.indexOf(ComplexTypes2017) >= 0) {
+        doDebug && debugLog("server implements ComplexTypes2017");
         return true;
     }
 
-    // One way to figure out is to check if the server provides DataTypeDefinition node
-    // ( see OPCUA 1.04 part 6 -)
-    // This is the preferred route, as we go along, more and more servers will implement this.
-    const browseResult1 = await browseAll(session, {
+    // Check if any non-deprecated 1.03 dictionary exists
+    const browseResult1 = await session.browse({
         browseDirection: BrowseDirection.Forward,
         includeSubtypes: true,
         nodeClassMask: NodeClassMask.Variable,
         nodeId: resolveNodeId(ObjectIds.OPCBinarySchema_TypeSystem),
         resultMask: ResultMask.TypeDefinition
     });
- 
-    let count103DataType = 0;
-    const innerF = async (ref: ReferenceDescription) => {
-        const td = ref.typeDefinition;
-        if (!(td.namespace === 0 && td.value === VariableTypeIds.DataTypeDictionaryType)) {
-            return;
-        }
-        // we have a type definition,
-        // let check if there is a deprecated property
-        const p = await session.translateBrowsePath(makeBrowsePath(ref.nodeId, "/Deprecated"));
-        if (!p.statusCode.isGood() || !p.targets || p.targets.length === 0) {
-            // the dataTypeDictionaryType is not exposing a Deprecated property
-            count103DataType++;
-            return;
-        }
-        const deprecatedNodeId = p.targets[0].targetId;
-        // we have a deprecated property => this is a 1.03 server or 1.04
-        // => we need to check if the server provides DataTypeDefinition
-        const dataValue = await session.read({ nodeId: deprecatedNodeId, attributeId: AttributeIds.Value });
-        if (dataValue.statusCode.isGood() && dataValue.value.value === false) {
-            // this is a 1.03 server
-            count103DataType++;
-            return;
-        }
-    }
 
-    if (false) {
-        for (let r of (browseResult1.references || [])) {
-            await innerF(r);
+    const references103 = browseResult1.references || [];
+    for (const ref of references103) {
+        const td = ref.typeDefinition;
+        if (td.namespace === 0 && td.value === VariableTypeIds.DataTypeDictionaryType) {
+            const p = await session.translateBrowsePath(makeBrowsePath(ref.nodeId, "/Deprecated"));
+            if (!p.statusCode.isGood() || !p.targets || p.targets.length === 0) {
+                doDebug && debugLog("server implements 1.03 dictionary but no Deprecated node found");
+                return false;
+            }
+            const deprecatedNodeId = p.targets[0].targetId;
+            const dataValue = await session.read({ nodeId: deprecatedNodeId, attributeId: AttributeIds.Value });
+            if (dataValue.statusCode.isGood() && dataValue.value.value === false) {
+                doDebug && debugLog("server implements 1.03 dictionary but Deprecated node is true");
+                return false;
+            }
         }
-    } else {
-        const promises: Promise<void>[] = (browseResult1.references || []).map((a) => innerF(a));
-        await Promise.all(promises);
-    }
-    
-    if (count103DataType >= 1) {
-        // some namespace are old , we cannot assume that all namespace are 1.04
-        return false;
     }
 
-    // check if server provides DataTypeDefinition => in this case this is the preferred route,
-    // as we go along, more and more servers will implement this.
-    const browseResult = await browseAll(session, {
+    // Try to find AT LEAST ONE custom DataType and check its DataTypeDefinition
+    // We browse the Structure type (22) without recursion first
+    const browseResult2 = await session.browse({
         browseDirection: BrowseDirection.Forward,
         includeSubtypes: true,
         nodeClassMask: NodeClassMask.DataType,
-        nodeId: resolveNodeId(DataType.ExtensionObject),
-        referenceTypeId: "HasSubtype",
+        nodeId: resolveNodeId(DataTypeIds.Structure),
+        referenceTypeId: resolveNodeId("HasSubtype"),
         resultMask: 63
     });
-    const browseResult2 = await browseAll(session, {
+
+    const references = browseResult2.references || [];
+    const customDataType = references.find(r => r.nodeId.namespace !== 0);
+    if (customDataType) {
+        const dv = await session.read({ nodeId: customDataType.nodeId, attributeId: AttributeIds.DataTypeDefinition });
+        if (dv.statusCode.isGood()) {
+            doDebug && debugLog("server implements 1.04 dictionary with custom DataType");
+            return true;
+        }
+    } else {
+        const standardDataType = references.find(r => r.nodeId.namespace == 0);
+        if (standardDataType) {
+            const dv = await session.read({ nodeId: standardDataType.nodeId, attributeId: AttributeIds.DataTypeDefinition });
+            if (dv.statusCode.isGood()) {
+                doDebug && debugLog("server implements 1.04 dictionary with standard DataType");
+                return true;
+            }
+        }
+    }
+
+    // If no custom type at first level, check Union too
+    const browseResult3 = await session.browse({
         browseDirection: BrowseDirection.Forward,
         includeSubtypes: true,
         nodeClassMask: NodeClassMask.DataType,
         nodeId: resolveNodeId(DataTypeIds.Union),
-        referenceTypeId: "HasSubtype",
+        referenceTypeId: resolveNodeId("HasSubtype"),
         resultMask: 63
     });
-
-    let references: ReferenceDescription[] = [];
-    if (browseResult && browseResult.references) references = references.concat(browseResult.references);
-    if (browseResult2 && browseResult2.references) references = references.concat(browseResult2.references);
-
-    if (references.length === 0) return false;
-
-    // DataType Structure from namespace 0 are not interesting and will not provide DataTypeDefinition attribute anyway
-    // on some servers.
-    references = references.filter((a, index) => a.nodeId.namespace !== 0);
-    if (references.length === 0) return false;
-
-    let nodesToRead = references.map((r) => ({
-        nodeId: r.nodeId,
-        attributeId: AttributeIds.DataTypeDefinition
-    }));
-
-    const nodesToRead2 = nodesToRead.map((r) => ({ nodeId: r.nodeId, attributeId: AttributeIds.IsAbstract }));
-    const abstractFlags: boolean[] = (await session.read(nodesToRead2)).map((d) => d.value.value);
-
-    // also remove the abstract dataStructure => they don't provide valid DataTypeDefinition
-    nodesToRead = nodesToRead.filter((_nodesToRead, index) => !abstractFlags[index]);
-    if (nodesToRead.length === 0) return false;
-
-    const dataValues = await session.read(nodesToRead);
-
-    const countOK = dataValues.reduce((prev, a) => prev + (a.statusCode.isGood() ? 1 : 0), 0);
-    if (countOK === dataValues.length) {
-        return true;
-        // await populateDataTypeManager104(session, dataTypeManager);
-        // return;
+    const customDataType2 = (browseResult3.references || []).find(r => r.nodeId.namespace !== 0);
+    if (customDataType2) {
+        const dv = await session.read({ nodeId: customDataType2.nodeId, attributeId: AttributeIds.DataTypeDefinition });
+        if (dv.statusCode.isGood()) {
+            doDebug && debugLog("server implements 1.04 dictionary with custom Union");
+            return true;
+        }
     }
 
+    doDebug && debugLog("server does not implement 1.04 dictionary or we cannot find any evidence of it");
     return false;
 }
 
@@ -144,7 +120,8 @@ export enum DataTypeExtractStrategy {
     Auto = 0,
     Force103 = 1,
     Force104 = 2,
-    Both = 3
+    Both = 3,
+    Lazy = 4
 };
 
 export async function populateDataTypeManager(
@@ -152,21 +129,54 @@ export async function populateDataTypeManager(
     dataTypeManager: ExtraDataTypeManager,
     strategy: DataTypeExtractStrategy
 ): Promise<void> {
+    dataTypeManager.setSession(session);
+
+
+    if (strategy === DataTypeExtractStrategy.Lazy) {
+        doDebug && debugLog("populateDataTypeManager: Lazy mode");
+        const force104 = await serverImplementsDataTypeDefinition(session);
+        if (force104) {
+            doDebug && debugLog("populateDataTypeManager: Lazy mode - server implements 1.04 dictionary - we will be lazy");
+            // we are in lazy mode for 1.0.5+
+            // create teh dataTypeFactory for namespace 1
+            const namespace = await readNamespaceArray(session);
+            for (let i = 1; i < namespace.length; i++) {
+                let dataTypeFactory = dataTypeManager.getDataTypeFactory(i);
+                if (!dataTypeFactory) {
+                    dataTypeFactory = new DataTypeFactory([]);
+                    dataTypeManager.registerDataTypeFactory(i, dataTypeFactory);
+                    //   throw new Error("cannot find dataType Manager for namespace of " + dataTypeNodeId.toString());
+                }
+            }
+            return;
+        }
+        doDebug && debugLog("populateDataTypeManager: Lazy mode - server does not implement 1.04 dictionary - we will be eager");
+        // for old 1.03 servers we must be eager as we don't have a way to lazy load 1.03 dictionaries yet
+        await populateDataTypeManager103(session, dataTypeManager);
+        await populateDataTypeManager104(session, dataTypeManager);
+        return;
+    }
     if (strategy === DataTypeExtractStrategy.Auto) {
+        doDebug && debugLog("populateDataTypeManager: Auto mode");
         const force104 = await serverImplementsDataTypeDefinition(session);
+
         if (force104) {
+            doDebug && debugLog("populateDataTypeManager: Auto mode - server implements 1.04 dictionary - we will be 104 eager");
             await populateDataTypeManager104(session, dataTypeManager);
             return;
         }
+        doDebug && debugLog("populateDataTypeManager: Auto mode - server does not implement 1.04 dictionary - we will be 103 eager and 104 eager");
         // old way for 1.03 and early 1.04 prototype
         await populateDataTypeManager103(session, dataTypeManager);
         await populateDataTypeManager104(session, dataTypeManager);
         return;
     }
     if (strategy == DataTypeExtractStrategy.Force103 || strategy == DataTypeExtractStrategy.Both) {
+        doDebug && debugLog("populateDataTypeManager: Force103 mode - we will be 103 eager");
         await populateDataTypeManager103(session, dataTypeManager);
     }
     if (strategy == DataTypeExtractStrategy.Force104 || strategy == DataTypeExtractStrategy.Both) {
+        doDebug && debugLog("populateDataTypeManager: Force104 mode - we will be 104 eager");
         await populateDataTypeManager104(session, dataTypeManager);
     }
 }

package/source/private/populate_data_type_manager_103.ts

@@ -278,9 +278,9 @@ const readIsAbstract = async (session: IBasicSessionAsync, nodeId: NodeId): Prom
 async function _extractDataTypeDictionaryFromDefinition(
     session: IBasicSessionAsync2,
     dataTypeDictionaryNodeId: NodeId,
-    dataTypeFactory: DataTypeFactory
+    dataTypeManager: ExtraDataTypeManager
 ) {
-    assert(dataTypeFactory, "expecting a dataTypeFactory");
+    assert(dataTypeManager, "expecting a dataTypeManager");
 
     const dataTypeDescriptions = await _getDataTypeDescriptions(session, dataTypeDictionaryNodeId);
     const dataTypeNodeIds = await _enrichWithDescriptionOf(session, dataTypeDescriptions);
@@ -343,6 +343,8 @@ async function _extractDataTypeDictionaryFromDefinition(
     for (const { className, dataTypeNodeId, dataTypeDefinition, isAbstract } of dataTypeDefinitionsSorted) {
         promises2.push(
             (async () => {
+
+                const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dataTypeNodeId.namespace);
                 // istanbul ignore next
                 if (doDebug) {
                     debugLog(chalk.yellow("--------------------------------------- "), className, dataTypeNodeId.toString());
@@ -362,7 +364,7 @@ async function _extractDataTypeDictionaryFromDefinition(
                         className,
                         dataTypeDefinition,
                         dataTypeDescription!, // for encodings
-                        dataTypeFactory,
+                        dataTypeManager,
                         isAbstract,
                         cache
                     );
@@ -463,7 +465,7 @@ async function _extractDataTypeDictionary(
         if (!dataTypeFactory2) {
             throw new Error("cannot find dataTypeFactory for namespace " + dataTypeDictionaryNodeId.namespace);
         }
-        await _extractDataTypeDictionaryFromDefinition(session, dataTypeDictionaryNodeId, dataTypeFactory2);
+        await _extractDataTypeDictionaryFromDefinition(session, dataTypeDictionaryNodeId, dataTypeManager);
     } else {
         const rawSchema = d.rawSchema; // DataValue = await session.read({ nodeId: dataTypeDictionaryNodeId, attributeId: AttributeIds.Value });
         doDebug &&

package/source/private/populate_data_type_manager_104.ts

@@ -8,32 +8,35 @@ import {
     ReferenceDescription,
     BrowseDescriptionOptions,
     StructureDefinition,
-    DataTypeDefinition} from "node-opcua-types";
+    DataTypeDefinition
+} from "node-opcua-types";
 //
 import { ExtraDataTypeManager } from "../extra_data_type_manager";
 import {
     ICache,
     convertDataTypeDefinitionToStructureTypeSchema
 } from "../convert_data_type_definition_to_structuretype_schema";
+import { hasBoostedSession } from "../get_extra_data_type_manager";
 import { StatusCodes } from "node-opcua-status-code";
 
-const errorLog = make_errorLog(__filename);
-const debugLog = make_debugLog(__filename);
-const warningLog = make_warningLog(__filename);
-const doDebug = checkDebugFlag(__filename);
+const errorLog = make_errorLog("populateDataTypeManager");
+const debugLog = make_debugLog("populateDataTypeManager");
+const warningLog = make_warningLog("populateDataTypeManager");
+const doDebug = checkDebugFlag("populateDataTypeManager");
 
 type DependentNamespaces = Set<number>
 
 export async function readDataTypeDefinitionAndBuildType(
     session: IBasicSessionAsync2,
     dataTypeNodeId: NodeId,
-    name: string,
-    dataTypeFactory: DataTypeFactory,
+    name: string | undefined,
+    dataTypeManager: ExtraDataTypeManager,
     cache: ICache
 ): Promise<DependentNamespaces> {
     const dependentNamespaces: DependentNamespaces = new Set();
     try {
-        if (dataTypeFactory.getStructureInfoForDataType(dataTypeNodeId)) {
+
+        if (dataTypeManager.getStructureInfoForDataType(dataTypeNodeId)) {
             return dependentNamespaces;
         }
         const [isAbstractDataValue, dataTypeDefinitionDataValue, browseNameDataValue] = await session.read([
@@ -55,6 +58,9 @@ export async function readDataTypeDefinitionAndBuildType(
             debugLog("Cannot find dataTypeNodeId = ", dataTypeNodeId.toString());
             return dependentNamespaces;
         }
+
+        const resolvedName = name || (browseNameDataValue.value?.value?.name as string) || "Unknown";
+
         /* istanbul ignore next */
         if (isAbstractDataValue.statusCode.isNotGood()) {
             errorLog("browseName", browseNameDataValue.value.toString());
@@ -82,7 +88,7 @@ export async function readDataTypeDefinitionAndBuildType(
 
         // get dependencies of struct
         if (dataTypeDefinition instanceof StructureDefinition && dataTypeDefinition.fields) {
-            for (const field of dataTypeDefinition.fields){
+            for (const field of dataTypeDefinition.fields) {
                 const dataTypeNamespace = field.dataType.namespace
                 if (dataTypeNamespace === dataTypeDefinition.defaultEncodingId.namespace) {
                     continue; // not dependent on own namespace
@@ -94,21 +100,23 @@ export async function readDataTypeDefinitionAndBuildType(
         const schema = await convertDataTypeDefinitionToStructureTypeSchema(
             session,
             dataTypeNodeId,
-            name,
+            resolvedName,
             dataTypeDefinition,
             null,
-            dataTypeFactory,
+            dataTypeManager,
             isAbstract,
             cache
         );
+
+        const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dataTypeNodeId.namespace);
         if (isAbstract) {
             // cannot construct an abstract structure
-            dataTypeFactory.registerAbstractStructure(dataTypeNodeId, name, schema);
+            dataTypeFactory.registerAbstractStructure(dataTypeNodeId, resolvedName, schema);
         } else {
             const Constructor = createDynamicObjectConstructorAndRegister(schema, dataTypeFactory);
         }
     } catch (err) {
-        errorLog("Error", (err as Error).message," while processing dataTypeNodeId =", dataTypeNodeId.toString());
+        errorLog("Error", (err as Error).message, " while processing dataTypeNodeId =", dataTypeNodeId.toString());
     }
     return dependentNamespaces;
 }
@@ -127,26 +135,38 @@ export async function populateDataTypeManager104(
         try {
             if (dataTypeNodeId.namespace === 0) {
                 // already known I guess
+                doDebug && debugLog("populateDataTypeManager104: skiping dataType = namespace 0", dataTypeNodeId.toString());
                 return;
             }
+
+            // register factory if not already registered
             let dataTypeFactory = dataTypeManager.getDataTypeFactory(dataTypeNodeId.namespace);
             if (!dataTypeFactory) {
                 dataTypeFactory = new DataTypeFactory([]);
                 dataTypeManager.registerDataTypeFactory(dataTypeNodeId.namespace, dataTypeFactory);
                 //   throw new Error("cannot find dataType Manager for namespace of " + dataTypeNodeId.toString());
             }
+
             // if not found already
             if (dataTypeFactory.getStructureInfoForDataType(dataTypeNodeId)) {
                 // already known !
+                doDebug && debugLog("populateDataTypeManager104: skiping dataType = already known", dataTypeNodeId.toString());
                 return;
             }
+
             // extract it formally
-            doDebug && debugLog(" DataType => ", r.browseName.toString(), dataTypeNodeId.toString());
-            const dependentNamespaces = await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, r.browseName.name!, dataTypeFactory, cache);
-            
+            doDebug && debugLog("populateDataTypeManager104: processing dataType = ", r.browseName.toString(), dataTypeNodeId.toString());
+            const dependentNamespaces = await readDataTypeDefinitionAndBuildType(
+                session,
+                dataTypeNodeId,
+                r.browseName.name!,
+                dataTypeManager,
+                cache
+            );
+
             // add dependent namespaces to dataFactoriesDependencies
             let dataFactoryDependencies = dataFactoriesDependencies.get(dataTypeNodeId.namespace);
-            if (!dataFactoryDependencies){
+            if (!dataFactoryDependencies) {
                 // add new dependencies set if not already existing
                 dataFactoryDependencies = new Set([0]); // always dependent on UA node set
                 dataFactoriesDependencies.set(dataTypeNodeId.namespace, dataFactoryDependencies);
@@ -169,11 +189,11 @@ export async function populateDataTypeManager104(
     await applyOnReferenceRecursively(session, resolveNodeId("Structure"), nodeToBrowse, withDataType);
 
     // set factory dependencies
-    for (const [namespace, dependentNamespaces] of dataFactoriesDependencies){
+    for (const [namespace, dependentNamespaces] of dataFactoriesDependencies) {
 
         const namespaceDataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(namespace);
-        const dependentTypeFactories = new Set<DataTypeFactory>([getStandardDataTypeFactory()]); 
-        
+        const dependentTypeFactories = new Set<DataTypeFactory>([getStandardDataTypeFactory()]);
+
         for (const dependentNamespace of dependentNamespaces) {
             if (dependentNamespace === 0) continue; // already added above
             const dependentTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dependentNamespace);
@@ -192,23 +212,42 @@ async function applyOnReferenceRecursively(
 ): Promise<void> {
 
 
-    const oneLevel = async (nodeId: NodeIdLike) => {
+    const hasBoosted = hasBoostedSession(session as any);
+    const useHeavyParallelization = hasBoosted;
+
+    debugLog("applyOnReferenceRecursively = useHeavyParallelization", useHeavyParallelization);
 
+    const oneLevel = async (nodeId: NodeIdLike, level: number) => {
+
+        doDebug && debugLog("applyOnReferenceRecursively = level", level, "nodeId", nodeId.toString());
         const nodeToBrowse: BrowseDescriptionOptions = {
             ...browseDescriptionTemplate,
             nodeId
         };
 
         const browseResult = await browseAll(session, nodeToBrowse);
+        if (useHeavyParallelization) {
+            // @sterfive/optimized-client (PRO module) we can 
+            // parallelize and minimize the number of calls to the server to 
+            // drastically improve performance
+            const promises: Promise<void>[] = [];
+            for (const ref of browseResult.references || []) {
+                promises.push((async () => {
+                    await action(ref);
+                    await oneLevel(ref.nodeId, level + 1);
+                })());
+            }
+            await Promise.all(promises);
 
-        const promises: Promise<void>[] = [];
-        for (const ref of browseResult.references || []) {
-            promises.push((async () => {
+        } else {
+            // important: we dont parallelize the action on browse reference
+            // to avoid overloading browseContinuationToken on client side      
+            for (const ref of browseResult.references || []) {
                 await action(ref);
-                await oneLevel(ref.nodeId);
-            })());
+                await oneLevel(ref.nodeId, level + 1);
+            }
+
         }
-        await Promise.all(promises);
     };
-    await oneLevel(nodeId);
+    await oneLevel(nodeId, 0);
 }