node-opcua-address-space 2.164.2 → 2.165.0

package/src/ua_data_type_impl.ts

@@ -2,63 +2,41 @@
  * @module node-opcua-address-space
  */
 import chalk from "chalk";
-
+import type { BaseNode, ISessionContext, UADataType, UAObject, UAVariable } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
-import { NodeClass, QualifiedNameLike } from "node-opcua-data-model";
-import { AttributeIds } from "node-opcua-data-model";
-import { DataValue, DataValueLike } from "node-opcua-data-value";
-import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
+import { coerceInt64, coerceInt64toInt32, type Int64 } from "node-opcua-basic-types";
+import { DataTypeIds } from "node-opcua-constants";
+import { AttributeIds, type LocalizedText, NodeClass, type QualifiedNameLike } from "node-opcua-data-model";
+import { DataValue, type DataValueLike } from "node-opcua-data-value";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { ExpandedNodeId, NodeId, resolveNodeId } from "node-opcua-nodeid";
 import { NumericRange } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
 import {
-    DataTypeDefinition,
+    type DataTypeDefinition,
     EnumDefinition,
-    EnumFieldOptions,
+    type EnumFieldOptions,
+    type EnumValueType,
     StructureDefinition,
-    StructureFieldOptions,
+    type StructureFieldOptions,
     StructureType
 } from "node-opcua-types";
