node-opcua-service-filter 2.74.0 → 2.75.0

package/source/check_where_clause.ts

@@ -0,0 +1,287 @@
+import {
+    ContentFilter,
+    FilterOperator,
+    LiteralOperand,
+    SimpleAttributeOperand,
+    FilterOperand,
+    AttributeOperand,
+    ElementOperand
+} from "node-opcua-types";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { DataType, Variant } from "node-opcua-variant";
+import { NodeClass } from "node-opcua-data-model";
+import { NodeId, sameNodeId } from "node-opcua-nodeid";
+import { make_warningLog } from "node-opcua-debug";
+//
+import { FilterContext } from "./filter_context";
+import { resolveOperand } from "./resolve_operand";
+
+const warningLog = make_warningLog("Filter");
+
+function _coerceToBoolean(value: Variant | number | string | null | boolean): boolean {
+    if (value instanceof Variant) {
+        return _coerceToBoolean(value.value);
+    }
+    return !!value;
+}
+function _coerceToNumber(value: Variant | number | string | null | boolean): number {
+    if (value instanceof Variant) {
+        return _coerceToNumber(value.value);
+    }
+    if (typeof value === "string") {
+        return parseInt(value, 10);
+    }
+    if (typeof value === "boolean") {
+        return value ? 1 : 0;
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+    return 0;
+}
+
+function evaluateOperand<T>(
+    filterContext: FilterContext,
+    filter: ContentFilter,
+    operand: FilterOperand,
+    coerce: (value: any) => T
+): T {
+    if (operand instanceof AttributeOperand) {
+        return coerce(resolveOperand(filterContext, operand));
+    } else if (operand instanceof SimpleAttributeOperand) {
+        return coerce(resolveOperand(filterContext, operand));
+    } else if (operand instanceof LiteralOperand) {
+        return coerce(operand.value);
+    } else if (operand instanceof ElementOperand) {
+        const index = operand.index;
+        return coerce(checkFilterAtIndex(filterContext, filter, index));
+    }
+    // istanbul ignore
+    return coerce(null);
+}
+
+function checkOfType(filterContext: FilterContext, ofType: ExtensionObject | null): boolean {
+    // istanbul ignore next
+    if (!ofType || !(ofType instanceof LiteralOperand)) {
+        warningLog("checkOfType : unsupported case ! ofType is not a LiteralOperand , ofType = ", ofType?.toString());
+        return false;
+    }
+    // istanbul ignore next
+    if (ofType.value.dataType !== DataType.NodeId) {
+        warningLog("invalid operand type (expecting NodeId); got " + DataType[ofType.value.dataType]);
+        return false;
+    }
+
+    const ofTypeNode: NodeId = ofType.value.value;
+    // istanbul ignore next
+    if (!ofTypeNode) {
+        return false; // the ofType node is not known, we don't know what to do
+    }
+    const ofTypeNodeNodeClass = filterContext.getNodeClass(ofTypeNode);
+
+    // istanbul ignore next
+    if (
+        ofTypeNodeNodeClass !== NodeClass.ObjectType &&
+        ofTypeNodeNodeClass !== NodeClass.VariableType &&
+        ofTypeNodeNodeClass !== NodeClass.DataType &&
+        ofTypeNodeNodeClass !== NodeClass.ReferenceType
+    ) {
+        warningLog("operand should be a ObjectType " + ofTypeNode.toString());
+        return false;
+    }
+
+    if (!filterContext.eventSource || filterContext.eventSource.isEmpty()) {
+        return false;
+    }
+
+    let sourceTypeDefinition = filterContext.eventSource;
+    const sourceNodeClass = filterContext.getNodeClass(filterContext.eventSource);
+    if (sourceNodeClass === NodeClass.Object || sourceNodeClass === NodeClass.Variable) {
+        sourceTypeDefinition = filterContext.getTypeDefinition(filterContext.eventSource)!;
+        if (!sourceTypeDefinition) {
+            return false;
+        }
+    }
+    return filterContext.isSubtypeOf(sourceTypeDefinition, ofTypeNode);
+}
+
+function checkNot(filterContext: FilterContext, filter: ContentFilter, filteredOperands: FilterOperand[]): boolean {
+    const operandA = evaluateOperand(filterContext, filter, filteredOperands[0], _coerceToBoolean);
+    return !operandA;
+}
+
+function checkOr(filterContext: FilterContext, filter: ContentFilter, filteredOperands: FilterOperand[]): boolean {
+    const operandA = evaluateOperand(filterContext, filter, filteredOperands[0], _coerceToBoolean);
+    const operandB = evaluateOperand(filterContext, filter, filteredOperands[1], _coerceToBoolean);
+    return operandA || operandB;
+}
+/**
+ *
+ * TRUE if operand[0] and operand[1] are TRUE.
+ * The following restrictions apply to the operands:
+ *  [0]: Any operand that resolves to a Boolean.
+ *
+ *   [1]: Any operand that resolves to a Boolean.
+ * If any operand cannot be resolved to a Boolean it is considered a NULL. See below for a discussion on the handling of NULL.
+ */
+function checkAnd(filterContext: FilterContext, filter: ContentFilter, filteredOperands: FilterOperand[]): boolean {
+    const operandA = evaluateOperand(filterContext, filter, filteredOperands[0], _coerceToBoolean);
+    const operandB = evaluateOperand(filterContext, filter, filteredOperands[1], _coerceToBoolean);
+    return operandA && operandB;
+}
+function checkLessThan(filterContext: FilterContext, filter: ContentFilter, filteredOperands: FilterOperand[]): boolean {
+    const operandA = evaluateOperand(filterContext, filter, filteredOperands[0], _coerceToNumber);
+    const operandB = evaluateOperand(filterContext, filter, filteredOperands[1], _coerceToNumber);
+    return operandA < operandB;
+}
+
+function checkLessThanOrEqual(filterContext: FilterContext, filter: ContentFilter, filteredOperands: FilterOperand[]): boolean {
+    const operandA = evaluateOperand(filterContext, filter, filteredOperands[0], _coerceToNumber);
+    const operandB = evaluateOperand(filterContext, filter, filteredOperands[1], _coerceToNumber);
+    return operandA <= operandB;
+}
+
+function checkGreaterThan(filterContext: FilterContext, filter: ContentFilter, filteredOperands: FilterOperand[]): boolean {
+    const operandA = evaluateOperand(filterContext, filter, filteredOperands[0], _coerceToNumber);
+    const operandB = evaluateOperand(filterContext, filter, filteredOperands[1], _coerceToNumber);
+    return operandA > operandB;
+}
+
+function checkGreaterThanOrEqual(filterContext: FilterContext, filter: ContentFilter, filteredOperands: FilterOperand[]): boolean {
+    const operandA = evaluateOperand(filterContext, filter, filteredOperands[0], _coerceToNumber);
+    const operandB = evaluateOperand(filterContext, filter, filteredOperands[1], _coerceToNumber);
+    return operandA >= operandB;
+}
+function checkEquals(filterContext: FilterContext, filter: ContentFilter, filteredOperands: FilterOperand[]): boolean {
+    const operandA = evaluateOperand(filterContext, filter, filteredOperands[0], _coerceToNumber);
+    const operandB = evaluateOperand(filterContext, filter, filteredOperands[1], _coerceToNumber);
+    return operandA === operandB;
+}
+/**
+ *
+ * TRUE if operand[0] is greater or equal to operand[1] and less than or equal to operand[2].
+ * The following restrictions apply to the operands:
+ *   [0]: Any operand that resolves to an ordered value.
+ *   [1]: Any operand that resolves to an ordered value.
+ *   [2]: Any operand that resolves to an ordered value.
+ * If the operands are of different types, the system shall perform any implicit conversion to match
+ * all operands to a common type. If no implicit conversion is available and the operands are of different
+ * types, the particular result is FALSE. See the discussion on data type precedence in Table 123
+ * for more information how to convert operands of different types.
+ */
+function checkBetween(filterContext: FilterContext, filter: ContentFilter, filteredOperands: FilterOperand[]): boolean {
+    const operandA = evaluateOperand(filterContext, filter, filteredOperands[0], _coerceToNumber);
+    const operandLow = evaluateOperand(filterContext, filter, filteredOperands[1], _coerceToNumber);
+    const operandHigh = evaluateOperand(filterContext, filter, filteredOperands[2], _coerceToNumber);
+    return operandA >= operandLow && operandA <= operandHigh;
+}
+
+/**
+ * 
+ * InList
+ * TRUE if operand[0] is equal to one or more of the remaining operands.
+ * The Equals Operator is evaluated for operand[0] and each remaining operand in the
+ * list. If any Equals evaluation is TRUE, InList returns TRUE
+ x*/
+function checkInList(context: FilterContext, filterOperands: FilterOperand[]): boolean {
+    const operand0 = filterOperands[0];
+
+    // istanbul ignore next
+    if (!(operand0 instanceof SimpleAttributeOperand)) {
+        // unsupported case
+        warningLog("FilterOperator.InList operand0 is not a SimpleAttributeOperand " + operand0.constructor.name);
+        return false;
+    }
+    const value = resolveOperand(context, operand0);
+
+    // istanbul ignore next
+    if (value.dataType !== DataType.NodeId) {
+        return false;
+    }
+
+    const nodeId: NodeId | null = value.value as NodeId;
+
+    // istanbul ignore next
+    if (!nodeId) {
+        return false;
+    }
+
+    function _is(nodeId1: NodeId, operandX: LiteralOperand): boolean {
+        if (operandX.value.dataType !== DataType.NodeId) {
+            return false;
+        }
+        const nodeId2 = operandX.value.value as NodeId;
+        const nodeClass = context.getNodeClass(nodeId2);
+        if (nodeClass === NodeClass.Unspecified) {
+            return false;
+        }
+        return sameNodeId(nodeId1, nodeId2);
+    }
+
+    for (let i = 1; i < filterOperands.length; i++) {
+        const filterOperand = filterOperands[i];
+        if (filterOperand instanceof LiteralOperand && _is(nodeId, filterOperand)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// eslint-disable-next-line complexity
+function checkFilterAtIndex(filterContext: FilterContext, filter: ContentFilter, index: number): boolean {
+    if (!filter.elements || filter.elements.length === 0) {
+        return true;
+    }
+    const element = filter.elements[index];
+
+    // istanbul ignore next
+    if (!element) {
+        return true;
+    }
+    const filterOperands = (element.filterOperands as FilterOperand[] | null) || [];
+
+    switch (element.filterOperator) {
+        case FilterOperator.Equals:
+            return checkEquals(filterContext, filter, filterOperands);
+        case FilterOperator.LessThan:
+            return checkLessThan(filterContext, filter, filterOperands);
+        case FilterOperator.LessThanOrEqual:
+            return checkLessThanOrEqual(filterContext, filter, filterOperands);
+        case FilterOperator.GreaterThan:
+            return checkGreaterThan(filterContext, filter, filterOperands);
+        case FilterOperator.GreaterThanOrEqual:
+            return checkGreaterThanOrEqual(filterContext, filter, filterOperands);
+        case FilterOperator.Between:
+            return checkBetween(filterContext, filter, filterOperands);
+
+        case FilterOperator.And:
+            return checkAnd(filterContext, filter, filterOperands);
+        case FilterOperator.Or:
+            return checkOr(filterContext, filter, filterOperands);
+        case FilterOperator.Not:
+            return checkNot(filterContext, filter, filterOperands);
+
+        case FilterOperator.OfType:
+            return checkOfType(filterContext, element.filterOperands![0]);
+        case FilterOperator.InList:
+            return checkInList(filterContext, filterOperands);
+
+        case FilterOperator.RelatedTo:
+        case FilterOperator.Like:
+        case FilterOperator.BitwiseAnd:
+        case FilterOperator.BitwiseOr:
+        case FilterOperator.Cast:
+        case FilterOperator.InView:
+        case FilterOperator.IsNull:
+        default:
+            // from Spec  OPC Unified Architecture, Part 4 133 Release 1.04
+            //  Any basic FilterOperator in Table 119 may be used in the whereClause, however, only the
+            //  OfType_14 FilterOperator from Table 120 is permitted.
+            warningLog(`checkFilter: operator ${FilterOperator[element.filterOperator]} is currently not supported in filter`);
+            return false;
+    }
+}
+
+export function checkFilter(filterContext: FilterContext, contentFilter: ContentFilter): boolean {
+    return checkFilterAtIndex(filterContext, contentFilter, 0);
+}

package/source/extract_event_field.ts

@@ -0,0 +1,55 @@
+import { assert } from "node-opcua-assert";
+import { AttributeIds } from "node-opcua-data-model";
+import { make_warningLog } from "node-opcua-debug";
+import { NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
+import { SimpleAttributeOperand } from "node-opcua-types";
+import { DataType, Variant } from "node-opcua-variant";
+import { FilterContext } from "./filter_context";
+import { resolveOperand } from "./resolve_operand";
+
+const warningLog = make_warningLog("FILTER");
+const conditionTypeNodeId = resolveNodeId("ConditionType");
+
+/**
+ *
+ * extract a eventField from a event node, matching the given selectClause
+ */
+export function extractEventField(context: FilterContext, operand: SimpleAttributeOperand): Variant {
+    assert(operand instanceof SimpleAttributeOperand);
+
+    operand.browsePath = operand.browsePath || [];
+
+    if (operand.browsePath.length === 0 && operand.attributeId === AttributeIds.NodeId) {
+        // "ns=0;i=2782" => ConditionType
+        // "ns=0;i=2041" => BaseEventType
+        if (!sameNodeId(operand.typeDefinitionId, conditionTypeNodeId)) {
+            // not a ConditionType
+            // but could be on of its derived type. for instance ns=0;i=2881 => AcknowledgeableConditionType
+            if (!context.isSubtypeOf(operand.typeDefinitionId, conditionTypeNodeId)) {
+                warningLog(" ", operand.typeDefinitionId.toString());
+                warningLog("this case is not handled yet : selectClause.typeDefinitionId = " + operand.typeDefinitionId.toString());
+                warningLog(operand.toString());
+                return new Variant({ dataType: DataType.NodeId, value: context.eventSource });
+            }
+        }
+
+        const eventSourceTypeDefinition = context.getTypeDefinition(context.eventSource);
+        if (!eventSourceTypeDefinition) {
+            // eventSource is a EventType class
+            return new Variant();
+        }
+
+        if (!context.isSubtypeOf(eventSourceTypeDefinition, conditionTypeNodeId)) {
+            return new Variant();
+        }
+        // Yeh : our EventType is a Condition Type !
+        return new Variant({ dataType: DataType.NodeId, value: context.eventSource });
+    }
+    return resolveOperand(context, operand);
+}
+
+export function extractEventFieldsBase(context: FilterContext, selectClauses: SimpleAttributeOperand[]): Variant[] {
+    assert(Array.isArray(selectClauses));
+    assert(selectClauses.length === 0 || selectClauses[0] instanceof SimpleAttributeOperand);
+    return selectClauses.map(extractEventField.bind(null, context));
+}

package/source/filter_context.ts

@@ -0,0 +1,15 @@
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { constructBrowsePathFromQualifiedName } from "node-opcua-service-translate-browse-path";
+import { AttributeOperand, BrowsePath, NodeClass, SimpleAttributeOperand } from "node-opcua-types";
+import { DataType, Variant } from "node-opcua-variant";
+
+export interface FilterContext {
+    readonly eventSource: NodeId;
+    isSubtypeOf(nodeId: NodeId, baseType: NodeId): boolean;
+    getTypeDefinition(nodeId: NodeId): NodeId | null;
+    // readOperand(operand: SimpleAttributeOperand | AttributeOperand): Variant;
+    readNodeValue(nodeId: NodeIdLike): Variant;
+    getNodeClass(nodeId: NodeId): NodeClass;
+    browsePath(browsePath: BrowsePath): NodeId | null;
+}
+

package/source/index.ts

@@ -1,8 +1,16 @@
 /**
  * @module node-opcua-service-filter
  */
+export * from "./check_event_clause";
+export * from "./check_where_clause";
+export * from "./extract_event_field";
+export * from "./filter_context";
 export * from "./imports";
+export * from "./make_content_filter";
+export * from "./on_address_space/extract_event_fields";
+export * from "./resolve_operand";
 export * from "./tools_event_filter";
+export * from "./on_address_space/filter_context_on_address_space";
 
 // The SimpleAttributeOperand is a simplified form of the AttributeOperand and all of the rules that
 // apply to the AttributeOperand also apply to the SimpleAttributeOperand. The examples provided in

package/source/make_content_filter.ts

@@ -0,0 +1,132 @@
+/**
+ * @module node-opcua-service-filter
+ */
+import { DataType } from "node-opcua-basic-types";
+import { ObjectTypeIds } from "node-opcua-constants";
+import { AttributeIds, coerceQualifiedName, QualifiedName, stringToQualifiedName } from "node-opcua-data-model";
+import { NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
+import { ContentFilterElementResult } from "node-opcua-types";
+import { Variant } from "node-opcua-variant";
+
+import {
+    AttributeOperand,
+    ContentFilter,
+    ContentFilterElement,
+    ContentFilterElementOptions,
+    ContentFilterOptions,
+    ElementOperand,
+    EventFilter,
+    FilterOperator,
+    LiteralOperand,
+    SimpleAttributeOperand
+} from "./imports";
+
+export function ofType(nodeId: NodeIdLike): ContentFilterElement {
+    const element: ContentFilterElement = new ContentFilterElement({
+        filterOperator: FilterOperator.OfType,
+        filterOperands: [
+            new LiteralOperand({
+                value: {
+                    dataType: DataType.NodeId,
+                    value: resolveNodeId(nodeId)
+                }
+            })
+        ]
+    });
+    return element;
+}
+
+export function l(dataType: DataType, value: any): LiteralOperand {
+    switch (dataType) {
+        case DataType.NodeId:
+            value = resolveNodeId(value);
+    }
+
+    return new LiteralOperand({ value: new Variant({ dataType, value }) });
+}
+export function n(n: NodeIdLike): LiteralOperand {
+    return l(DataType.NodeId, n);
+}
+
+export function s(attributeId: AttributeIds, path: string): SimpleAttributeOperand {
+    return new SimpleAttributeOperand({
+        attributeId: attributeId,
+        browsePath: path.split(".").map(coerceQualifiedName)
+    });
+}
+
+type A = LiteralOperand | SimpleAttributeOperand | AttributeOperand | ContentFilterElement;
+
+export function or(a: A, b: A): ContentFilterElement {
+    return new ContentFilterElement({
+        filterOperands: [a, b],
+        filterOperator: FilterOperator.Or
+    });
+}
+export function and(a: A, b: A): ContentFilterElement {
+    return new ContentFilterElement({
+        filterOperands: [a, b],
+        filterOperator: FilterOperator.And
+    });
+}
+export function lessThan(a: A, b: A): ContentFilterElement {
+    return new ContentFilterElement({
+        filterOperands: [a, b],
+        filterOperator: FilterOperator.LessThan
+    });
+}
+export function LessThanOrEqual(a: A, b: A): ContentFilterElement {
+    return new ContentFilterElement({
+        filterOperands: [a, b],
+        filterOperator: FilterOperator.LessThanOrEqual
+    });
+}
+
+export function greaterThanOrEqual(a: A, b: A): ContentFilterElement {
+    return new ContentFilterElement({
+        filterOperands: [a, b],
+        filterOperator: FilterOperator.GreaterThanOrEqual
+    });
+}
+
+export function greaterThan(a: A, b: A): ContentFilterElement {
+    return new ContentFilterElement({
+        filterOperands: [a, b],
+        filterOperator: FilterOperator.GreaterThan
+    });
+}
+
+export function inList(a: A, l: A[]) {
+    return new ContentFilterElement({
+        filterOperands: [a, ...l],
+        filterOperator: FilterOperator.InList
+    });
+}
+
+export function makeContentFilterElements(o: ContentFilterElement): ContentFilterElement[] {
+    const elements: ContentFilterElement[] = [];
+
+    function pushElement(element: ContentFilterElement) {
+        elements.push(element);
+        const thisIndex = elements.length - 1;
+        if (element.filterOperands) {
+            for (let i = 0; i < element.filterOperands.length; i++) {
+                const op = element.filterOperands[i];
+                if (op instanceof ContentFilterElement) {
+                    const index = pushElement(op);
+                    element.filterOperands![i] = new ElementOperand({ index });
+                }
+            }
+        }
+        return thisIndex;
+    }
+    pushElement(o);
+
+    return elements;
+}
+
+export function makeContentFilter(o: ContentFilterElementOptions): ContentFilter {
+    return new ContentFilter({
+        elements: makeContentFilterElements(o instanceof ContentFilterElement ? o : new ContentFilterElement(o))
+    });
+}

package/source/on_address_space/extract_event_fields.ts

@@ -0,0 +1,24 @@
+import {
+    IEventData,
+    ISessionContext} from "node-opcua-address-space-base";
+import { SimpleAttributeOperand } from "node-opcua-types";
+import { Variant } from "node-opcua-variant";
+//
+import { extractEventFieldsBase } from "../extract_event_field";
+import { FilterContextOnAddressSpace } from "./filter_context_on_address_space";
+
+
+/**
+ * @method extractEventFields
+ * extract a array of eventFields from a event node, matching the selectClauses
+ * @param selectClauses
+ * @param eventData : a pseudo Node that provides a browse Method and a readValue(nodeId)
+ */
+export function extractEventFields(
+    sessionContext: ISessionContext,
+    selectClauses: SimpleAttributeOperand[],
+    eventData: IEventData
+): Variant[] {
+    const context = new FilterContextOnAddressSpace(sessionContext, eventData);
+    return extractEventFieldsBase(context, selectClauses);
+}

package/source/on_address_space/filter_context_on_address_space.ts

@@ -0,0 +1,134 @@
+import {
+    BaseNode,
+    IAddressSpace,
+    IEventData,
+    ISessionContext,
+    UADataType,
+    UAObject,
+    UAObjectType,
+    UAReferenceType,
+    UAVariable,
+    UAVariableType
+} from "node-opcua-address-space-base";
+import { AttributeIds, NodeClass } from "node-opcua-data-model";
+import { make_warningLog } from "node-opcua-debug";
+import { NodeId, sameNodeId, NodeIdLike, coerceNodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { BrowsePath } from "node-opcua-types";
+import { Variant, DataType } from "node-opcua-variant";
+import { DataValue } from "node-opcua-data-value";
+//
+import { FilterContext } from "../filter_context";
+
+const warningLog = make_warningLog("Filter");
+
+export class FilterContextOnAddressSpace implements FilterContext {
+    public eventSource: NodeId;
+
+    constructor(private sessionContext: ISessionContext, private eventData: IEventData) {
+        this.eventSource = this.eventData.$eventDataSource?.nodeId || NodeId.nullNodeId;
+    }
+
+    getNodeClass(nodeId: NodeId): NodeClass {
+        const addressSpace = this.getAddressSpace();
+        const node = addressSpace.findNode(nodeId);
+        return node ? node.nodeClass : NodeClass.Unspecified;
+    }
+
+    isSubtypeOf(nodeId: NodeId, baseType: NodeId): boolean {
+        const addressSpace = this.getAddressSpace();
+        const node = addressSpace.findNode(nodeId);
+        const baseTypeNode = addressSpace.findNode(baseType);
+        if (!node || !baseTypeNode) {
+            warningLog("invalid node - must be specifed ");
+            return false;
+        }
+        if (node.nodeClass === NodeClass.ObjectType && baseTypeNode.nodeClass === NodeClass.ObjectType) {
+            return (node as UAObjectType).isSupertypeOf(baseTypeNode as UAObjectType);
+        }
+        if (node.nodeClass === NodeClass.VariableType && baseTypeNode.nodeClass === NodeClass.VariableType) {
+            return (node as UAVariableType).isSupertypeOf(baseTypeNode as UAVariableType);
+        }
+        if (node.nodeClass === NodeClass.ReferenceType && baseTypeNode.nodeClass === NodeClass.ReferenceType) {
+            return (node as UAReferenceType).isSupertypeOf(baseTypeNode as UAReferenceType);
+        }
+        if (node.nodeClass === NodeClass.DataType && baseTypeNode.nodeClass === NodeClass.DataType) {
+            return (node as UADataType).isSupertypeOf(baseTypeNode as UADataType);
+        }
+        if (node.nodeClass === NodeClass.Object && baseTypeNode.nodeClass === NodeClass.ObjectType) {
+            const obj = node as UAObject;
+            return obj.typeDefinitionObj.isSupertypeOf(baseTypeNode as UAObjectType);
+        }
+        if (node.nodeClass === NodeClass.Variable && baseTypeNode.nodeClass !== NodeClass.VariableType) {
+            const obj = node as UAVariable;
+            return obj.typeDefinitionObj.isSupertypeOf(baseTypeNode as UAVariableType);
+        }
+        return false;
+    }
+
+    getTypeDefinition(nodeId: NodeId): NodeId | null {
+        const addressSpace = this.getAddressSpace();
+        const node = addressSpace.findNode(nodeId);
+        if (!node) return null;
+        if (node.nodeClass === NodeClass.Object || node.nodeClass === NodeClass.Variable) {
+            return (node as UAObject | UAVariable).typeDefinition;
+        }
+        return null;
+    }
+
+    readNodeValue(nodeId: NodeIdLike): Variant {
+        nodeId = coerceNodeId(nodeId);
+
+        // use  cache/snapshot if available
+        const value = this.eventData._readValue(nodeId);
+        if (value) {
+            return value;
+        }
+
+        const addressSpace = this.getAddressSpace();
+        const node = addressSpace.findNode(nodeId);
+        if (!node || node.nodeClass !== NodeClass.Variable) {
+            return new Variant();
+        }
+        return prepare((node as UAVariable).readValue(this.sessionContext));
+    }
+
+    private getAddressSpace(): IAddressSpace {
+        return this.eventData.$eventDataSource!.addressSpace;
+    }
+
+    public browsePath(browsePath: BrowsePath): NodeId | null {
+
+        // delegate to eventData if appropriate
+        if (sameNodeId(browsePath.startingNode, this.eventSource)) {
+            const browseResult = this.eventData._browse(browsePath);
+            if (
+                browseResult &&
+                browseResult.statusCode === StatusCodes.Good &&
+                browseResult.targets &&
+                browseResult.targets.length === 1
+            ) {
+                return browseResult.targets![0].targetId;
+            }
+        }
+
+        // fallback to addressSpace otherwise
+        const addressSpace = this.getAddressSpace();
+        const browseResult = addressSpace.browsePath(browsePath);
+        if (browseResult.statusCode !== StatusCodes.Good || !browseResult.targets || browseResult.targets.length !== 1) {
+            return null;
+        }
+        return browseResult.targets[0].targetId;
+    }
+
+    setEventSource(eventSource: BaseNode | null) {
+        this.eventSource = eventSource ? eventSource.nodeId : NodeId.nullNodeId;
+    }
+}
+
+function prepare(dataValue: DataValue): Variant {
+    if (dataValue.statusCode === StatusCodes.Good) {
+        return dataValue.value;
+    }
+    return new Variant({ dataType: DataType.StatusCode, value: dataValue.statusCode });
+}

package/source/on_address_space/index.ts

@@ -0,0 +1,3 @@
+
+export * from "./filter_context_on_address_space";
+export * from "./extract_event_fields";