node-opcua-client-dynamic-extension-object 2.178.0 → 2.180.0

package/source/private/populate_data_type_manager_104.ts

@@ -1,41 +1,63 @@
 import { AttributeIds, BrowseDirection } from "node-opcua-data-model";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { DataTypeFactory, getStandardDataTypeFactory } from "node-opcua-factory";
-import { NodeId, resolveNodeId, NodeIdLike } from "node-opcua-nodeid";
-import { IBasicSessionAsync2, IBasicSessionBrowseAsync, IBasicSessionBrowseNext, IBasicSessionReadAsync, IBasicSessionTranslateBrowsePathAsync, browseAll } from "node-opcua-pseudo-session";
+import { NodeId, type NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
+import {
+    browseAll,
+    type IBasicSessionAsync2,
+    type IBasicSessionBrowseAsync,
+    type IBasicSessionBrowseNext,
+    type IBasicSessionReadAsync,
+    type IBasicSessionTranslateBrowsePathAsync
+} from "node-opcua-pseudo-session";
 import { createDynamicObjectConstructor as createDynamicObjectConstructorAndRegister } from "node-opcua-schemas";
+import { StatusCodes } from "node-opcua-status-code";
 import {
-    ReferenceDescription,
-    BrowseDescriptionOptions,
-    StructureDefinition,
-    DataTypeDefinition
+    type BrowseDescriptionOptions,
+    type DataTypeDefinition,
+    type ReferenceDescription,
+    StructureDefinition
 } from "node-opcua-types";
-//
-import { ExtraDataTypeManager } from "../extra_data_type_manager";
 import {
-    ICache,
-    convertDataTypeDefinitionToStructureTypeSchema
+    convertDataTypeDefinitionToStructureTypeSchema,
+    type ICache
 } from "../convert_data_type_definition_to_structuretype_schema";
+//
+import type { ExtraDataTypeManager } from "../extra_data_type_manager";
 import { hasBoostedSession } from "../get_extra_data_type_manager";
-import { StatusCodes } from "node-opcua-status-code";
 
 const errorLog = make_errorLog("populateDataTypeManager");
 const debugLog = make_debugLog("populateDataTypeManager");
 const warningLog = make_warningLog("populateDataTypeManager");
 const doDebug = checkDebugFlag("populateDataTypeManager");
 
-type DependentNamespaces = Set<number>
+type DependentNamespaces = Set<number>;
+
+/**
+ * A dataType that could not be turned into a constructor.
+ *
+ * These are collected rather than only logged. A failure here means the class is never
+ * registered, so decoding that extension object fails later with nothing pointing back
+ * to this load - and the 1.03 loader had exactly that fault for five standard types
+ * while every test passed. One line naming the count and the types makes the state
+ * visible without anyone having to read scrollback.
+ */
+export interface IDataTypeLoadFailure {
+    dataTypeNodeId: string;
+    name: string;
+    message: string;
+}
 
 export async function readDataTypeDefinitionAndBuildType(
     session: IBasicSessionAsync2,
     dataTypeNodeId: NodeId,
     name: string | undefined,
     dataTypeManager: ExtraDataTypeManager,
-    cache: ICache
+    cache: ICache,
+    failures?: IDataTypeLoadFailure[]
 ): Promise<DependentNamespaces> {
     const dependentNamespaces: DependentNamespaces = new Set();
     try {
-
         if (dataTypeManager.getStructureInfoForDataType(dataTypeNodeId)) {
             return dependentNamespaces;
         }
@@ -53,9 +75,10 @@ export async function readDataTypeDefinitionAndBuildType(
                 nodeId: dataTypeNodeId
             }
         ]);
-        if (isAbstractDataValue.statusCode == StatusCodes.BadNodeIdUnknown) {
+        if (isAbstractDataValue.statusCode === StatusCodes.BadNodeIdUnknown) {
             // may be model is incomplete and dataTypeNodeId is missing
-            debugLog("Cannot find dataTypeNodeId = ", dataTypeNodeId.toString());
+            // c8 ignore next
+            doDebug && debugLog("Cannot find dataTypeNodeId = ", dataTypeNodeId.toString());
             return dependentNamespaces;
         }
 
@@ -64,7 +87,9 @@ export async function readDataTypeDefinitionAndBuildType(
         /* c8 ignore next */
         if (isAbstractDataValue.statusCode.isNotGood()) {
             errorLog("browseName", browseNameDataValue.value.toString());
-            throw new Error(" Cannot find dataType isAbstract ! with nodeId =" + dataTypeNodeId.toString() + " " + isAbstractDataValue.statusCode.toString());
+            throw new Error(
+                ` Cannot find dataType isAbstract ! with nodeId =${dataTypeNodeId.toString()} ${isAbstractDataValue.statusCode.toString()}`
+            );
         }
         const isAbstract = isAbstractDataValue.value.value as boolean;
 
@@ -79,7 +104,11 @@ export async function readDataTypeDefinitionAndBuildType(
                     { nodeId: dataTypeNodeId, attributeId: AttributeIds.IsAbstract },
                     { nodeId: dataTypeNodeId, attributeId: AttributeIds.BrowseName }
                 ]);
-                warningLog(" Cannot find dataType Definition ! with nodeId =" + dataTypeNodeId.toString(), browseNameDV.value?.value?.toString(), isAbstract2.value?.value);
+                warningLog(
+                    ` Cannot find dataType Definition ! with nodeId =${dataTypeNodeId.toString()}`,
+                    browseNameDV.value?.value?.toString(),
+                    isAbstract2.value?.value
+                );
                 return dependentNamespaces;
             }
             // it is OK to not have dataTypeDefinition for Abstract type!
@@ -89,10 +118,10 @@ export async function readDataTypeDefinitionAndBuildType(
         // get dependencies of struct
         if (dataTypeDefinition instanceof StructureDefinition && dataTypeDefinition.fields) {
             for (const field of dataTypeDefinition.fields) {
-                const dataTypeNamespace = field.dataType.namespace
+                const dataTypeNamespace = field.dataType.namespace;
                 if (dataTypeNamespace === dataTypeDefinition.defaultEncodingId.namespace) {
                     continue; // not dependent on own namespace
-                };
+                }
                 dependentNamespaces.add(dataTypeNamespace);
             }
         }
@@ -113,10 +142,17 @@ export async function readDataTypeDefinitionAndBuildType(
             // cannot construct an abstract structure
             dataTypeFactory.registerAbstractStructure(dataTypeNodeId, resolvedName, schema);
         } else {
-            const Constructor = createDynamicObjectConstructorAndRegister(schema, dataTypeFactory);
+            createDynamicObjectConstructorAndRegister(schema, dataTypeFactory);
         }
     } catch (err) {
-        errorLog("Error", (err as Error).message, " while processing dataTypeNodeId =", dataTypeNodeId.toString());
+        const message = (err as Error).message;
+        if (failures) {
+            // the caller reports these together; logging here as well would only
+            // reproduce the scattered lines this is meant to replace
+            failures.push({ dataTypeNodeId: dataTypeNodeId.toString(), name: name || "?", message });
+        } else {
+            errorLog("Error", message, " while processing dataTypeNodeId =", dataTypeNodeId.toString());
+        }
     }
     return dependentNamespaces;
 }
