node-opcua-address-space 2.179.0 → 2.181.0

package/api/helpers/argument_list.ts

@@ -0,0 +1,310 @@
+/**
+ * @module node-opcua-address-space
+ */
+
+import type { IAddressSpace, UAMethod, UAObject } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { decodeArray, encodeArray } from "node-opcua-basic-types";
+import { type BinaryStream, BinaryStreamSizeCalculator, type OutputBinaryStream } from "node-opcua-binary-stream";
+import { DataTypeIds } from "node-opcua-constants";
+import { NodeClass } from "node-opcua-data-model";
+import { checkDebugFlag, make_debugLog, make_warningLog } from "node-opcua-debug";
+import { type BasicTypeDefinition, findBuiltInType } from "node-opcua-factory";
+import { coerceNodeId, type NodeId, resolveNodeId } from "node-opcua-nodeid";
+import type { Argument } from "node-opcua-service-call";
+import { type StatusCode, StatusCodes } from "node-opcua-status-code";
+import { DataType, type Variant, VariantArrayType } from "node-opcua-variant";
+
+const debugLog = make_debugLog("argument_list");
+const warningLog = make_warningLog("argument_list");
+const doDebug = checkDebugFlag("argument_list");
+
+function myfindBuiltInType(dataType: DataType): BasicTypeDefinition {
+    return findBuiltInType(DataType[dataType]);
+}
+export interface ArgumentDef {
+    dataType: DataType;
+    valueRank?: undefined | number;
+}
+export function encode_ArgumentList(definition: ArgumentDef[], args: unknown[], stream: OutputBinaryStream): void {
+    assert(definition.length === args.length);
+
+    assert(Array.isArray(definition));
+    assert(Array.isArray(args));
+    assert(definition.length === args.length);
+    assert(definition.length >= 0);
+
+    // we only encode arguments by following the definition
+
+    for (let i = 0; i < definition.length; i++) {
+        const def = definition[i];
+        const value = args[i];
+
+        const encodeFunc = myfindBuiltInType(def.dataType).encode;
+        if (!encodeFunc) {
+            throw new Error(
+                "This BaseDataType cannot be encoded because it has no definition.\n" +
+                    "Please construct a BaseDataType({definition : [{dataType: DataType.UInt32 }]});"
+            );
+        }
+        // assert((def.valueRank === -1) || (def.valueRank === 0));
+
+        // todo : handle -3 -2
+        const isArray = def.valueRank && (def.valueRank === 1 || def.valueRank !== -1);
+
+        if (isArray) {
+            encodeArray(value as unknown[], stream, encodeFunc);
+        } else {
+            encodeFunc(value, stream);
+        }
+    }
+}
+
+export function decode_ArgumentList(definition: ArgumentDef[], stream: BinaryStream): unknown[] {
+    // c8 ignore next
+    if (!Array.isArray(definition)) {
+        throw new Error(
+            "This BaseDataType cannot be decoded because it has no definition.\n" +
+                "Please construct a BaseDataType({definition : [{dataType: DataType.UInt32 }]});"
+        );
+    }
+
+    const args: unknown[] = [];
+    let value: unknown;
+
+    for (const def of definition) {
+        const decodeFunc = myfindBuiltInType(def.dataType).decode;
+        if (!decodeFunc) {
+            throw new Error(
+                "This BaseDataType cannot be decoded because it has no definition.\n" +
+                    "Please construct a BaseDataType({definition : [{dataType: DataType.UInt32 }]});"
+            );
+        }
+        // assert(def.valueRank === -1 || def.valueRank==0);
+        // todo : handle -3 -2
+        // xx assert(def.valueRank === -1 || def.valueRank==0);
+        const isArray = def.valueRank === 1 || def.valueRank === -1;
+
+        if (isArray) {
+            value = decodeArray(stream, decodeFunc);
+        } else {
+            value = decodeFunc(stream);
+        }
+        args.push(value);
+    }
+    return args;
+}
+
+export function binaryStoreSize_ArgumentList(description: ArgumentDef[], args: unknown[]): number {
+    assert(Array.isArray(description));
+    assert(Array.isArray(args));
+    assert(args.length === description.length);
+
+    const stream = new BinaryStreamSizeCalculator();
+    encode_ArgumentList(description, args, stream);
+    return stream.length;
+}
+
+export function getMethodDeclaration_ArgumentList(
+    addressSpace: IAddressSpace,
+    objectId: NodeId,
+    methodId: NodeId
+): { statusCode: StatusCode; methodDeclaration?: UAMethod } {
+    // find object in address space
+    const obj = addressSpace.findNode(objectId) as UAObject;
+    if (!obj) {
+        // c8 ignore next
+        doDebug && debugLog("cannot find node ", objectId.toString());
+
+        return { statusCode: StatusCodes.BadNodeIdUnknown };
+    }
+    let objectMethod = obj.getMethodById(methodId) as UAMethod;
+    if (!objectMethod) {
+        // the method doesn't belong to the object, nevertheless
+        // the method can be called
+        objectMethod = addressSpace.findNode(methodId) as UAMethod;
+        if (!objectMethod || objectMethod.nodeClass !== NodeClass.Method) {
+            warningLog("cannot find method with id", methodId.toString(), "object Id = ", objectId.toString());
+            return { statusCode: StatusCodes.BadMethodInvalid };
+        }
+    }
+
+    const methodDeclarationId = objectMethod.methodDeclarationId;
+    const methodDeclaration = addressSpace.findNode(methodDeclarationId) as UAMethod;
+    if (!methodDeclaration) {
+        //  return {statusCode: StatusCodes.BadMethodInvalid};
+        return { statusCode: StatusCodes.Good, methodDeclaration: objectMethod };
+    }
+    // c8 ignore next
+    if (methodDeclaration.nodeClass !== NodeClass.Method) {
+        throw new Error("Expecting a Method here");
+    }
+    return { statusCode: StatusCodes.Good, methodDeclaration };
+}
+
+function checkValueRank(argDefinition: Argument, arg: Variant) {
+    const isArray = arg.arrayType === VariantArrayType.Array;
+    const isMatrix = arg.arrayType === VariantArrayType.Matrix;
+
+    if (argDefinition.valueRank > 0) {
+        if (argDefinition.valueRank === 1) {
+            if (!isArray) {
+                return false;
+            }
+        } else {
+            if (!isMatrix) {
+                return false;
+            }
+        }
+    } else if (argDefinition.valueRank === -1) {
+        // SCALAR
+        if (isArray || isMatrix) {
+            return false;
+        }
+    } else if (argDefinition.valueRank === -2) {
+        // ANY
+    } else if (argDefinition.valueRank === -3) {
+        // Scalar or OneDim
+        if (isMatrix) {
+            return false;
+        }
+    } else if (argDefinition.valueRank === 0) {
+        // array or matrix
+        if (!isArray && !isMatrix) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @private
+ */
+export function isArgumentValid(addressSpace: IAddressSpace, argDefinition: Argument, arg: Variant): boolean {
+    assert(Object.hasOwn(argDefinition, "dataType"));
+    assert(Object.hasOwn(argDefinition, "valueRank"));
+
+    const argDefDataType = addressSpace.findDataType(argDefinition.dataType);
+    const argDataType = addressSpace.findDataType(resolveNodeId(arg.dataType));
+
+    // c8 ignore next
+    if (!argDefDataType) {
+        // c8 ignore next
+        doDebug && debugLog("dataType ", argDefinition.dataType.toString(), "doesn't exist");
+        return false;
+    }
+
+    if (argDefinition.valueRank >= 0 && arg.dataType === DataType.Null) {
+        // this is valid to receive an empty array ith DataType.Null;
+        return true;
+    }
+
+    if (!checkValueRank(argDefinition, arg)) {
+        return false;
+    }
+
+    // c8 ignore next
+    if (!argDataType) {
+        doDebug && debugLog(" cannot find dataType ", arg.dataType, resolveNodeId(arg.dataType));
+        doDebug && debugLog(" arg = ", arg.toString());
+        doDebug && debugLog(" def =", argDefinition.toString());
+        return false;
+    }
+
+    // c8 ignore next
+    if (doDebug) {
+        doDebug && debugLog(" checking argDefDataType ", argDefDataType.toString());
+        doDebug && debugLog(" checking argDataType ", argDataType.toString());
+    }
+
+    if (argDataType.nodeId.value === argDefDataType?.nodeId.value) {
+        return true;
+    }
+
+    // check that dataType is of the same type (derived )
+    if (argDefDataType.isSubtypeOf(argDataType)) {
+        // like argDefDataType IntegerId and argDataType Uint32
+        return true;
+    }
+    if (argDataType.isSubtypeOf(argDefDataType)) {
+        // like argDefDataType BaseDataType and argDataType any Type
+        return true;
+    }
+
+    // special case for Enumeration
+    if (arg.dataType === DataType.Int32) {
+        const enumDataType = addressSpace.findDataType(coerceNodeId(DataTypeIds.Enumeration));
+        if (enumDataType && argDefDataType.isSubtypeOf(enumDataType)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ */
+export function verifyArguments_ArgumentList(
+    addressSpace: IAddressSpace,
+    methodInputArguments: Argument[],
+    inputArguments: Variant[]
+): {
+    inputArgumentResults?: StatusCode[];
+    statusCode: StatusCode;
+} {
+    const inputArgumentResults: StatusCode[] = methodInputArguments.map((methodInputArgument, index) => {
+        const argument = inputArguments?.[index];
+        if (!argument) {
+            return StatusCodes.BadNoData;
+        } else if (!isArgumentValid(addressSpace, methodInputArgument, argument)) {
+            return StatusCodes.BadTypeMismatch;
+        } else {
+            return StatusCodes.Good;
+        }
+    });
+
+    if (methodInputArguments.length > inputArguments.length) {
+        // c8 ignore next
+        doDebug &&
+            debugLog(
+                "verifyArguments_ArgumentList " +
+                    "\n       The client did  specify too many input arguments for the method.  " +
+                    "\n        expected : " +
+                    methodInputArguments.length +
+                    "" +
+                    "\n        actual   : " +
+                    inputArguments.length
+            );
+
+        return { inputArgumentResults, statusCode: StatusCodes.BadArgumentsMissing };
+    }
+
+    if (methodInputArguments.length < inputArguments.length) {
+        // c8 ignore next
+        doDebug &&
+            debugLog(
+                " verifyArguments_ArgumentList " +
+                    "\n        The client did not specify all of the input arguments for the method. " +
+                    "\n        expected : " +
+                    methodInputArguments.length +
+                    "" +
+                    "\n        actual   : " +
+                    inputArguments.length
+            );
+
+        return { inputArgumentResults, statusCode: StatusCodes.BadTooManyArguments };
+    }
+
+    const hasBadTypeMismatch = inputArgumentResults.includes(StatusCodes.BadTypeMismatch);
+    const hasBadOutOfRange = inputArgumentResults.includes(StatusCodes.BadOutOfRange);
+
+    const statusCode =
+        hasBadTypeMismatch || hasBadOutOfRange
+            ? hasBadTypeMismatch && !hasBadOutOfRange
+                ? StatusCodes.BadTypeMismatch
+                : StatusCodes.BadInvalidArgument
+            : StatusCodes.Good;
+
+    return {
+        inputArgumentResults,
+        statusCode
+    };
+}

package/api/helpers/call_helpers.ts

@@ -0,0 +1,100 @@
+/**
+ * @module node-opcua-address-space
+ */
+
+import type { IAddressSpace, ISessionContext, UAMethod, UAObject } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { NodeClass } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import type { CallMethodRequest } from "node-opcua-service-call";
+import { StatusCodes } from "node-opcua-status-code";
+import type { CallMethodResultOptions } from "node-opcua-types";
+import type { Variant } from "node-opcua-variant";
+
+import { getMethodDeclaration_ArgumentList, verifyArguments_ArgumentList } from "./argument_list.js";
+import { resolveOpaqueOnAddressSpace } from "./resolve_opaque_on_address_space.js";
+
+// Symbolic Id                   Description
+// ----------------------------  -----------------------------------------------------------------------------
+// BadNodeIdInvalid              Used to indicate that the specified object is not valid.
+//
+// BadNodeIdUnknown             Used to indicate that the specified object is not valid.
+//
+// BadArgumentsMissing          The client did not specify all of the input arguments for the method.
+// BadUserAccessDenied
+//
+// BadMethodInvalid             The method id does not refer to a method for the specified object.
+// BadOutOfRange                Used to indicate that an input argument is outside the acceptable range.
+// BadTypeMismatch              Used to indicate that an input argument does not have the correct data type.
+//                               A ByteString is structurally the same as a one dimensional array of Byte.
+//                               A server shall accept a ByteString if an array of Byte is expected.
+// BadNoCommunication
+
+export async function callMethodHelper(
+    context: ISessionContext,
+    addressSpace: IAddressSpace,
+    callMethodRequest: CallMethodRequest
+): Promise<CallMethodResultOptions> {
+    const objectId = callMethodRequest.objectId;
+    const methodId = callMethodRequest.methodId;
+    const inputArguments = callMethodRequest.inputArguments || [];
+
+    assert(objectId instanceof NodeId);
+    assert(methodId instanceof NodeId);
+
+    const object = addressSpace.findNode(objectId) as UAObject;
+    if (!object) {
+        return { statusCode: StatusCodes.BadNodeIdUnknown };
+    }
+    if (object.nodeClass !== NodeClass.Object && object.nodeClass !== NodeClass.ObjectType) {
+        return { statusCode: StatusCodes.BadNodeIdInvalid };
+    }
+
+    const methodObj = addressSpace.findNode(methodId) as UAMethod;
+    if (!methodObj) {
+        return { statusCode: StatusCodes.BadMethodInvalid };
+    }
+    if (methodObj.nodeClass !== NodeClass.Method) {
+        return { statusCode: StatusCodes.BadMethodInvalid };
+    }
+
+    const response1 = getMethodDeclaration_ArgumentList(addressSpace, objectId, methodId);
+
+    if (response1.statusCode.isNotGood()) {
+        return { statusCode: response1.statusCode };
+    }
+    const methodDeclaration = response1.methodDeclaration;
+    if (!methodDeclaration) {
+        return { statusCode: StatusCodes.BadMethodInvalid };
+    }
+
+    // verify input Parameters
+    const methodInputArguments = methodDeclaration.getInputArguments();
+
+    const response = verifyArguments_ArgumentList(addressSpace, methodInputArguments, inputArguments);
+    if (response.statusCode.isNotGood()) {
+        return response;
+    }
+
+    try {
+        await resolveOpaqueOnAddressSpace(addressSpace, inputArguments);
+
+        const callMethodResponse = await methodObj.execute(object, inputArguments, context);
+        callMethodResponse.inputArgumentResults = callMethodResponse.inputArgumentResults || response.inputArgumentResults || [];
+        assert(callMethodResponse.statusCode);
+
+        if (callMethodResponse.statusCode?.isGood()) {
+            assert(Array.isArray(callMethodResponse.outputArguments));
+        }
+
+        assert(Array.isArray(callMethodResponse.inputArgumentResults));
+        assert(callMethodResponse.inputArgumentResults?.length === methodInputArguments.length);
+
+        const outputArguments = callMethodResponse.outputArguments || [];
+        await resolveOpaqueOnAddressSpace(addressSpace, outputArguments as Variant[]);
+
+        return callMethodResponse;
+    } catch (_err) {
+        return { statusCode: StatusCodes.BadInternalError };
+    }
+}

package/api/helpers/coerce_enum_value.ts

@@ -0,0 +1,33 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { assert } from "node-opcua-assert";
+import { coerceInt64, type Int64 } from "node-opcua-basic-types";
+import { coerceLocalizedText } from "node-opcua-data-model";
+import { EnumValueType } from "node-opcua-types";
+import type { EnumValueTypeOptionsLike } from "../address_space_ts.js";
+
+export function coerceEnumValues(enumValues: EnumValueTypeOptionsLike[] | { [key: string]: number | Int64 }): EnumValueType[] {
+    if (Array.isArray(enumValues)) {
+        //
+        return enumValues.map((en) => {
+            assert(Object.hasOwn(en, "value"));
+            assert(Object.hasOwn(en, "displayName"));
+            return new EnumValueType({
+                displayName: coerceLocalizedText(en.displayName),
+                value: coerceInt64(en.value || 0)
+            });
+        });
+    } else {
+        return coerceEnumValues(
+            Object.entries(enumValues as { [key: string]: Int64 }).map((entry: [string, Int64]) => {
+                const [key, value] = entry;
+                return new EnumValueType({
+                    description: coerceLocalizedText(key),
+                    displayName: coerceLocalizedText(key),
+                    value: coerceInt64(value)
+                });
+            })
+        );
+    }
+}

package/api/helpers/dump_tools.ts

@@ -0,0 +1,90 @@
+/**
+ * @module node-opcua-address-space
+ */
+import chalk from "chalk";
+import type { BaseNode, IAddressSpace, UAReference, UAReferenceType as UAReferenceTypePublic } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { BrowseDirection } from "node-opcua-data-model";
+import type { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { BrowseDescription, type BrowseDescriptionOptions, type ReferenceDescription } from "node-opcua-types";
+
+import { resolveReferenceType } from "../../impl/reference_impl.js";
+
+export function referenceTypeToString(addressSpace: IAddressSpace, referenceTypeId: NodeIdLike | null): string {
+    // c8 ignore next
+    if (!referenceTypeId) {
+        return "<null> ";
+    } else {
+        const referenceType = addressSpace.findNode(referenceTypeId) as UAReferenceTypePublic | null;
+        if (!referenceType) {
+            return `${referenceTypeId.toString()} <unknown reference type>`;
+        }
+        return `${referenceTypeId.toString()} ${referenceType.browseName.toString()}/${referenceType.inverseName?.text}`;
+    }
+}
+
+function nodeIdInfo(addressSpace: IAddressSpace, nodeId: NodeId): string {
+    const obj = addressSpace.findNode(nodeId);
+    const name = obj ? obj.browseName.toString() : " <????>";
+    return `${nodeId.toString()} [ ${name} ]`;
+}
+
+export function dumpReferenceDescription(addressSpace: IAddressSpace, referenceDescription: ReferenceDescription): void {
+    assert(referenceDescription.referenceTypeId); // must be known;
+
+    console.log(chalk.red("referenceDescription"));
+    console.log("    referenceTypeId : ", referenceTypeToString(addressSpace, referenceDescription.referenceTypeId));
+    console.log("    isForward       : ", referenceDescription.isForward ? "true" : "false");
+    console.log("    nodeId          : ", nodeIdInfo(addressSpace, referenceDescription.nodeId));
+    console.log("    browseName      : ", referenceDescription.browseName.toString());
+    console.log("    nodeClass       : ", referenceDescription.nodeClass.toString());
+    console.log("    typeDefinition  : ", nodeIdInfo(addressSpace, referenceDescription.typeDefinition));
+}
+
+export function dumpReferenceDescriptions(addressSpace: IAddressSpace, referenceDescriptions: ReferenceDescription[]): void {
+    referenceDescriptions.forEach((r: ReferenceDescription) => {
+        dumpReferenceDescription(addressSpace, r);
+    });
+}
+
+export function dumpBrowseDescription(node: BaseNode, _browseDescription: BrowseDescriptionOptions): void {
+    const browseDescription = new BrowseDescription(_browseDescription);
+
+    const addressSpace = node.addressSpace;
+
+    console.log(" Browse Node :");
+
+    if (browseDescription.nodeId) {
+        console.log(" nodeId : ", chalk.cyan(browseDescription.nodeId.toString()));
+    }
+
+    console.log(" nodeId : ", chalk.cyan(node.browseName.toString()), "(", node.nodeId.toString(), ")");
+    console.log("   referenceTypeId :", referenceTypeToString(addressSpace, browseDescription.referenceTypeId));
+
+    console.log("   browseDirection :", chalk.cyan(BrowseDirection[browseDescription.browseDirection]));
+    console.log("   includeSubType  :", browseDescription.includeSubtypes ? "true" : "false");
+    console.log("   nodeClassMask   :", browseDescription.nodeClassMask);
+    console.log("   resultMask      :", browseDescription.resultMask);
+}
+
+/**
+ */
+export function dumpReferences(addressSpace: IAddressSpace, references: UAReference[] | MapIterator<UAReference>): void {
+    assert(addressSpace);
+    for (const reference of references) {
+        const referenceType = resolveReferenceType(addressSpace, reference);
+        if (!referenceType) {
+            // unknown type ... this may happen when the address space is not fully build
+            return;
+        }
+        const dir = reference.isForward ? "(=>)" : "(<-)";
+        const objectName = nodeIdInfo(addressSpace, reference.nodeId);
+        console.log(
+            " referenceType : ",
+            dir,
+            referenceType ? referenceType.browseName.toString() : reference.referenceType.toString(),
+            " ",
+            objectName
+        );
+    }
+}

package/api/helpers/ensure_secure_access.ts

@@ -0,0 +1,78 @@
+import type { BaseNode, IChannelBase, UAMethod, UAObject, UAVariable } from "node-opcua-address-space-base";
+import { allPermissions, BrowseDirection, makeAccessRestrictionsFlag, makePermissionFlag, NodeClass } from "node-opcua-data-model";
+import { MessageSecurityMode } from "node-opcua-types";
+import { WellKnownRoles } from "../session_context.js";
+
+function _isChannelSecure(channel: IChannelBase): boolean {
+    if (channel.securityMode === MessageSecurityMode.SignAndEncrypt) {
+        return true;
+    }
+    return false;
+}
+
+/**
+ * make sure that the given ia node can only be read
+ * by Administrator user on a encrypted channel
+ * @param node
+
+*/
+const adminPermissions = [
+    { roleId: WellKnownRoles.SecurityAdmin, permissions: allPermissions },
+    { roleId: WellKnownRoles.ConfigureAdmin, permissions: allPermissions },
+    { roleId: WellKnownRoles.Supervisor, permissions: allPermissions },
+    { roleId: WellKnownRoles.Operator, permissions: makePermissionFlag("Browse") },
+    { roleId: WellKnownRoles.Engineer, permissions: makePermissionFlag("Browse") },
+    { roleId: WellKnownRoles.Observer, permissions: makePermissionFlag("Browse") }
+];
+// the structure stays visible to every session: the mandatory children of the
+// well-known roles (Identities ...) must be browsable by the anonymous session the
+// CTT uses (Base Info Core Structure 001). Values remain readable only by the roles
+// above, on a signed and encrypted channel.
+const restrictedPermissions = [
+    ...adminPermissions,
+    { roleId: WellKnownRoles.Anonymous, permissions: makePermissionFlag("Browse") },
+    { roleId: WellKnownRoles.AuthenticatedUser, permissions: makePermissionFlag("Browse") }
+];
+// hideStructure: unauthorised sessions do not even see the nodes
+const hiddenPermissions = adminPermissions;
+
+const restrictedAccessFlag = makeAccessRestrictionsFlag("SigningRequired | EncryptionRequired");
+
+export interface EnsureObjectIsSecureOptions {
+    /**
+     * When true, a session without one of the authorised roles cannot browse the nodes
+     * either: the structure itself is hidden. The default (false) leaves the structure
+     * browsable by everyone, which is what the OPC UA conformance tests expect of the
+     * mandatory children of the well-known roles; only the values are protected.
+     */
+    hideStructure?: boolean;
+}
+
+/**
+ * this method install the access right restriction on the given node and its children
+ * values will only be available to user with role Administrator or supervisor and
+ * with a signed and encrypted channel.
+ *
+ * @param node the node which permissions are to be adjusted
+ * @param options `hideStructure` to also hide the nodes from unauthorised sessions
+ */
+export function ensureObjectIsSecure(node: BaseNode, options: EnsureObjectIsSecureOptions = {}): void {
+    const permissions = options.hideStructure ? hiddenPermissions : restrictedPermissions;
+    node.setAccessRestrictions(restrictedAccessFlag);
+    if (node.nodeClass === NodeClass.Variable) {
+        const variable = node as UAVariable;
+        variable.setRolePermissions(permissions);
+    }
+    if (node.nodeClass === NodeClass.Method) {
+        const method = node as UAMethod;
+        method.setRolePermissions(permissions);
+    }
+    if (node.nodeClass === NodeClass.Object) {
+        const object = node as UAObject;
+        object.setRolePermissions(permissions);
+    }
+    const children = node.findReferencesExAsObject("Aggregates", BrowseDirection.Forward);
+    for (const child of children) {
+        ensureObjectIsSecure(child, options);
+    }
+}

package/api/helpers/multiform_func.ts

@@ -0,0 +1,78 @@
+import { make_warningLog } from "node-opcua-debug";
+import type { CallbackT } from "node-opcua-status-code";
+
+const warningLog = make_warningLog("multiform_func");
+
+export type StraightFunc<T, This> = (this: This) => T;
+export type PromiseFunc<T, This> = (this: This) => Promise<T>;
+export type CallbackFunc<T, This> = (this: This, callback: CallbackT<T>) => void;
+export type MultiformFunc<T, This> = StraightFunc<T, This> | PromiseFunc<T, This> | CallbackFunc<T, This>;
+
+export function convertToCallbackFunction<T, This>(func: MultiformFunc<T, This>): CallbackFunc<T, This> {
+    if (func.length === 0) {
+        return function (this: This, callback: CallbackT<T>) {
+            /** */
+            let valueOrPromise: T | Promise<T>;
+            try {
+                valueOrPromise = (func as (this: This) => Promise<T> | T).call(this);
+            } catch (err) {
+                return callback(err as Error);
+            }
+            if (valueOrPromise instanceof Promise) {
+                valueOrPromise.then((value: T) => callback(null, value)).catch((err) => callback(err));
+            } else {
+                return callback(null, valueOrPromise);
+            }
+        };
+    } else {
+        if (func.length !== 1) {
+            throw new Error("convertToCallbackFunction: invalid function");
+        }
+
+        return function (this: This, callback: CallbackT<T>) {
+            try {
+                (func as CallbackFunc<T, This>).call(this, callback);
+            } catch (err) {
+                warningLog("internal error", (err as Error).message);
+                callback(err as Error);
+            }
+        };
+    }
+}
+
+export type StraightFunc1<T, P, This> = (this: This, param1: P) => T;
+export type PromiseFunc1<T, P, This> = (this: This, param1: P) => Promise<T>;
+export type CallbackFunc1<T, P, This> = (this: This, param1: P, callback: CallbackT<T>) => void;
+export type MultiformFunc1<T, P, This> = StraightFunc1<T, P, This> | PromiseFunc1<T, P, This> | CallbackFunc1<T, P, This>;
+
+export function convertToCallbackFunction1<T, P, This>(func: MultiformFunc1<T, P, This>): CallbackFunc1<T, P, This> {
+    if (func.length === 1) {
+        return function (this: This, param: P, callback: CallbackT<T>) {
+            /** */
+            let valueOrPromise: T | Promise<T>;
+            try {
+                valueOrPromise = (func as (this: This, param: P) => Promise<T> | T).call(this, param);
+            } catch (err) {
+                return callback(err as Error);
+            }
+            if (valueOrPromise instanceof Promise) {
+                valueOrPromise.then((value: T) => callback(null, value)).catch((err) => callback(err));
+            } else {
+                return callback(null, valueOrPromise);
+            }
+        };
+    } else {
+        if (func.length !== 2) {
+            throw new Error("convertToCallbackFunction: invalid function");
+        }
+
+        return function (this: This, param: P, callback: CallbackT<T>) {
+            try {
+                (func as CallbackFunc1<T, P, This>).call(this, param, callback);
+            } catch (err) {
+                warningLog("internal error", (err as Error).message);
+                callback(err as Error);
+            }
+        };
+    }
+}