node-opcua-aggregates 2.53.0 → 2.56.2

package/source/common.ts

@@ -1,11 +1,12 @@
 /**
  * @module node-opca-aggregates
  */
-import { SessionContext, UAVariable } from "node-opcua-address-space";
+import { SessionContext, UAVariable, ContinuationPointManager, ContinuationPoint } from "node-opcua-address-space";
 import { NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { HistoryData, HistoryReadResult, ReadRawModifiedDetails } from "node-opcua-service-history";
 import { StatusCode } from "node-opcua-status-code";
+import { coerceNodeId } from "node-opcua-nodeid";
 
 import { getAggregateConfiguration } from "./aggregates";
 import { getInterval, Interval, AggregateConfigurationOptionsEx } from "./interval";
@@ -56,7 +57,6 @@ function processAggregateData(
     setImmediate(() => {
         callback(null, results);
     });
-
 }
 
 export function getAggregateData(
@@ -66,8 +66,7 @@ export function getAggregateData(
     endDate: Date,
     lambda: (interval: Interval, aggregateConfiguration: AggregateConfigurationOptionsEx) => DataValue,
     callback: (err: Error | null, dataValues?: DataValue[]) => void
-) {
-
+): void {
     /* istanbul ignore next */
     if (node.nodeClass !== NodeClass.Variable) {
         throw new Error("node must be UAVariable");
@@ -78,17 +77,30 @@ export function getAggregateData(
         throw new Error("Invalid processing interval, shall be greater than 0");
     }
 
-    const context = new SessionContext();
+    const continuationPointManager = new ContinuationPointManager();
+    const context = new SessionContext({
+        session: {
+            continuationPointManager,
+            getSessionId: () => coerceNodeId("i=0")
+        }
+    });
     const historyReadDetails = new ReadRawModifiedDetails({
         endTime: endDate,
         startTime: startDate,
+        isReadModified: false,
+        numValuesPerNode: 0
+        // returnBounds: true,
     });
     const indexRange = null;
     const dataEncoding = null;
-    const continuationPoint = null;
-    node.historyRead(context, historyReadDetails, indexRange, dataEncoding, continuationPoint,
+    const continuationPoint: ContinuationPoint | null = null;
+    node.historyRead(
+        context,
+        historyReadDetails,
+        indexRange,
+        dataEncoding,
+        { continuationPoint },
         (err: Error | null, result?: HistoryReadResult) => {
-
             /* istanbul ignore next */
             if (err) {
                 return callback(err);
@@ -98,10 +110,11 @@ export function getAggregateData(
             const dataValues = historyData.dataValues || [];
 
             processAggregateData(node, processingInterval, startDate, endDate, dataValues, lambda, callback);
-        });
+        }
+    );
 }
 
-export function interpolateValue(dataValue1: DataValue, dataValue2: DataValue, date: Date) {
+export function interpolateValue(dataValue1: DataValue, dataValue2: DataValue, date: Date): DataValue {
     const t0 = dataValue1.sourceTimestamp!.getTime();
     const t = date.getTime();
     const t1 = dataValue2.sourceTimestamp!.getTime();

package/source/index.ts

@@ -1,17 +1,11 @@
-/**
- * @module node-opca-aggregates
- */
-export {
-    addAggregateSupport,
-    installAggregateConfigurationOptions,
-    getAggregateConfiguration,
-} from "./aggregates";
-export * from "./interpolate";
-export * from "./minmax";
-export * from "./interval";
-export * from "./common";
-export * from "./average";
-export * from "./read_processed_details";
-export {
-    AggregateFunction
-} from "node-opcua-constants";
+/**
+ * @module node-opca-aggregates
+ */
+export { addAggregateSupport, installAggregateConfigurationOptions, getAggregateConfiguration } from "./aggregates";
+export * from "./interpolate";
+export * from "./minmax";
+export * from "./interval";
+export * from "./common";
+export * from "./average";
+export * from "./read_processed_details";
+export { AggregateFunction } from "node-opcua-constants";

package/source/interpolate.ts

@@ -1,5 +1,5 @@
 /**
- * @module node-opca-aggregates
+ * @module node-opcua-aggregates
  */
 //  excerpt from OPC Unified Architecture, Part 13 21 Release 1.04
 //
@@ -47,7 +47,8 @@ import {
     _findGoodDataValueBefore,
     adjustProcessingOptions,
     AggregateConfigurationOptionsEx,
-    Interval, isBad,
+    Interval,
+    isBad,
     isGood
 } from "./interval";
 
@@ -62,11 +63,10 @@ import {
  If for an interval neither ratio applies then that interval is Uncertain_DataSubNormal.
   */
 export function interpolatedValue(interval: Interval, options: AggregateConfigurationOptionsEx): DataValue {
-
     options = adjustProcessingOptions(options);
 
-    assert(Object.prototype.hasOwnProperty.call(options,"useSlopedExtrapolation"));
-    assert(Object.prototype.hasOwnProperty.call(options,"treatUncertainAsBad"));
+    assert(Object.prototype.hasOwnProperty.call(options, "useSlopedExtrapolation"));
+    assert(Object.prototype.hasOwnProperty.call(options, "treatUncertainAsBad"));
 
     const bTreatUncertainAsBad = options.treatUncertainAsBad!;
 
@@ -77,10 +77,9 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
         const interpValue = new DataValue({
             sourceTimestamp: interval.startTime,
             statusCode: StatusCodes.Bad,
-            value: previousDataValue.value,
+            value: previousDataValue.value
         });
-        interpValue.statusCode =
-            StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, "HistorianInterpolated");
+        interpValue.statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, "HistorianInterpolated");
         return interpValue;
     };
 
@@ -93,7 +92,7 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
             return new DataValue({
                 sourceTimestamp: interval.startTime,
                 statusCode: StatusCodes.BadNoData,
-                value: undefined,
+                value: undefined
             });
         }
         if (!options.useSlopedExtrapolation) {
@@ -111,13 +110,12 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
         // tslint:disable:no-bitwise
         if (prev2.index + 1 < prev1.index || prev1.index < interval.dataValues.length - 1) {
             // some bad data exist in between = change status code
-            const mask = 0x0000FFFFFF;
+            const mask = 0x0000ffffff;
             const extraBits = interpVal.statusCode.value & mask;
             interpVal.statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, extraBits);
         }
 
         return interpVal;
-
     }
 
     /* istanbul ignore next */
@@ -166,16 +164,12 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
     //   x is a value at ‘x’ and Tx is the timestamp associated with Vx.
     const interpolatedDataValue = interpolateValue(before.dataValue, next.dataValue, interval.startTime);
 
-    if (before.index + 1 < next.index
-        || !isGood(next.dataValue.statusCode)
-        || !isGood(before.dataValue.statusCode)
-    ) {
+    if (before.index + 1 < next.index || !isGood(next.dataValue.statusCode) || !isGood(before.dataValue.statusCode)) {
         // tslint:disable:no-bitwise
         // some bad data exist in between = change status code
-        const mask = 0x0000FFFFFF;
+        const mask = 0x0000ffffff;
         const extraBits = interpolatedDataValue.statusCode.value & mask;
-        interpolatedDataValue.statusCode =
-            StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, extraBits);
+        interpolatedDataValue.statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, extraBits);
     }
     // check if uncertain or bad value exist between before/next
     // todo
@@ -196,6 +190,6 @@ export function getInterpolatedData(
     startDate: Date,
     endDate: Date,
     callback: (err: Error | null, dataValues?: DataValue[]) => void
-) {
-    return getAggregateData(node, processingInterval, startDate, endDate, interpolatedValue, callback);
+): void {
+    getAggregateData(node, processingInterval, startDate, endDate, interpolatedValue, callback);
 }

package/source/interval.ts

@@ -117,7 +117,7 @@ export class Interval {
     /**
      * returns true if a raw data exists at start
      */
-    public hasRawDataAsStart() {
+    public hasRawDataAsStart(): boolean {
         const index = this.index;
         if (index < 0) {
             return false;
@@ -131,11 +131,11 @@ export class Interval {
      * just preceding this interval
      * @returns {*}
      */
-    public beforeStartDataValue(bTreatUncertainAsBad: boolean) {
+    public beforeStartDataValue(bTreatUncertainAsBad: boolean): DataValueWithIndex {
         return _findGoodDataValueBefore(this.dataValues, this.index, bTreatUncertainAsBad);
     }
 
-    public nextStartDataValue(bTreatUncertainAsBad: boolean) {
+    public nextStartDataValue(bTreatUncertainAsBad: boolean): DataValueWithIndex {
         return _findGoodDataValueAfter(this.dataValues, this.index, bTreatUncertainAsBad);
     }
 

package/source/minmax.ts

@@ -1,7 +1,7 @@
 /**
  * @module node-opca-aggregates
  */
-//  excert from OPC Unified Architecture, Part 13 21 Release 1.04
+//  excerpt from OPC Unified Architecture, Part 13 21 Release 1.04
 // 5.4.3.10 Minimum
 // The Minimum Aggregate defined in Table 21 retrieves the minimum Good raw value within the
 // interval, and returns that value with the timestamp at the start of the interval. Note that if the
@@ -60,12 +60,12 @@ import { Variant } from "node-opcua-variant";
 import { getAggregateData } from "./common";
 import { AggregateConfigurationOptions, Interval, isGood } from "./interval";
 
+// eslint-disable-next-line max-statements
 function calculateIntervalMinOrMaxValue(
     interval: Interval,
     options: AggregateConfigurationOptions,
     predicate: (a: Variant, b: Variant) => "equal" | "select" | "reject"
 ): DataValue {
-
     //   console.log(interval.toString());
 
     const indexStart = interval.index;
@@ -143,15 +143,15 @@ function calculateIntervalMinOrMaxValue(
 }
 
 export function calculateIntervalMinValue(interval: Interval, options: AggregateConfigurationOptions): DataValue {
-    return calculateIntervalMinOrMaxValue(interval, options,
-        (a: Variant, b: Variant) =>
-            a.value > b.value ? "select" : (a.value === b.value ? "equal" : "reject"));
+    return calculateIntervalMinOrMaxValue(interval, options, (a: Variant, b: Variant) =>
+        a.value > b.value ? "select" : a.value === b.value ? "equal" : "reject"
+    );
 }
 
 export function calculateIntervalMaxValue(interval: Interval, options: AggregateConfigurationOptions): DataValue {
-    return calculateIntervalMinOrMaxValue(interval, options,
-        (a: Variant, b: Variant) =>
-            a.value < b.value ? "select" : (a.value === b.value ? "equal" : "reject"));
+    return calculateIntervalMinOrMaxValue(interval, options, (a: Variant, b: Variant) =>
+        a.value < b.value ? "select" : a.value === b.value ? "equal" : "reject"
+    );
 }
 
 // From OPC Unified Architecture, Part 13 26 Release 1.04
@@ -216,7 +216,7 @@ export function getMinData(
     startDate: Date,
     endDate: Date,
     callback: (err: Error | null, dataValues?: DataValue[]) => void
-) {
+): void {
     return getAggregateData(node, processingInterval, startDate, endDate, calculateIntervalMinValue, callback);
 }
 
@@ -226,6 +226,6 @@ export function getMaxData(
     startDate: Date,
     endDate: Date,
     callback: (err: Error | null, dataValues?: DataValue[]) => void
-) {
+): void {
     return getAggregateData(node, processingInterval, startDate, endDate, calculateIntervalMaxValue, callback);
 }

package/source/read_processed_details.ts

@@ -1,139 +1,149 @@
-import * as async from "async";
-import { AggregateFunction } from "node-opcua-constants";
-import { ISessionContext, ContinuationPoint, UAVariable } from "node-opcua-address-space";
-import { NumericRange } from "node-opcua-numeric-range";
-import { QualifiedNameLike } from "node-opcua-data-model";
-import { CallbackT, StatusCodes } from "node-opcua-status-code";
-import { DataValue } from "node-opcua-data-value";
-import { ObjectIds } from "node-opcua-constants";
-import { NodeId } from "node-opcua-nodeid";
-import { getMinData, getMaxData } from "./minmax";
-import {
-    HistoryData,
-    HistoryReadResult,
-    ReadAtTimeDetails,
-    ReadEventDetails,
-    ReadProcessedDetails,
-    ReadRawModifiedDetails
-} from "node-opcua-service-history";
-
-import { getInterpolatedData } from "./interpolate";
-import { getAverageData } from "./average";
-
-export function readProcessedDetails(
-    variable: UAVariable,
-    context: ISessionContext,
-    historyReadDetails: ReadProcessedDetails,
-    indexRange: NumericRange | null,
-    dataEncoding: QualifiedNameLike | null,
-    continuationPoint: ContinuationPoint | null,
-    callback: CallbackT<HistoryReadResult>
-) {
-    // OPC Unified Architecture, Part 11 27 Release 1.03
-    //
-    // This structure is used to compute Aggregate values, qualities, and timestamps from data in
-    // the history database for the specified time domain for one or more HistoricalDataNodes. The
-    // time domain is divided into intervals of duration ProcessingInterval. The specified Aggregate
-    // Type is calculated for each interval beginning with startTime by using the data within the next
-    // ProcessingInterval.
-    // For example, this function can provide hourly statistics such as Maximum, Minimum , and
-    // Average for each item during the specified time domain when ProcessingInterval is 1 hour.
-    // The domain of the request is defined by startTime, endTime, and ProcessingInterval. All three
-    // shall be specified. If endTime is less than startTime then the data shall be returned in reverse
-    // order with the later data coming first. If startTime and endTime are the same then the Server
-    // shall return Bad_InvalidArgument as there is no meaningful way to interpret such a case. If
-    // the ProcessingInterval is specified as 0 then Aggregates shall be calculated using one interval
-    // starting at startTime and ending at endTime.
-    // The aggregateType[] parameter allows a Client to request multiple Aggregate calculations per
-    // requested NodeId. If multiple Aggregates are requested then a corresponding number of
-    // entries are required in the NodesToRead array.
-    // For example, to request Min Aggregate for NodeId FIC101, FIC102, and both Min and Max
-    // Aggregates for NodeId FIC103 would require NodeId FIC103 to appear twice in the
-    // NodesToRead array request parameter.
-    // aggregateType[] NodesToRead[]
-    // Min FIC101
-    // Min FIC102
-    // Min FIC103
-    // Max FIC103
-    // If the array of Aggregates does not match the array of NodesToRead then the Server shall
-    // return a StatusCode of Bad_AggregateListMismatch.
-    // The aggregateConfiguration parameter allows a Client to override the Aggregate configuration
-    // settings supplied by the AggregateConfiguration Object on a per call basis. See Part 13 for
-    // more information on Aggregate configurations. If the Server does not support the ability to
-    // override the Aggregate configuration settings then it shall return a StatusCode of Bad_
-    // AggregateConfigurationRejected. If the Aggregate is not valid for the Node then the
-    // StatusCode shall be Bad_AggregateNotSupported.
-    // The values used in computing the Aggregate for each interval shall include any value that
-    // falls exactly on the timestamp at the beginning of the interval, but shall not include any value
-    // that falls directly on the timestamp ending the interval. Thus, each value shall be included
-    // only once in the calculation. If the time domain is in reverse order then we consider the later
-    // timestamp to be the one beginning the sub interval, and the earlier timestamp to be the one
-    // ending it. Note that this means that simply swapping the start and end times will not result in
-    // getting the same values back in reverse order as the intervals being requested in the two
-    // cases are not the same.
-    // If an Aggregate is taking a long time to calculate then the Server can return partial results
-    // with a continuation point. This might be done if the calculation is going to take more time th an
-    // the Client timeout hint. In some cases it may take longer than the Client timeout hint to
-    // calculate even one Aggregate result. Then the Server may return zero results with a
-    // continuation point that allows the Server to resume the calculation on the next Client read
-    // call.
-    const startTime = historyReadDetails.startTime;
-    const endTime = historyReadDetails.endTime;
-    if (!startTime || !endTime) {
-        return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInvalidArgument }));
-    }
-    if (startTime.getTime() === endTime.getTime()) {
-        // Start = End Int = Anything No intervals. Returns a Bad_InvalidArgument StatusCode,
-        // regardless of whether there is data at the specified time or not
-        return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInvalidArgument }));
-    }
-
-    const aggregateTypes: NodeId[] = historyReadDetails.aggregateType || [];
-
-    // If the ProcessingInterval is specified as 0 then Aggregates shall be calculated using one interval
-    // starting at startTime and ending at endTime.
-    const processingInterval = historyReadDetails.processingInterval || endTime.getTime() - startTime.getTime();
-
-    // tslint:disable-next-line: prefer-for-of
-
-    function applyAggregate(aggregateType: NodeId, callback2: (err: Error | null, result: HistoryReadResult) => void) {
-        function buildResult(err: Error | null, dataValues?: DataValue[]) {
-            if (err) {
-                return callback2(null, new HistoryReadResult({ statusCode: StatusCodes.BadInternalError }));
-            }
-            const result = new HistoryReadResult({
-                historyData: new HistoryData({
-                    dataValues
-                }),
-                statusCode: StatusCodes.Good
-            });
-            return callback2(null, result);
-        }
-
-        if (!startTime || !endTime) {
-            return buildResult(new Error("Invalid date time"));
-        }
-        switch (aggregateType.value) {
-            case AggregateFunction.Minimum:
-                getMinData(variable, processingInterval, startTime, endTime, buildResult);
-                break;
-            case AggregateFunction.Maximum:
-                getMaxData(variable, processingInterval, startTime, endTime, buildResult);
-                break;
-            case AggregateFunction.Interpolative:
-                getInterpolatedData(variable, processingInterval, startTime, endTime, buildResult);
-                break;
-            case AggregateFunction.Average:
-                getAverageData(variable, processingInterval, startTime, endTime, buildResult);
-                break;
-            case AggregateFunction.Count:
-            default:
-                // todo provide correct implementation
-                return callback2(null, new HistoryReadResult({ statusCode: StatusCodes.BadAggregateNotSupported }));
-        }
-    }
-    if (historyReadDetails.aggregateType?.length !== 1) {
-        return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInternalError }));
-    }
-    return applyAggregate(aggregateTypes[0], callback);
-}
+import * as async from "async";
+import { AggregateFunction } from "node-opcua-constants";
+import { ISessionContext, ContinuationPoint, UAVariable, ContinuationData } from "node-opcua-address-space";
+import { NumericRange } from "node-opcua-numeric-range";
+import { QualifiedNameLike } from "node-opcua-data-model";
+import { CallbackT, StatusCodes } from "node-opcua-status-code";
+import { DataValue } from "node-opcua-data-value";
+import { ObjectIds } from "node-opcua-constants";
+import { NodeId } from "node-opcua-nodeid";
+import {
+    HistoryData,
+    HistoryReadResult,
+    ReadAtTimeDetails,
+    ReadEventDetails,
+    ReadProcessedDetails,
+    ReadRawModifiedDetails
+} from "node-opcua-service-history";
+
+import { getMinData, getMaxData } from "./minmax";
+
+import { getInterpolatedData } from "./interpolate";
+import { getAverageData } from "./average";
+
+function _buildResult(err: Error | null, dataValues: DataValue[] | undefined, callback2: CallbackT<HistoryReadResult>) {
+    if (err) {
+        return callback2(null, new HistoryReadResult({ statusCode: StatusCodes.BadInternalError }));
+    }
+    const result = new HistoryReadResult({
+        historyData: new HistoryData({
+            dataValues
+        }),
+        statusCode: StatusCodes.Good
+    });
+    return callback2(null, result);
+}
+
+function applyAggregate(
+    variable: UAVariable,
+    processingInterval: number,
+    startTime: Date,
+    endTime: Date,
+    aggregateType: NodeId,
+    callback2: CallbackT<HistoryReadResult>
+) {
+    if (!startTime || !endTime) {
+        return _buildResult(new Error("Invalid date time"), undefined, callback2);
+    }
+    const buildResult = (err: Error | null, dataValues: DataValue[] | undefined) => {
+        _buildResult(err, dataValues, callback2);
+    };
+    switch (aggregateType.value) {
+        case AggregateFunction.Minimum:
+            getMinData(variable, processingInterval, startTime, endTime, buildResult);
+            break;
+        case AggregateFunction.Maximum:
+            getMaxData(variable, processingInterval, startTime, endTime, buildResult);
+            break;
+        case AggregateFunction.Interpolative:
+            getInterpolatedData(variable, processingInterval, startTime, endTime, buildResult);
+            break;
+        case AggregateFunction.Average:
+            getAverageData(variable, processingInterval, startTime, endTime, buildResult);
+            break;
+        case AggregateFunction.Count:
+        default:
+            // todo provide correct implementation
+            return callback2(null, new HistoryReadResult({ statusCode: StatusCodes.BadAggregateNotSupported }));
+    }
+}
+export function readProcessedDetails(
+    variable: UAVariable,
+    context: ISessionContext,
+    historyReadDetails: ReadProcessedDetails,
+    indexRange: NumericRange | null,
+    dataEncoding: QualifiedNameLike | null,
+    continuationData: ContinuationData,
+    callback: CallbackT<HistoryReadResult>
+): void {
+    // OPC Unified Architecture, Part 11 27 Release 1.03
+    //
+    // This structure is used to compute Aggregate values, qualities, and timestamps from data in
+    // the history database for the specified time domain for one or more HistoricalDataNodes. The
+    // time domain is divided into intervals of duration ProcessingInterval. The specified Aggregate
+    // Type is calculated for each interval beginning with startTime by using the data within the next
+    // ProcessingInterval.
+    // For example, this function can provide hourly statistics such as Maximum, Minimum , and
+    // Average for each item during the specified time domain when ProcessingInterval is 1 hour.
+    // The domain of the request is defined by startTime, endTime, and ProcessingInterval. All three
+    // shall be specified. If endTime is less than startTime then the data shall be returned in reverse
+    // order with the later data coming first. If startTime and endTime are the same then the Server
+    // shall return Bad_InvalidArgument as there is no meaningful way to interpret such a case. If
+    // the ProcessingInterval is specified as 0 then Aggregates shall be calculated using one interval
+    // starting at startTime and ending at endTime.
+    // The aggregateType[] parameter allows a Client to request multiple Aggregate calculations per
+    // requested NodeId. If multiple Aggregates are requested then a corresponding number of
+    // entries are required in the NodesToRead array.
+    // For example, to request Min Aggregate for NodeId FIC101, FIC102, and both Min and Max
+    // Aggregates for NodeId FIC103 would require NodeId FIC103 to appear twice in the
+    // NodesToRead array request parameter.
+    // aggregateType[] NodesToRead[]
+    // Min FIC101
+    // Min FIC102
+    // Min FIC103
+    // Max FIC103
+    // If the array of Aggregates does not match the array of NodesToRead then the Server shall
+    // return a StatusCode of Bad_AggregateListMismatch.
+    // The aggregateConfiguration parameter allows a Client to override the Aggregate configuration
+    // settings supplied by the AggregateConfiguration Object on a per call basis. See Part 13 for
+    // more information on Aggregate configurations. If the Server does not support the ability to
+    // override the Aggregate configuration settings then it shall return a StatusCode of Bad_
+    // AggregateConfigurationRejected. If the Aggregate is not valid for the Node then the
+    // StatusCode shall be Bad_AggregateNotSupported.
+    // The values used in computing the Aggregate for each interval shall include any value that
+    // falls exactly on the timestamp at the beginning of the interval, but shall not include any value
+    // that falls directly on the timestamp ending the interval. Thus, each value shall be included
+    // only once in the calculation. If the time domain is in reverse order then we consider the later
+    // timestamp to be the one beginning the sub interval, and the earlier timestamp to be the one
+    // ending it. Note that this means that simply swapping the start and end times will not result in
+    // getting the same values back in reverse order as the intervals being requested in the two
+    // cases are not the same.
+    // If an Aggregate is taking a long time to calculate then the Server can return partial results
+    // with a continuation point. This might be done if the calculation is going to take more time th an
+    // the Client timeout hint. In some cases it may take longer than the Client timeout hint to
+    // calculate even one Aggregate result. Then the Server may return zero results with a
+    // continuation point that allows the Server to resume the calculation on the next Client read
+    // call.
+    const startTime = historyReadDetails.startTime;
+    const endTime = historyReadDetails.endTime;
+    if (!startTime || !endTime) {
+        return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInvalidArgument }));
+    }
+    if (startTime.getTime() === endTime.getTime()) {
+        // Start = End Int = Anything No intervals. Returns a Bad_InvalidArgument StatusCode,
+        // regardless of whether there is data at the specified time or not
+        return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInvalidArgument }));
+    }
+
+    const aggregateTypes: NodeId[] = historyReadDetails.aggregateType || [];
+
+    // If the ProcessingInterval is specified as 0 then Aggregates shall be calculated using one interval
+    // starting at startTime and ending at endTime.
+    const processingInterval = historyReadDetails.processingInterval || endTime.getTime() - startTime.getTime();
+
+    // tslint:disable-next-line: prefer-for-of
+    if (historyReadDetails.aggregateType?.length !== 1) {
+        return callback(null, new HistoryReadResult({ statusCode: StatusCodes.BadInternalError }));
+    }
+    return applyAggregate(variable, processingInterval, startTime, endTime, aggregateTypes[0], callback);
+}