-import {
-    DataType
-} from "node-opcua-variant";
-import {
-    UAObject,
-    ISessionContext,
-    UADataType,
-    UAVariable,
-    BaseNode
-} from "node-opcua-address-space-base";
-import {
-    DataTypeIds
-} from "node-opcua-constants";
-import {
-    Int64,
-    coerceInt64,
-    coerceInt64toInt32
-} from "node-opcua-basic-types";
+import { DataType } from "node-opcua-variant";
+import type { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
 import { SessionContext } from "../source/session_context";
-import { ExtensionObjectConstructorFuncWithSchema } from "../source/interfaces/extension_object_constructor";
-import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
+import { BaseNodeImpl, type InternalBaseNodeOptions } from "./base_node_impl";
 import {
+    BaseNode_getCache,
     BaseNode_References_toString,
     BaseNode_toString,
     ToStringBuilder,
-    ToStringOption
+    type ToStringOption
 } from "./base_node_private";
-import { construct_isSubtypeOf } from "./tool_isSubtypeOf";
-import { get_subtypeOf } from "./tool_isSubtypeOf";
-import { get_subtypeOfObj } from "./tool_isSubtypeOf";
-import { BaseNode_getCache } from "./base_node_private";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-
+import { construct_isSubtypeOf, get_subtypeOf, get_subtypeOfObj } from "./tool_isSubtypeOf";
 
 const debugLog = make_debugLog("DATA_TYPE");
 const doDebug = checkDebugFlag("DATA_TYPE");
 
-export interface UADataTypeImpl {
-    _extensionObjectConstructor: ExtensionObjectConstructorFuncWithSchema;
-}
-
 
 export interface StructureFieldOptionsEx extends StructureFieldOptions {
     allowSubTypes: boolean;
@@ -80,6 +58,7 @@ export interface UADataTypeOptions extends InternalBaseNodeOptions {
 }
 
 export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
+    public _extensionObjectConstructor!: ExtensionObjectConstructorFuncWithSchema;
     public readonly nodeClass = NodeClass.DataType;
     public readonly definitionName: string = "";
     public readonly symbolicName: string;
@@ -100,7 +79,7 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
     }
 
     public get subtypeOfObj(): UADataType | null {
-        return get_subtypeOfObj.call(this) as any as UADataType;
+        return get_subtypeOfObj.call(this) as unknown as UADataType;
     }
 
     /** @deprecated */
@@ -108,10 +87,8 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
     public isSubtypeOf = construct_isSubtypeOf<UADataType>(UADataTypeImpl);
 
     public readonly isAbstract: boolean;
-
-    private $isUnion?: boolean;
-    private enumStrings?: any;
-    private enumValues?: any;
+    private enumStrings?: UAVariable;
+    private enumValues?: UAVariable;
     private $partialDefinition?: StructureFieldOptionsEx[] | EnumFieldOptions[];
     private $fullDefinition?: StructureDefinition | EnumDefinition;
 
@@ -119,10 +96,9 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
         super(options);
         if (options.partialDefinition) {
             this.$partialDefinition = options.partialDefinition;
-            this.$isUnion = options.isUnion;
         }
         this.isAbstract = options.isAbstract === undefined || options.isAbstract === null ? false : options.isAbstract;
-        this.symbolicName = options.symbolicName || this.browseName.name!;
+        this.symbolicName = options.symbolicName || this.browseName.name || "";
     }
 
     public get basicDataType(): DataType {
@@ -165,10 +141,10 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
     public getEncodingDefinition(encoding_name: string): string | null {
         const encodingNode = this.getEncodingNode(encoding_name);
         if (!encodingNode) {
-            throw new Error("Cannot find Encoding for " + encoding_name);
+            throw new Error(`Cannot find Encoding for ${encoding_name}`);
         }
         const indexRange = new NumericRange();
-        const descriptionNodeRef = encodingNode.findReferences("HasDescription")[0]!;
+        const descriptionNodeRef = encodingNode.findReferences("HasDescription")[0];
         const descriptionNode = this.addressSpace.findNode(descriptionNodeRef.nodeId) as UAVariable;
         if (!descriptionNode) {
             return null;
@@ -180,7 +156,7 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
     public getEncodingNode(encoding_name: string): UAObject | null {
         const _cache = BaseNode_getCache(this);
         _cache._encoding = _cache._encoding || new Map();
-        const key = encoding_name + "Node";
+        const key = `${encoding_name}Node`;
         if (!_cache._encoding.has(key)) {
             assert(encoding_name === "Default Binary" || encoding_name === "Default XML" || encoding_name === "Default JSON");
             // could be binary or xml
@@ -188,11 +164,11 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
             const addressSpace = this.addressSpace;
             const encoding = refs
                 .map((ref) => addressSpace.findNode(ref.nodeId))
-                .filter((obj: any) => obj !== null)
-                .filter((obj: any) => obj.browseName.toString() === encoding_name);
+                .filter((obj): obj is BaseNode => obj !== null)
+                .filter((obj) => obj.browseName.toString() === encoding_name);
             const node = encoding.length === 0 ? null : (encoding[0] as UAObject);
             _cache._encoding.set(key, node);
-            return node
+            return node;
         }
         return _cache._encoding.get(key) || null;
     }
@@ -247,7 +223,7 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
         if (this.enumStrings) {
             const enumStrings = this.enumStrings.readValue().value.value;
             assert(Array.isArray(enumStrings));
-            definition = enumStrings.map((e: any, index: number) => {
+            definition = enumStrings.map((e: LocalizedText, index: number) => {
                 return {
                     name: e.text,
                     value: index
@@ -257,7 +233,7 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
             assert(this.enumValues, "must have a enumValues property");
             const enumValues = this.enumValues.readValue().value.value;
             assert(Array.isArray(enumValues));
-            definition = enumValues.map((e: any) => {
+            definition = enumValues.map((e: EnumValueType) => {
                 return {
                     name: e.displayName.text,
                     value: coerceInt64toInt32(e.value)
@@ -317,9 +293,8 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
 
         // https://reference.opcfoundation.org/v105/Core/docs/Part3/8.49/#Table34
         if (isStructure) {
-
             let dataTypeNode: UADataTypeImpl | null = this;
-            const allPartialDefinitions: (StructureFieldOptionsEx[])[] = [];
+            const allPartialDefinitions: StructureFieldOptionsEx[][] = [];
             while (dataTypeNode && !isRootDataType(dataTypeNode)) {
                 if (dataTypeNode.$partialDefinition) {
                     allPartialDefinitions.push(dataTypeNode.$partialDefinition as StructureFieldOptionsEx[]);
@@ -337,14 +312,7 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
 
             const defaultEncodingId = this.binaryEncodingNodeId || this.xmlEncodingNodeId || new NodeId();
 
-
-
-            this.$fullDefinition = makeStructureDefinition(
-                basicDataType,
-                defaultEncodingId,
-                definitionFields,
-                isUnion
-            );
+            this.$fullDefinition = makeStructureDefinition(basicDataType, defaultEncodingId, definitionFields, isUnion);
         } else if (isEnumeration) {
             const allPartialDefinitions: StructureFieldOptions[][] = [];
             // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -363,7 +331,7 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
             this.$fullDefinition = makeEnumDefinition(definitionFields);
         }
 
-        return this.$fullDefinition!;
+        return this.$fullDefinition as DataTypeDefinition;
     }
 
     public getDefinition(): DataTypeDefinition {
@@ -395,14 +363,14 @@ function dataTypeDefinition_toString(this: UADataTypeImpl, options: ToStringOpti
     const output = definition.toString();
     options.add(options.padding + chalk.yellow(" Definition                   :             "));
     for (const str of output.split("\n")) {
-        options.add(options.padding + chalk.yellow("                              :   " + str));
+        options.add(options.padding + chalk.yellow(`                              :   ${str}`));
     }
 }
 
 export function DataType_toString(this: UADataTypeImpl, options: ToStringOption): void {
     BaseNode_toString.call(this, options);
-    options.add(options.padding + chalk.yellow("          isAbstract          : " + this.isAbstract));
-    options.add(options.padding + chalk.yellow("          definitionName      : " + this.definitionName));
+    options.add(options.padding + chalk.yellow(`          isAbstract          : ${this.isAbstract}`));
+    options.add(options.padding + chalk.yellow(`          definitionName      : ${this.definitionName}`));
 
     options.add(
         options.padding +
@@ -450,7 +418,6 @@ function makeStructureDefinition(
     fields: StructureFieldOptionsEx[],
     isUnion: boolean
 ): StructureDefinition {
-
     const hasSubtypedFields = fields.filter((field) => field.allowSubTypes).length > 0;
 
     if (hasSubtypedFields && doDebug) {
@@ -463,18 +430,15 @@ function makeStructureDefinition(
     }
     const hasOptionalFields = fields.filter((field) => field.isOptional).length > 0;
 
-
-
     const structureType = isUnion
-        ?
-        (
-            hasSubtypedFields ? StructureType.UnionWithSubtypedValues : StructureType.Union
-        )
+        ? hasSubtypedFields
+            ? StructureType.UnionWithSubtypedValues
+            : StructureType.Union
         : hasOptionalFields
             ? StructureType.StructureWithOptionalFields
-            : (
-                hasSubtypedFields ? StructureType.StructureWithSubtypedValues : StructureType.Structure
-            );
+            : hasSubtypedFields
+                ? StructureType.StructureWithSubtypedValues
+                : StructureType.Structure;
 
     // note:  https://reference.opcfoundation.org/Core/Part3/v105/docs/8.51
     // field.isOptional has a special behavior depending on the structure type
@@ -490,8 +454,7 @@ function makeStructureDefinition(
     // indicate if the data type field allows subtyping.Subtyping is allowed when set to TRUE.
 
     const isUnionOrStructureWithSubtypedValues =
-        structureType === StructureType.UnionWithSubtypedValues ||
-        structureType === StructureType.StructureWithSubtypedValues;
+        structureType === StructureType.UnionWithSubtypedValues || structureType === StructureType.StructureWithSubtypedValues;
 
     if (isUnionOrStructureWithSubtypedValues) {
         for (const field of fields) {
@@ -503,10 +466,18 @@ function makeStructureDefinition(
         }
     }
 
+    // Normalize: default missing field dataType to BaseDataType (i=24)
+    // per OPC UA spec, a missing DataType should reference BaseDataType,
+    // not Null NodeId (i=0)
+    const baseDataTypeNodeId = resolveNodeId(DataTypeIds.BaseDataType);
+
     const sd = new StructureDefinition({
         baseDataType,
         defaultEncodingId,
-        fields,
+        fields: fields.map((f) => ({
+            ...f,
+            dataType: f.dataType ?? baseDataTypeNodeId
+        })),
         structureType
     });
     return sd;

package/src/ua_method_impl.ts

@@ -1,7 +1,7 @@
 /**
  * @module node-opcua-address-space
  */
-import { callbackify, types } from "util";
+import { callbackify } from "util";
 import chalk from "chalk";
 import { assert } from "node-opcua-assert";
 
@@ -12,7 +12,7 @@ import { make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug"
 import { NodeId } from "node-opcua-nodeid";
 import { NumericRange } from "node-opcua-numeric-range";
 import { Argument } from "node-opcua-service-call";
-import { CallbackT, StatusCodes } from "node-opcua-status-code";
+import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
 import { CallMethodResultOptions, PermissionType } from "node-opcua-types";
 import { Variant } from "node-opcua-variant";
 import { DataType, VariantLike } from "node-opcua-variant";
@@ -209,47 +209,90 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
 
         context.object = object;
 
-        try {
-            this._asyncExecutionFunction.call(
-                this as UAMethodImpl,
-                inputArguments as Variant[],
-                context,
-                (err: Error | null, callMethodResult?: CallMethodResultOptions) => {
-                    if (err) {
-                        debugLog(err.message);
-                        debugLog(err);
+        // ── method call interceptors ──
+        const addressSpace = this.addressSpace as AddressSpacePrivate;
+        const interceptors = addressSpace._methodCallInterceptors;
+        const self = this;
+        const coercedInputArguments = inputArguments as Variant[];
+        const callObject = object;
+
+        const runInterceptorsAndExecute = async () => {
+            // Run interceptors sequentially
+            for (const interceptor of interceptors) {
+                let status: StatusCode;
+                try {
+                    status = await interceptor(context, callObject, self, coercedInputArguments);
+                } catch (err) {
+                    if (err instanceof Error) {
+                        warningLog(chalk.red("ERR in method interceptor"), err.message);
                     }
-                    callMethodResult = callMethodResult || {};
-
-                    callMethodResult.statusCode = callMethodResult.statusCode || StatusCodes.Good;
-                    callMethodResult.outputArguments = callMethodResult.outputArguments || [];
-
-                    callMethodResult.inputArgumentResults =
-                        callMethodResult.inputArgumentResults?.length === inputArguments?.length
-                            ? callMethodResult.inputArgumentResults
-                            : inputArguments?.map(() => StatusCodes.Good);
-                    callMethodResult.inputArgumentDiagnosticInfos =
-                        callMethodResult.inputArgumentDiagnosticInfos || inputArgumentDiagnosticInfos;
-
-                    // verify that output arguments are correct according to schema
-                    // Todo : ...
-                    // const outputArgsDef = this.getOutputArguments();
-
-                    // xx assert(outputArgsDef.length === callMethodResponse.outputArguments.length,
-                    // xx     "_asyncExecutionFunction did not provide the expected number of output arguments");
-                    // to be continued ...
+                    const callMethodResponse = { statusCode: StatusCodes.BadInternalError };
+                    callback!(err as Error, callMethodResponse);
+                    return;
+                }
+                if (status !== StatusCodes.Good) {
+                    const callMethodResult: CallMethodResultOptions = {
+                        statusCode: status,
+                        outputArguments: [],
+                        inputArgumentResults: coercedInputArguments?.map(() => status) || [],
+                        inputArgumentDiagnosticInfos
+                    };
+                    return callback!(null, callMethodResult);
+                }
+            }
 
-                    callback(err, callMethodResult);
+            // All interceptors passed — execute the method body
+            try {
+                self._asyncExecutionFunction!.call(
+                    self as UAMethodImpl,
+                    coercedInputArguments,
+                    context,
+                    (err: Error | null, callMethodResult?: CallMethodResultOptions) => {
+                        if (err) {
+                            debugLog(err.message);
+                            debugLog(err);
+                        }
+                        callMethodResult = callMethodResult || {};
+
+                        callMethodResult.statusCode = callMethodResult.statusCode || StatusCodes.Good;
+                        callMethodResult.outputArguments = callMethodResult.outputArguments || [];
+
+                        callMethodResult.inputArgumentResults =
+                            callMethodResult.inputArgumentResults?.length === coercedInputArguments?.length
+                                ? callMethodResult.inputArgumentResults
+                                : coercedInputArguments?.map(() => StatusCodes.Good);
+                        callMethodResult.inputArgumentDiagnosticInfos =
+                            callMethodResult.inputArgumentDiagnosticInfos || inputArgumentDiagnosticInfos;
+
+                        // ── afterCall event ──
+                        try {
+                            self.emit("afterCall", context, coercedInputArguments, callMethodResult);
+                        } catch (afterCallErr) {
+                            if (afterCallErr instanceof Error) {
+                                warningLog(chalk.red("ERR in afterCall listener"), afterCallErr.message);
+                            }
+                        }
+
+                        callback!(err, callMethodResult);
+                    }
+                );
+            } catch (err) {
+                if (err instanceof Error) {
+                    warningLog(chalk.red("ERR in method  handler"), err.message);
+                    warningLog(err.stack);
                 }
-            );
-        } catch (err) {
-            if (types.isNativeError(err)) {
-                warningLog(chalk.red("ERR in method  handler"), err.message);
-                warningLog(err.stack);
+                const callMethodResponse = { statusCode: StatusCodes.BadInternalError };
+                callback!(err as Error, callMethodResponse);
+            }
+        };
+
+        runInterceptorsAndExecute().catch((err) => {
+            if (err instanceof Error) {
+                warningLog(chalk.red("ERR in method interceptor"), err.message);
             }
             const callMethodResponse = { statusCode: StatusCodes.BadInternalError };
-            callback(err as Error, callMethodResponse);
-        }
+            callback!(err as Error, callMethodResponse);
+        });
     }
 
     public clone(options: CloneOptions, optionalFilter?: CloneFilter, extraInfo?: CloneExtraInfo): UAMethod {
@@ -272,7 +315,7 @@ export class UAMethodImpl extends BaseNodeImpl implements UAMethod {
             UAMethodImpl,
             options,
             optionalFilter || defaultCloneFilter,
-            extraInfo 
+            extraInfo
         ) as UAMethodImpl;
 
         clonedMethod._asyncExecutionFunction = this._asyncExecutionFunction;

package/src/ua_variable_impl_ext_obj.ts

@@ -153,13 +153,57 @@ export function setExtensionObjectPartialValue(node: UAVariableImpl, partialObje
 
     const extensionObject = node.$extensionObject;
     if (!extensionObject) {
-        throw new Error("setExtensionObjectValue node has no extension object " + node.browseName.toString());
+        throw new Error(`setExtensionObjectValue node has no extension object ${node.browseName.toString()}`);
+    }
+    /**
+     * Returns true if the value is a structure-like object that should
+     * be recursed into during a partial update.
+     *
+     * For the existing extension object (extObject[prop]):
+     *  - Proxied sub-extension objects → recurse (they have $isProxy)
+     * For the incoming partial object (partialObject1[prop]):
+     *  - Plain objects {} → recurse (from constructExtensionObject or literals)
+     *
+     * Everything else (Date, Buffer, NodeId, QualifiedName, LocalizedText,
+     * DiagnosticInfo, arrays, etc.) is a terminal value and should be
+     * assigned directly — even if it has a `schema` property.
+     */
+    function _shouldRecurseIntoExisting(value: any): boolean {
+        if (value === null || value === undefined) return false;
+        if (typeof value !== "object") return false;
+        if (Array.isArray(value)) return false;
+        // proxied sub-structures: installed by bindExtensionObject for nested structs
+        if (isProxy(value)) return true;
+        // plain objects (unlikely on the existing side but safe fallback)
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null) return true;
+        return false;
+    }
+
+    function _shouldRecurseIntoNew(value: any): boolean {
+        if (value === null || value === undefined) return false;
+        if (typeof value !== "object") return false;
+        if (Array.isArray(value)) return false;
+        // plain objects: partial update literals like { field1: v1 }
+        const proto = Object.getPrototypeOf(value);
+        if (proto === Object.prototype || proto === null) return true;
+        // extension objects from constructExtensionObject have a schema
+        // but so do QualifiedName/LocalizedText — we disambiguate by
+        // checking the *existing* side with isProxy, not here.
+        // Instead, only recurse if it's a schema'd type AND has
+        // Extension-Object-like characteristics (constructor with schema.name)
+        if (value.schema !== undefined && value.constructor?.name !== "QualifiedName"
+            && value.constructor?.name !== "LocalizedText"
+            && value.constructor?.name !== "DiagnosticInfo") {
+            return true;
+        }
+        return false;
     }
 
     function _update_extension_object(extObject: any, partialObject1: any) {
         const keys = Object.keys(partialObject1);
         for (const prop of keys) {
-            if (extObject[prop] instanceof Object) {
+            if (_shouldRecurseIntoExisting(extObject[prop]) && _shouldRecurseIntoNew(partialObject1[prop])) {
                 _update_extension_object(extObject[prop], partialObject1[prop]);
             } else {
                 if (isProxy(extObject)) {