node-opcua-server 2.105.1 → 2.107.0

package/source/server_engine.ts

@@ -10,14 +10,11 @@ import { BinaryStream } from "node-opcua-binary-stream";
 import {
     addElement,
     AddressSpace,
-    BaseNode,
     bindExtObjArrayNode,
-    ensureDatatypeExtractedWithCallback,
     ensureObjectIsSecure,
     MethodFunctor,
     removeElement,
     SessionContext,
-    UADataType,
     UADynamicVariableArray,
     UAMethod,
     UAObject,
@@ -28,13 +25,9 @@ import {
     BindVariableOptions,
     ISessionContext,
     DTServerStatus,
-    resolveOpaqueOnAddressSpace,
-    ContinuationData,
-    IServerBase,
-    UARole
-} from "node-opcua-address-space";
+    IServerBase} from "node-opcua-address-space";
 import { generateAddressSpace } from "node-opcua-address-space/nodeJS";
-import { DataValue, coerceTimestampsToReturn, apply_timestamps_no_copy } from "node-opcua-data-value";
+import { DataValue } from "node-opcua-data-value";
 import {
     ServerDiagnosticsSummaryDataType,
     ServerState,
@@ -43,40 +36,30 @@ import {
 } from "node-opcua-common";
 import {
     AttributeIds,
-    BrowseDirection,
     coerceLocalizedText,
     LocalizedTextLike,
     makeAccessLevelFlag,
-    NodeClass,
-    QualifiedName
-} from "node-opcua-data-model";
+    NodeClass} from "node-opcua-data-model";
 import { coerceNodeId, makeNodeId, NodeId, NodeIdLike, NodeIdType, resolveNodeId } from "node-opcua-nodeid";
 import { BrowseResult } from "node-opcua-service-browse";
-import { ReadRequest, TimestampsToReturn } from "node-opcua-service-read";
 import { UInt32 } from "node-opcua-basic-types";
 import { CreateSubscriptionRequestLike } from "node-opcua-client";
-import { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
 import { DataTypeIds, MethodIds, ObjectIds, VariableIds } from "node-opcua-constants";
 import { getCurrentClock, minOPCUADate } from "node-opcua-date-time";
 import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog, traceFromThisProjectOnly } from "node-opcua-debug";
 import { nodesets } from "node-opcua-nodesets";
-import { NumericRange } from "node-opcua-numeric-range";
 import { ObjectRegistry } from "node-opcua-object-registry";
 import { CallMethodResult } from "node-opcua-service-call";
 import { TransferResult } from "node-opcua-service-subscription";
 import { ApplicationDescription } from "node-opcua-service-endpoints";