@@ -125,10 +161,10 @@ export async function populateDataTypeManager104(
     session: IBasicSessionAsync2,
     dataTypeManager: ExtraDataTypeManager
 ): Promise<void> {
-
     const dataFactoriesDependencies = new Map<number, DependentNamespaces>();
 
     const cache: ICache = {};
+    const failures: IDataTypeLoadFailure[] = [];
 
     async function withDataType(r: ReferenceDescription): Promise<void> {
         const dataTypeNodeId = r.nodeId;
@@ -155,13 +191,18 @@ export async function populateDataTypeManager104(
             }
 
             // extract it formally
-            doDebug && debugLog("populateDataTypeManager104: processing dataType = ", r.browseName.toString(), dataTypeNodeId.toString());
+            doDebug &&
+                debugLog("populateDataTypeManager104: processing dataType = ", r.browseName.toString(), dataTypeNodeId.toString());
+            if (!r.browseName.name) {
+                throw new Error(`Unexpected: BrowseName has no name for nodeId ${dataTypeNodeId.toString()}`);
+            }
             const dependentNamespaces = await readDataTypeDefinitionAndBuildType(
                 session,
                 dataTypeNodeId,
-                r.browseName.name!,
+                r.browseName.name,
                 dataTypeManager,
-                cache
+                cache,
+                failures
             );
 
             // add dependent namespaces to dataFactoriesDependencies
@@ -171,10 +212,16 @@ export async function populateDataTypeManager104(
                 dataFactoryDependencies = new Set([0]); // always dependent on UA node set
                 dataFactoriesDependencies.set(dataTypeNodeId.namespace, dataFactoryDependencies);
             }
-            dependentNamespaces.forEach((ns) => dataFactoryDependencies.add(ns));
-
+            for (const ns of dependentNamespaces) {
+                dataFactoryDependencies.add(ns);
+            }
         } catch (err) {
-            errorLog("err=", err);
+            // named, so the summary below can say which type failed rather than "err="
+            failures.push({
+                dataTypeNodeId: dataTypeNodeId.toString(),
+                name: r.browseName.name || "?",
+                message: (err as Error).message
+            });
         }
     }
 
@@ -188,9 +235,21 @@ export async function populateDataTypeManager104(
     };
     await applyOnReferenceRecursively(session, resolveNodeId("Structure"), nodeToBrowse, withDataType);
 
+    // One line for the whole load. A dataType that fails here is simply absent from the
+    // factory, and every later decode of it fails somewhere unrelated, so the count
+    // belongs where it can be seen rather than spread across the run.
+    if (failures.length > 0) {
+        warningLog(
+            `populateDataTypeManager104: ${failures.length} dataType(s) could not be registered;` +
+                " decoding those extension objects will fail:"
+        );
+        for (const f of failures) {
+            warningLog(`    ${f.name} (${f.dataTypeNodeId}): ${f.message}`);
+        }
+    }
+
     // set factory dependencies
     for (const [namespace, dependentNamespaces] of dataFactoriesDependencies) {
-
         const namespaceDataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(namespace);
         const dependentTypeFactories = new Set<DataTypeFactory>([getStandardDataTypeFactory()]);
 
@@ -210,15 +269,13 @@ async function applyOnReferenceRecursively(
     browseDescriptionTemplate: BrowseDescriptionOptions,
     action: (ref: ReferenceDescription) => Promise<void>
 ): Promise<void> {
-
-
-    const hasBoosted = hasBoostedSession(session as any);
+    const hasBoosted = hasBoostedSession(session as unknown as IBasicSessionAsync2);
     const useHeavyParallelization = hasBoosted;
 
-    debugLog("applyOnReferenceRecursively = useHeavyParallelization", useHeavyParallelization);
+    // c8 ignore next
+    doDebug && debugLog("applyOnReferenceRecursively = useHeavyParallelization", useHeavyParallelization);
 
     const oneLevel = async (nodeId: NodeIdLike, level: number) => {
-
         doDebug && debugLog("applyOnReferenceRecursively = level", level, "nodeId", nodeId.toString());
         const nodeToBrowse: BrowseDescriptionOptions = {
             ...browseDescriptionTemplate,
@@ -227,27 +284,27 @@ async function applyOnReferenceRecursively(
 
         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 
+            // @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);
-                })());
+                promises.push(
+                    (async () => {
+                        await action(ref);
+                        await oneLevel(ref.nodeId, level + 1);
+                    })()
+                );
             }
             await Promise.all(promises);
-
         } else {
             // important: we dont parallelize the action on browse reference
-            // to avoid overloading browseContinuationToken on client side      
+            // to avoid overloading browseContinuationToken on client side
             for (const ref of browseResult.references || []) {
                 await action(ref);
                 await oneLevel(ref.nodeId, level + 1);
             }
-
         }
     };
     await oneLevel(nodeId, 0);