-import { HistoryReadDetails, HistoryReadRequest, HistoryReadResult, HistoryReadValueId } from "node-opcua-service-history";
-import { StatusCode, StatusCodes, CallbackT, StatusCodeCallback } from "node-opcua-status-code";
+import { HistoryReadRequest, HistoryReadResult, HistoryReadValueId } from "node-opcua-service-history";
+import { StatusCode, StatusCodes, CallbackT } from "node-opcua-status-code";
 import {
     BrowseDescription,
     BrowsePath,
     BrowsePathResult,
     BuildInfo,
     BuildInfoOptions,
-    ReadAtTimeDetails,
-    ReadEventDetails,
-    ReadProcessedDetails,
-    ReadRawModifiedDetails,
     SessionDiagnosticsDataType,
     SessionSecurityDiagnosticsDataType,
     WriteValue,
@@ -84,7 +67,9 @@ import {
     TimeZoneDataType,
     ProgramDiagnosticDataType,
     CallMethodResultOptions,
-    AggregateConfiguration
+    ReadRequestOptions,
+    BrowseDescriptionOptions,
+    CallMethodRequest
 } from "node-opcua-types";
 import { DataType, isValidVariant, Variant, VariantArrayType } from "node-opcua-variant";
 
@@ -97,6 +82,8 @@ import { ServerSession } from "./server_session";
 import { Subscription } from "./server_subscription";
 import { sessionsCompatibleForTransfer } from "./sessions_compatible_for_transfer";
 import { OPCUAServerOptions } from "./opcua_server";
+import { IAddressSpaceAccessor } from "./i_address_space_accessor";
+import { AddressSpaceAccessor } from "./addressSpace_accessor";
 
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
@@ -303,44 +290,6 @@ function _get_next_subscriptionId() {
     return next_subscriptionId++;
 }
 
-function checkReadProcessedDetails(historyReadDetails: ReadProcessedDetails): StatusCode {
-    if (!historyReadDetails.aggregateConfiguration) {
-        historyReadDetails.aggregateConfiguration = new AggregateConfiguration({
-            useServerCapabilitiesDefaults: true
-        });
-    }
-    if (historyReadDetails.aggregateConfiguration.useServerCapabilitiesDefaults) {
-        return StatusCodes.Good;
-    }
-
-    // The PercentDataGood and PercentDataBad shall follow the following relationship
-    //          PercentDataGood ≥ (100 – PercentDataBad).
-    // If they are equal the result of the PercentDataGood calculation is used.
-    // If the values entered for PercentDataGood and PercentDataBad do not result in a valid calculation
-    //  (e.g. Bad = 80; Good = 0) the result will have a StatusCode of Bad_AggregateInvalidInputs.
-    if (
-        historyReadDetails.aggregateConfiguration.percentDataGood <
-        100 - historyReadDetails.aggregateConfiguration.percentDataBad
-    ) {
-        return StatusCodes.BadAggregateInvalidInputs;
-    }
-    // The StatusCode Bad_AggregateInvalidInputs will be returned if the value of PercentDataGood
-    // or PercentDataBad exceed 100.
-    if (
-        historyReadDetails.aggregateConfiguration.percentDataGood > 100 ||
-        historyReadDetails.aggregateConfiguration.percentDataGood < 0
-    ) {
-        return StatusCodes.BadAggregateInvalidInputs;
-    }
-    if (
-        historyReadDetails.aggregateConfiguration.percentDataBad > 100 ||
-        historyReadDetails.aggregateConfiguration.percentDataBad < 0
-    ) {
-        return StatusCodes.BadAggregateInvalidInputs;
-    }
-    return StatusCodes.Good;
-}
-
 export type StringGetter = () => string;
 
 export interface ServerEngineOptions {
@@ -365,10 +314,15 @@ export interface CreateSessionOption {
 export type ClosingReason = "Timeout" | "Terminated" | "CloseSession" | "Forcing";
 
 export type ServerEngineShutdownTask = (this: ServerEngine) => void | Promise<void>;
+
+
+
+
+
 /**
  *
  */
-export class ServerEngine extends EventEmitter {
+export class ServerEngine extends EventEmitter implements IAddressSpaceAccessor {
     public static readonly registry = new ObjectRegistry();
 
     public isAuditing: boolean;
@@ -379,6 +333,7 @@ export class ServerEngine extends EventEmitter {
     public clientDescription?: ApplicationDescription;
 
     public addressSpace: AddressSpace | null;
+    public addressSpaceAccessor: IAddressSpaceAccessor | null = null;
 
     // pseudo private
     public _internalState: "creating" | "initializing" | "initialized" | "shutdown" | "disposed";
@@ -775,6 +730,8 @@ export class ServerEngine extends EventEmitter {
 
         this.addressSpace = AddressSpace.create();
 
+        this.addressSpaceAccessor = new AddressSpaceAccessor(this.addressSpace);
+
         // register namespace 1 (our namespace);
         const serverNamespace = this.addressSpace.registerNamespace(this.serverNamespaceUrn);
         assert(serverNamespace.index === 1);
@@ -1325,24 +1282,9 @@ export class ServerEngine extends EventEmitter {
         });
     }
 
-    /**
-     *
-     * @method browseSingleNode
-     * @param nodeId {NodeId|String} : the nodeid of the element to browse
-     * @param browseDescription
-     * @param browseDescription.browseDirection {BrowseDirection} :
-     * @param browseDescription.referenceTypeId {String|NodeId}
-     * @param [context]
-     * @return  the browse result
-     */
-    public browseSingleNode(nodeId: NodeIdLike, browseDescription: BrowseDescription, context?: ISessionContext): BrowseResult {
-        const addressSpace = this.addressSpace!;
-        return addressSpace.browseSingleNode(nodeId, browseDescription, context);
-    }
-
     public async browseWithAutomaticExpansion(
         nodesToBrowse: BrowseDescription[],
-        context?: ISessionContext
+        context: ISessionContext
     ): Promise<BrowseResult[]> {
         // do expansion first
         for (const browseDescription of nodesToBrowse) {
@@ -1363,325 +1305,22 @@ export class ServerEngine extends EventEmitter {
                 }
             }
         }
-        return this.browse(nodesToBrowse, context);
+        return await this.browse(context, nodesToBrowse);
     }
-    /**
-     *
-     */
-    public browse(nodesToBrowse: BrowseDescription[], context?: ISessionContext): BrowseResult[] {
-        const results: BrowseResult[] = [];
-        for (const browseDescription of nodesToBrowse) {
-            const nodeId = resolveNodeId(browseDescription.nodeId);
-            const r = this.browseSingleNode(nodeId, browseDescription, context);
-            results.push(r);
-        }
-        return results;
+    public async browse(context: ISessionContext, nodesToBrowse: BrowseDescriptionOptions[]): Promise<BrowseResult[]> {
+        return this.addressSpaceAccessor!.browse(context, nodesToBrowse);
     }
-
-    /**
-     *
-     * @method readSingleNode
-     * @param context
-     * @param nodeId
-     * @param attributeId
-     * @param [timestampsToReturn=TimestampsToReturn.Neither]
-     * @return DataValue
-     */
-    public readSingleNode(
-        context: ISessionContext,
-        nodeId: NodeId | string,
-        attributeId: AttributeIds,
-        timestampsToReturn?: TimestampsToReturn
-    ): DataValue {
-        context.currentTime = getCurrentClock();
-        return this._readSingleNode(
-            context,
-            new ReadValueId({
-                attributeId,
-                nodeId: resolveNodeId(nodeId)
-            }),
-            timestampsToReturn
-        );
+    public async read(context: ISessionContext, readRequest: ReadRequestOptions): Promise<DataValue[]> {
+        return this.addressSpaceAccessor!.read(context, readRequest);
     }
-
-    /**
-     *
-     *
-     *    Maximum age of the value to be read in milliseconds. The age of the value is based on the difference between
-     *    the ServerTimestamp and the time when the  Server starts processing the request. For example if the Client
-     *    specifies a maxAge of 500 milliseconds and it takes 100 milliseconds until the Server starts  processing
-     *    the request, the age of the returned value could be 600 milliseconds  prior to the time it was requested.
-     *    If the Server has one or more values of an Attribute that are within the maximum age, it can return any one
-     *    of the values or it can read a new value from the data  source. The number of values of an Attribute that
-     *    a Server has depends on the  number of MonitoredItems that are defined for the Attribute. In any case,
-     *    the Client can make no assumption about which copy of the data will be returned.
-     *    If the Server does not have a value that is within the maximum age, it shall attempt to read a new value
-     *    from the data source.
-     *    If the Server cannot meet the requested maxAge, it returns its 'best effort' value rather than rejecting the
-     *    request.
-     *    This may occur when the time it takes the Server to process and return the new data value after it has been
-     *    accessed is greater than the specified maximum age.
-     *    If maxAge is set to 0, the Server shall attempt to read a new value from the data source.
-     *    If maxAge is set to the max Int32 value or greater, the Server shall attempt to get a cached value.
-     *    Negative values are invalid for maxAge.
-     *
-     *  @return  an array of DataValue
-     */
-    public read(context: ISessionContext, readRequest: ReadRequest): DataValue[] {
-        assert(context instanceof SessionContext);
-        assert(readRequest instanceof ReadRequest);
-        assert(readRequest.maxAge >= 0);
-
-        const timestampsToReturn = readRequest.timestampsToReturn;
-
-        const nodesToRead = readRequest.nodesToRead || [];
-        assert(Array.isArray(nodesToRead));
-
-        context.currentTime = getCurrentClock();
-
-        const dataValues: DataValue[] = [];
-        for (const readValueId of nodesToRead) {
-            const dataValue = this._readSingleNode(context, readValueId, timestampsToReturn);
-            if (timestampsToReturn === TimestampsToReturn.Server) {
-                dataValue.sourceTimestamp = null;
-                dataValue.sourcePicoseconds = 0;
-            }
-            if (
-                (timestampsToReturn === TimestampsToReturn.Both || timestampsToReturn === TimestampsToReturn.Server) &&
-                (!dataValue.serverTimestamp || dataValue.serverTimestamp.getTime() === minOPCUADate.getTime())
-            ) {
-                dataValue.serverTimestamp = context.currentTime.timestamp;
-                dataValue.serverPicoseconds = 0; // context.currentTime.picoseconds;
-            }
-            dataValues.push(dataValue);
-        }
-        return dataValues;
-    }
-
-    /**
-     *
-     * @method writeSingleNode
-     * @param context
-     * @param writeValue
-     * @param callback
-     * @param callback.err
-     * @param callback.statusCode
-     * @async
-     */
-    public writeSingleNode(
-        context: ISessionContext,
-        writeValue: WriteValue,
-        callback: (err: Error | null, statusCode?: StatusCode) => void
-    ): void {
-        assert(context instanceof SessionContext);
-        assert(typeof callback === "function");
-        assert(writeValue.schema.name === "WriteValue");
-        assert(writeValue.value instanceof DataValue);
-
-        if (writeValue.value.value === null) {
-            return callback(null, StatusCodes.BadTypeMismatch);
-        }
-
-        assert(writeValue.value.value instanceof Variant);
-
-        const nodeId = writeValue.nodeId;
-
-        const obj = this.__findNode(nodeId) as UAVariable;
-        if (!obj) {
-            return callback(null, StatusCodes.BadNodeIdUnknown);
-        } else {
-            obj.writeAttribute(context, writeValue, callback);
-        }
-    }
-
-    /**
-     * write a collection of nodes
-     * @method write
-     * @param context
-     * @param nodesToWrite
-     * @param callback
-     * @param callback.err
-     * @param callback.results
-     * @async
-     */
-    public write(
-        context: ISessionContext,
-        nodesToWrite: WriteValue[],
-        callback: (err: Error | null, statusCodes?: StatusCode[]) => void
-    ): void {
-        assert(context instanceof SessionContext);
-        assert(typeof callback === "function");
-
-        context.currentTime = getCurrentClock();
-
-        ensureDatatypeExtractedWithCallback(
-            this.addressSpace!,
-            (err2: Error | null, extraDataTypeManager?: ExtraDataTypeManager) => {
-                if (err2) {
-                    return callback(err2);
-                }
-                const performWrite = (writeValue: WriteValue, inner_callback: StatusCodeCallback) => {
-                    resolveOpaqueOnAddressSpace(this.addressSpace!, writeValue.value.value!)
-                        .then(() => {
-                            this.writeSingleNode(context, writeValue, inner_callback);
-                        })
-                        .catch(inner_callback);
-                };
-                // tslint:disable:array-type
-                async.map(nodesToWrite, performWrite, (err?: Error | null, statusCodes?: (StatusCode | undefined)[]) => {
-                    assert(Array.isArray(statusCodes));
-                    callback(err!, statusCodes as StatusCode[]);
-                });
-            }
-        );
+    public async write(context: ISessionContext, nodesToWrite: WriteValue[]): Promise<StatusCode[]> {
+        return await this.addressSpaceAccessor!.write(context, nodesToWrite);
     }
-
-    /**
-     *
-     */
-    public historyReadSingleNode(
-        context: ISessionContext,
-        nodeId: NodeId,
-        attributeId: AttributeIds,
-        historyReadDetails: ReadRawModifiedDetails | ReadEventDetails | ReadProcessedDetails | ReadAtTimeDetails,
-        timestampsToReturn: TimestampsToReturn,
-        continuationData: ContinuationData,
-        callback: (err: Error | null, results?: HistoryReadResult) => void
-    ): void {
-        if (timestampsToReturn === TimestampsToReturn.Invalid) {
-            callback(
-                null,
-                new HistoryReadResult({
-                    statusCode: StatusCodes.BadTimestampsToReturnInvalid
-                })
-            );
-            return;
-        }
-        assert(context instanceof SessionContext);
-        this._historyReadSingleNode(
-            context,
-            new HistoryReadValueId({
-                nodeId
-            }),
-            historyReadDetails,
-            timestampsToReturn,
-            continuationData,
-            callback
-        );
+    public async call(context: ISessionContext, methodsToCall: CallMethodRequest[]): Promise<CallMethodResultOptions[]> {
+        return await this.addressSpaceAccessor!.call(context, methodsToCall);
     }
-
-    /**
-     *
-     *  @method historyRead
-     *  @param context {SessionContext}
-     *  @param historyReadRequest {HistoryReadRequest}
-     *  @param historyReadRequest.requestHeader  {RequestHeader}
-     *  @param historyReadRequest.historyReadDetails  {HistoryReadDetails}
-     *  @param historyReadRequest.timestampsToReturn  {TimestampsToReturn}
-     *  @param historyReadRequest.releaseContinuationPoints  {Boolean}
-     *  @param historyReadRequest.nodesToRead {HistoryReadValueId[]}
-     *  @param callback
-     *  @param callback.err
-     *  @param callback.results {HistoryReadResult[]}
-     */
-    public historyRead(
-        context: ISessionContext,
-        historyReadRequest: HistoryReadRequest,
-        callback: (err: Error | null, results: HistoryReadResult[]) => void
-    ): void {
-        assert(context instanceof SessionContext);
-        assert(historyReadRequest instanceof HistoryReadRequest);
-        assert(typeof callback === "function");
-
-        const timestampsToReturn = historyReadRequest.timestampsToReturn;
-        const historyReadDetails = historyReadRequest.historyReadDetails! as HistoryReadDetails;
-        const releaseContinuationPoints = historyReadRequest.releaseContinuationPoints;
-        assert(historyReadDetails instanceof HistoryReadDetails);
-        //  ReadAnnotationDataDetails | ReadAtTimeDetails | ReadEventDetails | ReadProcessedDetails | ReadRawModifiedDetails;
-
-        const nodesToRead = historyReadRequest.nodesToRead || ([] as HistoryReadValueId[]);
-        assert(Array.isArray(nodesToRead));
-
-        // special cases with ReadProcessedDetails
-        interface M {
-            nodeToRead: HistoryReadValueId;
-            processDetail: ReadProcessedDetails;
-            index: number;
-        }
-
-        const _q = async (m: M): Promise<HistoryReadResult> => {
-            return new Promise((resolve) => {
-                const continuationPoint = m.nodeToRead.continuationPoint;
-                this._historyReadSingleNode(
-                    context,
-                    m.nodeToRead,
-                    m.processDetail,
-                    timestampsToReturn,
-                    { continuationPoint, releaseContinuationPoints /**, index = ??? */ },
-                    (err: Error | null, result?: any) => {
-                        if (err && !result) {
-                            errorLog("Internal error", err.message);
-                            result = new HistoryReadResult({ statusCode: StatusCodes.BadInternalError });
-                        }
-                        resolve(result);
-                    }
-                );
-            });
-        };
-
-        if (historyReadDetails instanceof ReadProcessedDetails) {
-            //
-            if (!historyReadDetails.aggregateType || historyReadDetails.aggregateType.length !== nodesToRead.length) {
-                return callback(null, [new HistoryReadResult({ statusCode: StatusCodes.BadInvalidArgument })]);
-            }
-
-            // chkec parameters
-            const parameterStatus = checkReadProcessedDetails(historyReadDetails);
-            if (parameterStatus !== StatusCodes.Good) {
-                return callback(null, [new HistoryReadResult({ statusCode: parameterStatus })]);
-            }
-            const promises: Promise<HistoryReadResult>[] = [];
-            let index = 0;
-            for (const nodeToRead of nodesToRead) {
-                const aggregateType = historyReadDetails.aggregateType[index];
-                const processDetail = new ReadProcessedDetails({ ...historyReadDetails, aggregateType: [aggregateType] });
-                promises.push(_q({ nodeToRead, processDetail, index }));
-                index++;
-            }
-            Promise.all(promises).then((results: HistoryReadResult[]) => {
-                callback(null, results);
-            });
-            return;
-        }
-
-        const _r = async (nodeToRead: HistoryReadValueId, index: number) => {
-            const continuationPoint = nodeToRead.continuationPoint;
-            return new Promise<HistoryReadResult>((resolve, reject) => {
-                this._historyReadSingleNode(
-                    context,
-                    nodeToRead,
-                    historyReadDetails,
-                    timestampsToReturn,
-                    { continuationPoint, releaseContinuationPoints, index },
-                    (err: Error | null, result?: any) => {
-                        if (err && !result) {
-                            result = new HistoryReadResult({ statusCode: StatusCodes.BadInternalError });
-                        }
-                        resolve(result);
-                        // it's not guaranteed that the historical read process is really asynchronous
-                    }
-                );
-            });
-        };
-        const promises: Promise<HistoryReadResult>[] = [];
-        let index = 0;
-        for (const nodeToRead of nodesToRead) {
-            promises.push(_r(nodeToRead, index));
-            index++;
-        }
-        Promise.all(promises).then((results: HistoryReadResult[]) => {
-            callback(null, results);
-        });
+    public async historyRead(context: ISessionContext, historyReadRequest: HistoryReadRequest): Promise<HistoryReadResult[]> {
+        return this.addressSpaceAccessor!.historyRead(context, historyReadRequest);
     }
 
     public getOldestInactiveSession(): ServerSession | null {
@@ -1980,9 +1619,15 @@ export class ServerEngine extends EventEmitter {
         return session;
     }
 
-    /**
-     */
-    public browsePath(browsePath: BrowsePath): BrowsePathResult {
+    public async translateBrowsePaths(browsePaths: BrowsePath[]): Promise<BrowsePathResult[]> {
+        const browsePathResults: BrowsePathResult[] = [];
+        for (const browsePath of browsePaths) {
+            const result = await this.translateBrowsePath(browsePath);
+            browsePathResults.push(result);
+        }
+        return browsePathResults;
+    }
+    public async translateBrowsePath(browsePath: BrowsePath): Promise<BrowsePathResult> {
         return this.addressSpace!.browsePath(browsePath);
     }
 
@@ -2139,123 +1784,6 @@ export class ServerEngine extends EventEmitter {
         return subscription;
     }
 
-    private __findNode(nodeId: NodeId): BaseNode | null {
-        if (nodeId.namespace >= (this.addressSpace?.getNamespaceArray().length || 0)) {
-            return null;
-        }
-        const namespace = this.addressSpace!.getNamespace(nodeId.namespace)!;
-        return namespace.findNode2(nodeId)!;
-    }
-
-    private _readSingleNode(context: ISessionContext, nodeToRead: ReadValueId, timestampsToReturn?: TimestampsToReturn): DataValue {
-        assert(context instanceof SessionContext);
-        const nodeId: NodeId = nodeToRead.nodeId!;
-        const attributeId: AttributeIds = nodeToRead.attributeId!;
-        const indexRange: NumericRange = nodeToRead.indexRange!;
-        const dataEncoding: QualifiedName = nodeToRead.dataEncoding;
-
-        if (timestampsToReturn === TimestampsToReturn.Invalid) {
-            return new DataValue({ statusCode: StatusCodes.BadTimestampsToReturnInvalid });
-        }
-
-        timestampsToReturn = coerceTimestampsToReturn(timestampsToReturn);
-
-        const obj = this.__findNode(nodeId!);
-
-        let dataValue;
-        if (!obj) {
-            // may be return BadNodeIdUnknown in dataValue instead ?
-            // Object Not Found
-            return new DataValue({ statusCode: StatusCodes.BadNodeIdUnknown });
-        } else {
-            // check access
-            //    BadUserAccessDenied
-            //    BadNotReadable
-            //    invalid attributes : BadNodeAttributesInvalid
-            //    invalid range      : BadIndexRangeInvalid
-            dataValue = obj.readAttribute(context, attributeId, indexRange, dataEncoding);
-            dataValue = apply_timestamps_no_copy(dataValue, timestampsToReturn, attributeId);
-
-            return dataValue;
-        }
-    }
-
-    private _historyReadSingleNode(
-        context: ISessionContext,
-        nodeToRead: HistoryReadValueId,
-        historyReadDetails: HistoryReadDetails,
-        timestampsToReturn: TimestampsToReturn,
-        continuationData: ContinuationData,
-        callback: CallbackT<HistoryReadResult>
-    ): void {
-        assert(context instanceof SessionContext);
-        assert(typeof callback === "function");
-
-        const nodeId = nodeToRead.nodeId;
-        const indexRange = nodeToRead.indexRange;
-        const dataEncoding = nodeToRead.dataEncoding;
-        const continuationPoint = nodeToRead.continuationPoint;
-
-        timestampsToReturn = coerceTimestampsToReturn(timestampsToReturn);
-        if (timestampsToReturn === TimestampsToReturn.Invalid) {
-            return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadTimestampsToReturnInvalid }));
-        }
-
-        const obj = this.__findNode(nodeId) as UAVariable;
-
-        if (!obj) {
-            // may be return BadNodeIdUnknown in dataValue instead ?
-            // Object Not Found
-            callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadNodeIdUnknown }));
-            return;
-        } else {
-            // istanbul ignore next
-            if (!obj.historyRead) {
-                // note : Object and View may also support historyRead to provide Event historical data
-                //        todo implement historyRead for Object and View
-                const msg =
-                    " this node doesn't provide historyRead! probably not a UAVariable\n " +
-                    obj.nodeId.toString() +
-                    " " +
-                    obj.browseName.toString() +
-                    "\n" +
-                    "with " +
-                    nodeToRead.toString() +
-                    "\n" +
-                    "HistoryReadDetails " +
-                    historyReadDetails.toString();
-                if (doDebug) {
-                    debugLog(chalk.cyan("ServerEngine#_historyReadSingleNode "), chalk.white.bold(msg));
-                }
-                const err = new Error(msg);
-                // object has no historyRead method
-                setImmediate(callback.bind(null, err));
-                return;
-            }
-            // check access
-            //    BadUserAccessDenied
-            //    BadNotReadable
-            //    invalid attributes : BadNodeAttributesInvalid
-            //    invalid range      : BadIndexRangeInvalid
-            obj.historyRead(
-                context,
-                historyReadDetails,
-                indexRange,
-                dataEncoding,
-                continuationData,
-                (err: Error | null, result?: HistoryReadResult) => {
-                    if (err || !result) {
-                        return callback(err);
-                    }
-                    assert(result!.statusCode instanceof StatusCode);
-                    assert(result!.isValid());
-                    // result = apply_timestamps(result, timestampsToReturn, attributeId);
-                    callback(err, result);
-                }
-            );
-        }
-    }
-
     /**
      */
     private __internal_bindMethod(nodeId: NodeId, func: MethodFunctor) {

package/source/server_subscription.ts

@@ -1086,11 +1086,11 @@ export class Subscription extends EventEmitter {
         this._createMonitoredItemStep3(monitoredItem, monitoredItemCreateRequest);
     }
 
-    public createMonitoredItem(
+    public async createMonitoredItem(
         addressSpace: AddressSpace,
         timestampsToReturn: TimestampsToReturn,
         monitoredItemCreateRequest: MonitoredItemCreateRequest
-    ): MonitoredItemCreateResult {
+    ): Promise<MonitoredItemCreateResult> {
         const { monitoredItem, createResult } = this.preCreateMonitoredItem(
             addressSpace,
             timestampsToReturn,