-}
+}

package/source/promote_opaque_structure.ts

@@ -1,6 +1,6 @@
 import { OpaqueStructure } from "node-opcua-extension-object";
-import { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
-import { DataType, VariantArrayType, Variant } from "node-opcua-variant";
+import type { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
+import { DataType, type Variant, VariantArrayType } from "node-opcua-variant";
 //
 import { getExtraDataTypeManager } from "./get_extra_data_type_manager";
 import { resolveDynamicExtensionObject } from "./resolve_dynamic_extension_object";
@@ -24,7 +24,7 @@ export function extractDataValueToPromote(dataValues: PseudoDataValue[]): Pseudo
     return dataValuesToFix;
 }
 /**
- * 
+ *
  * @private
  */
 export async function promoteOpaqueStructure(session: IBasicSessionAsync2, dataValues: PseudoDataValue[]) {

package/source/promote_opaque_structure_in_notification_data.ts

@@ -1,6 +1,6 @@
-import { NotificationData, DataChangeNotification, EventNotificationList } from "node-opcua-types";
-import { Variant, DataType } from "node-opcua-variant";
-import { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
+import type { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
+import { DataChangeNotification, EventNotificationList, type NotificationData } from "node-opcua-types";
+import { DataType, type Variant } from "node-opcua-variant";
 import { promoteOpaqueStructure } from "./promote_opaque_structure";
 
 export async function promoteOpaqueStructureInNotificationData(
@@ -24,9 +24,7 @@ export async function promoteOpaqueStructureInNotificationData(
             if (notification.events) {
                 for (const events of notification.events) {
                     if (events.eventFields) {
-                        // eslint-disable-next-line max-depth
                         for (const eventField of events.eventFields) {
-                            // eslint-disable-next-line max-depth
                             if (eventField.dataType === DataType.ExtensionObject) {
                                 dataValuesToPromote.push({ value: eventField });
                             }

package/source/resolve_dynamic_extension_object.ts

@@ -1,11 +1,11 @@
 import { BinaryStream } from "node-opcua-binary-stream";
+import { make_warningLog } from "node-opcua-debug";
 import { ExtensionObject, OpaqueStructure } from "node-opcua-extension-object";
+import type { IBaseUAObject, StructuredTypeField } from "node-opcua-factory";
+import type { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
 import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
-import { make_warningLog } from "node-opcua-debug";
-import { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
-import { StructuredTypeField } from "node-opcua-factory";
 //
-import { ExtraDataTypeManager } from "./extra_data_type_manager";
+import type { ExtraDataTypeManager } from "./extra_data_type_manager";
 
 const warningLog = make_warningLog(__filename);
 
@@ -13,10 +13,9 @@ export async function resolveOpaqueStructureInExtensionObject(
     session: IBasicSessionAsync2,
     dataTypeManager: ExtraDataTypeManager,
     object: ExtensionObject,
-    visited?: Set<any>
+    visitedParam?: Set<unknown>
 ): Promise<void> {
-
-    visited = visited || new Set();
+    const visited = visitedParam || new Set<unknown>();
     if (visited.has(object)) {
         return;
     }
@@ -25,48 +24,48 @@ export async function resolveOpaqueStructureInExtensionObject(
     interface D {
         dataTypeManager: ExtraDataTypeManager;
         promises: Promise<void>[];
-        visited: Set<any>;
+        visited: Set<unknown>;
     }
     async function fixOpaqueStructureOnElement(
-        element: any,
-        field: StructuredTypeField,
+        element: unknown,
+        _field: StructuredTypeField,
         data: D,
-        args?: any
+        _args?: unknown
     ): Promise<unknown> {
-
-
         if (!element) {
             return element;
         }
+        const elementAsRecord = element as { constructor?: { name?: string; schema?: { name?: string } } };
 
-        if (element instanceof Variant || element.constructor?.name === "Variant") {
-            await resolveDynamicExtensionObject(session, element, dataTypeManager, data.visited);
+        if (element instanceof Variant || elementAsRecord.constructor?.name === "Variant") {
+            await resolveDynamicExtensionObject(session, element as Variant, dataTypeManager, data.visited);
             return element;
         }
-        if (element instanceof ExtensionObject || element?.constructor?.schema?.name === "ExtensionObject") {
+        if (element instanceof ExtensionObject || elementAsRecord.constructor?.schema?.name === "ExtensionObject") {
             if (element instanceof OpaqueStructure) {
                 const variant = new Variant({ dataType: DataType.ExtensionObject, value: element });
                 await resolveDynamicExtensionObject(session, variant, dataTypeManager, data.visited);
                 return variant.value as unknown;
             } else {
-                await resolveOpaqueStructureInExtensionObject(session, dataTypeManager, element, data.visited);
+                await resolveOpaqueStructureInExtensionObject(session, dataTypeManager, element as ExtensionObject, data.visited);
                 return element;
             }
         }
         return element;
     }
-    function fixOpaqueStructure(object: any, field: StructuredTypeField, data: D, args?: any) {
-
+    function fixOpaqueStructure(objectArg: IBaseUAObject, field: StructuredTypeField, data: D, args?: unknown) {
+        const object = objectArg as unknown as Record<string, unknown>;
         const a = object[field.name];
         if (!a) {
             return;
         }
         if (field.isArray) {
-            for (let i = 0; i < a.length; i++) {
-                const x = a[i];
+            const arr = a as unknown[];
+            for (let i = 0; i < arr.length; i++) {
+                const x = arr[i];
                 data.promises.push(
                     (async () => {
-                        a[i] = await fixOpaqueStructureOnElement(x, field, data, args);
+                        arr[i] = await fixOpaqueStructureOnElement(x, field, data, args);
                     })()
                 );
             }
@@ -87,11 +86,11 @@ export async function resolveDynamicExtensionObject(
     session: IBasicSessionAsync2,
     variant: Variant,
     dataTypeManager: ExtraDataTypeManager,
-    visited?: Set<any>
+    visitedParam?: Set<unknown>
 ): Promise<void> {
-    visited = visited || new Set();
+    const visited = visitedParam || new Set<unknown>();
 
-    const handleValue = async (value: any): Promise<any> => {
+    const handleValue = async (value: unknown): Promise<unknown> => {
         if (!value) {
             return value;
         }
@@ -102,7 +101,7 @@ export async function resolveDynamicExtensionObject(
                 const stream = new BinaryStream(value.buffer);
                 try {
                     object.decode(stream);
-                    await resolveOpaqueStructureInExtensionObject(session, dataTypeManager, object, visited!);
+                    await resolveOpaqueStructureInExtensionObject(session, dataTypeManager, object, visited);
                     return object;
                 } catch (err) {
                     warningLog("resolveDynamicExtensionObjectV: error decoding or resolving inner structures");
@@ -120,15 +119,15 @@ export async function resolveDynamicExtensionObject(
             }
         }
         if (value instanceof ExtensionObject) {
-            await resolveOpaqueStructureInExtensionObject(session, dataTypeManager, value, visited!);
+            await resolveOpaqueStructureInExtensionObject(session, dataTypeManager, value, visited);
             return value;
         }
         if (value instanceof Variant) {
-            await resolveDynamicExtensionObject(session, value, dataTypeManager, visited!);
+            await resolveDynamicExtensionObject(session, value, dataTypeManager, visited);
             return value;
         }
         return value;
-    }
+    };
 
     if (variant.arrayType !== VariantArrayType.Scalar) {
         if (Array.isArray(variant.value)) {