node-opcua-address-space 2.80.0 → 2.82.0

package/src/namespace_private.ts

@@ -10,14 +10,18 @@ import {
     CreateNodeOptions,
     ModellingRuleType,
     INamespace,
-    UADataType
+    UADataType,
+    RequiredModel
 } from "node-opcua-address-space-base";
 
 import { AddressSpacePrivate } from "./address_space_private";
 
+
 export interface NamespacePrivate extends INamespace {
     addressSpace: AddressSpacePrivate;
 
+    setRequiredModels(requiredModels: RequiredModel[]): void;
+
     nodeIterator(): IterableIterator<BaseNode>;
 
     constructNodeId(options: ConstructNodeIdOptions): NodeId;
@@ -35,6 +39,8 @@ export interface NamespacePrivate extends INamespace {
     _dataTypeIterator(): IterableIterator<UADataType>;
 
     registerSymbolicNames: boolean;
+
+
 }
 
 export declare const NamespacePrivate: new (options: any) => NamespacePrivate;

package/src/nodeset_tools/construct_namespace_dependency.ts

@@ -8,19 +8,23 @@ function _constructNamespaceDependency(
     namespace: INamespace,
     dependency: INamespace[],
     depMap: Set<number>,
-    _visitedDataType: Set<string>
+    _visitedDataType: Set<string>,
+    priorityTable: number[]
 ): void {
     const addressSpace = namespace.addressSpace;
     const namespace_ = namespace as NamespacePrivate;
     // navigate all namespace recursively to
 
     function consider(namespaceIndex: number) {
+        if (hasHigherPriorityThan(namespaceIndex,namespace.index, priorityTable)) {
+            return;
+        }
         if (!depMap.has(namespaceIndex)) {
             depMap.add(namespaceIndex);
             const namespace = addressSpace.getNamespace(namespaceIndex);
             dependency.push(namespace);
             if (namespaceIndex > 0) {
-                _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType);
+                _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
             }
         }
     }
@@ -57,7 +61,7 @@ function _constructNamespaceDependency(
                 exploreDataTypes(dataTypeNode);
             } else {
                 // istanbul ignore next
-                if (dataTypeNodeId.value!=0) {
+                if (dataTypeNodeId.value != 0) {
                     console.log("Internal error: Cannot find dataType", dataTypeNodeId.toString());
                 }
             }
@@ -74,8 +78,41 @@ function _constructNamespaceDependency(
     }
 }
 
-export function constructNamespaceDependency(namespace: INamespace): INamespace[] {
+
+export function hasHigherPriorityThan(namespaceIndex1: number, namespaceIndex2: number, priorityTable: number[]) {
+    const order1 = priorityTable[namespaceIndex1];
+    const order2 = priorityTable[namespaceIndex2];
+    return order1 > order2;
+}
+
+export function constructNamespacePriorityTable(namespace: INamespace): number[] {
+
+    // Namespace 0 will always be 0 
+    // Namespaces with no requiredModel will be considered as instance namespaces and will added at the end
+    // in the same order as they appear,
+    // Namespace with requiredModels are considered to be companion specification, so already loaded in the correct order
+ 
+    const addressSpace = namespace.addressSpace;
+    const namespaces = addressSpace.getNamespaceArray();
+
+    const namespaceWithReq = namespaces.filter((n)=> (n.getRequiredModels() !== undefined)  && n.index !==0);
+    const namespaceWithoutReq = namespaces.filter((n)=>(n.getRequiredModels() === undefined) && n.index !==0);
+    
+    const priorityList: number[] = [0];
+    let counter = 1;
+    for (let i = 0; i < namespaceWithReq.length; i++) {
+        priorityList[namespaceWithReq[i].index] = counter++;
+    }
+    for (let i = 0; i < namespaceWithoutReq.length; i++) {
+        priorityList[namespaceWithoutReq[i].index] = counter++;
+    }
+    return priorityList;
+}
+
+export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
     const addressSpace = namespace.addressSpace;
+   
+    priorityTable = priorityTable || constructNamespacePriorityTable(namespace);
 
     const dependency: INamespace[] = [];
     const depMap = new Set<number>();
@@ -89,7 +126,7 @@ export function constructNamespaceDependency(namespace: INamespace): INamespace[
     }
     const _visitedDataType = new Set<string>();
 
-    _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType);
+    _constructNamespaceDependency(namespace, dependency, depMap, _visitedDataType, priorityTable);
 
     return dependency;
 }

package/src/nodeset_tools/nodeset_to_xml.ts

@@ -34,7 +34,7 @@ import {
 import { AttributeIds, Int64, minOPCUADate, StatusCode, StatusCodes } from "node-opcua-basic-types";
 import { BrowseDescription, EnumDefinition, StructureDefinition, StructureType } from "node-opcua-types";
 
-import { XmlWriter } from "../../source/xml_writer";
+import { ITranslationTable, XmlWriter } from "../../source/xml_writer";
 import { NamespacePrivate } from "../namespace_private";
 import { ReferenceImpl } from "../reference_impl";
 import { BaseNodeImpl, getReferenceType } from "../base_node_impl";
@@ -50,7 +50,7 @@ import { SessionContext } from "../index_current";
 
 import { DefinitionMap2, TypeInfo } from "../../source/loader/make_xml_extension_object_parser";
 import { makeDefinitionMap } from "../../source/loader/decode_xml_extension_object";
-import { constructNamespaceDependency } from "./construct_namespace_dependency";
+import { constructNamespaceDependency, constructNamespacePriorityTable, hasHigherPriorityThan } from "./construct_namespace_dependency";
 
 // tslint:disable:no-var-requires
 const XMLWriter = require("xml-writer");
@@ -98,17 +98,20 @@ function b(xw: XmlWriter, browseName: QualifiedName): string {
     return translateBrowseName(xw, browseName).toString().replace("ns=0;", "");
 }
 
-function _dumpReverseReferences(xw: XmlWriter, node: BaseNode) {
-    const addressSpace = node.addressSpace;
-    const hasSubtypeReferenceType = addressSpace.findReferenceType("HasSubtype")!;
+function _hasHigherPriorityThan(xw: XmlWriter, namespaceIndex1: number, namespaceIndex2: number) {
+    assert(xw.priorityTable, "expecting a priorityTable");
+    assert(namespaceIndex1 < xw.priorityTable.length);
+    assert(namespaceIndex2 < xw.priorityTable.length);
+    return hasHigherPriorityThan(namespaceIndex1, namespaceIndex2, xw.priorityTable);
 }
+
 function _dumpReferences(xw: XmlWriter, node: BaseNode) {
     xw.startElement("References");
 
     const addressSpace = node.addressSpace;
 
     const aggregateReferenceType = addressSpace.findReferenceType("Aggregates")!;
-    const hasChildReferenceType = addressSpace.findReferenceType("HasChild")!;
+    // const hasChildReferenceType = addressSpace.findReferenceType("HasChild")!;
     const hasSubtypeReferenceType = addressSpace.findReferenceType("HasSubtype")!;
     const hasTypeDefinitionReferenceType = addressSpace.findReferenceType("HasTypeDefinition")!;
     const nonHierarchicalReferencesType = addressSpace.findReferenceType("NonHierarchicalReferences")!;
@@ -119,6 +122,13 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
     function referenceToKeep(reference: UAReference): boolean {
         const referenceType = (reference as ReferenceImpl)._referenceType!;
 
+        const targetedNamespaceIndex = reference.nodeId.namespace;
+        if (_hasHigherPriorityThan(xw, targetedNamespaceIndex, node.nodeId.namespace)) {
+            // this reference has nothing to do here ! drop it
+            // because the target namespace is higher in the hierarchy
+            return false;
+        }
+
         // get the direct backward reference to a external namespace
         if (referenceType.isSupertypeOf(aggregateReferenceType) && !reference.isForward) {
             if (reference.nodeId.namespace !== node.nodeId.namespace) {
@@ -128,7 +138,9 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
                 return true;
             }
         }
-
+        if (referenceType.isSupertypeOf(hasSubtypeReferenceType) && reference.isForward) {
+            // return false;
+        }
         // only keep
         if (referenceType.isSupertypeOf(aggregateReferenceType) && reference.isForward) {
             return true;
@@ -154,8 +166,6 @@ function _dumpReferences(xw: XmlWriter, node: BaseNode) {
         if (getReferenceType(reference).browseName.toString() === "HasSubtype" && reference.isForward) {
             continue;
         }
-
-        // only output inverse Reference
         xw.startElement("Reference");
 
         xw.writeAttribute("ReferenceType", b(xw, getReferenceType(reference).browseName));
@@ -665,7 +675,6 @@ function _dumpArrayDimensionsAttribute(xw: XmlWriter, node: UAVariableType | UAV
 }
 
 function visitUANode(node: BaseNode, data: DumpData, forward: boolean) {
-    assert(typeof forward === "boolean");
 
     const addressSpace = node.addressSpace;
 
@@ -772,7 +781,9 @@ function dumpCommonAttributes(xw: XmlWriter, node: BaseNode) {
 
     const parentNode = getParent(node);
     if (parentNode) {
-        xw.writeAttribute("ParentNodeId", n(xw, parentNode.nodeId));
+        if (parentNode.nodeId.namespace <= node.nodeId.namespace) {
+            xw.writeAttribute("ParentNodeId", n(xw, parentNode.nodeId));
+        }
     }
     if (Object.prototype.hasOwnProperty.call(node, "symbolicName")) {
         xw.writeAttribute("SymbolicName", (node as any).symbolicName);
@@ -788,6 +799,12 @@ function dumpCommonAttributes(xw: XmlWriter, node: BaseNode) {
             xw.writeAttribute("AccessLevel", (node as UAVariable).accessLevel.toString());
         }
     }
+    if (Object.prototype.hasOwnProperty.call(node, "minimumSamplingInterval")) {
+        const minimumSamplingInterval =(node as UAVariable).minimumSamplingInterval;
+        if (minimumSamplingInterval > 0) {
+            xw.writeAttribute("MinimumSamplingInterval", minimumSamplingInterval);
+        }
+    }
 }
 
 function dumpCommonElements(xw: XmlWriter, node: BaseNode) {
@@ -800,11 +817,11 @@ function coerceInt64ToInt32(int64: Int64): number {
     if (typeof int64 === "number") {
         return int64 as number;
     }
-    if (int64[0] === 4294967295 && int64[1] === 4294967295) {
+    if (int64[0] === 0xffffffff && int64[1] === 0xffffffff) {
         return 0xffffffff;
     }
     if (int64[0] !== 0) {
-        debugLog("coerceInt64ToInt32 , loosing high word in conversion");
+        warningLog("coerceInt64ToInt32 , loosing high word in conversion");
     }
     return int64[1];
 }
@@ -831,8 +848,8 @@ function _dumpStructureDefinition(
      * note: baseDataType and defaultEncodingId are implicit and not stored in the XML file ??
      *
      */
-    const baseDataType = structureDefinition.baseDataType;
-    const defaultEncodingId = structureDefinition.defaultEncodingId;
+    // const baseDataType = structureDefinition.baseDataType;
+    // const defaultEncodingId = structureDefinition.defaultEncodingId;
 
     // do not repeat elements that are already defined in base structure in the xml ouput!
     const fields = structureDefinition.fields || [];
@@ -927,9 +944,7 @@ function dumpUADataType(xw: XmlWriter, node: UADataType) {
         xw.writeAttribute("IsAbstract", node.isAbstract ? "true" : "false");
     }
 
-    _dumpDisplayName(xw, node);
-
-    _dumpReferences(xw, node);
+    dumpCommonElements(xw, node);
 
     _dumpUADataTypeDefinition(xw, node);
 
@@ -1015,11 +1030,11 @@ function dumpUAVariableType(xw: XmlWriter, node: UAVariableType) {
             // throw new Error(" cannot find datatype " + node.dataType);
             console.log(
                 " cannot find datatype " +
-                    node.dataType +
-                    " for node " +
-                    node.browseName.toString() +
-                    " id =" +
-                    node.nodeId.toString()
+                node.dataType +
+                " for node " +
+                node.browseName.toString() +
+                " id =" +
+                node.nodeId.toString()
             );
         } else {
             const dataTypeName = b(xw, resolveDataTypeName(addressSpace, dataTypeNode.nodeId));
@@ -1088,11 +1103,18 @@ function dumpAggregates(xw: XmlWriter, node: BaseNode) {
     // Xx xw.writeComment("Aggregates {{ ");
     const aggregates = node
         .getAggregates()
-        .sort((x: BaseNode, y: BaseNode) => (x.browseName.name!.toString() > y.browseName.name!.toString() ? 1 : -1));
+        .sort(sortByBrowseName);
+    // const aggregates = node.findReferencesExAsObject("Aggregates", BrowseDirection.Forward);
+
     for (const aggregate of aggregates.sort(sortByNodeId)) {
         // do not export node that do not belong to our namespace
         if (node.nodeId.namespace !== aggregate.nodeId.namespace) {
-            return;
+            continue;
+        }
+        // even further! we should export here the children
+        // that have been added later by a namespace with higher index
+        if (_hasHigherPriorityThan(xw, aggregate.nodeId.namespace, node.nodeId.namespace)) {
+            continue;
         }
         if (!xw.visitedNode[_hash(aggregate)]) {
             (<BaseNodeImpl>aggregate).dumpXML(xw);
@@ -1219,18 +1241,15 @@ function writeAliases(xw: XmlWriter, aliases: Record<string, NodeIdString>) {
     }
     xw.endElement();
 }
-interface ITranslationTable {
-    [key: number]: number;
-}
 
-function constructNamespaceTranslationTable(dependency: INamespace[]): ITranslationTable {
+
+export function constructNamespaceTranslationTable(dependency: INamespace[]): ITranslationTable {
     const translationTable: ITranslationTable = {};
     for (let i = 0; i < dependency.length; i++) {
         translationTable[dependency[i].index] = i;
     }
     return translationTable;
 }
-
 function dumpReferenceType(xw: XmlWriter, referenceType: UAReferenceType) {
     _markAsVisited(xw, referenceType);
 
@@ -1249,7 +1268,7 @@ function dumpReferenceType(xw: XmlWriter, referenceType: UAReferenceType) {
     xw.endElement();
 }
 
-function sortByBrowseName(x: BaseNode, y: BaseNode): number {
+export function sortByBrowseName(x: BaseNode, y: BaseNode): number {
     const x_str = x.browseName.toString();
     const y_str = y.browseName.toString();
     if (x_str > y_str) {
@@ -1281,56 +1300,6 @@ export interface DumpXMLOptions {
     /** */
 }
 
-export function dumpXml(node: BaseNode, options: DumpXMLOptions): void {
-    const namespace = node.namespace as NamespacePrivate;
-
-    // make a first visit so that we determine which node to output and in which order
-    const data: DumpData = { aliases: {}, aliases_visited: {}, index_el: {}, elements: [] };
-
-    const dependency = constructNamespaceDependency(namespace);
-    const translationTable = constructNamespaceTranslationTable(dependency);
-
-    const xw = new XMLWriter(true);
-    xw.translationTable = translationTable;
-
-    visitUANode(node, data, false);
-
-    xw.startDocument({ encoding: "utf-8" });
-    xw.startElement("UANodeSet");
-    xw.writeAttribute("xmlns:xs", "http://www.w3.org/2001/XMLSchema-instance");
-    xw.writeAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
-    xw.writeAttribute("Version", "1.02");
-    xw.writeAttribute("LastModified", new Date().toISOString());
-    xw.writeAttribute("xmlns", "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd");
-
-    buildUpAliases(node, xw, data);
-    writeAliases(xw, data.aliases);
-
-    const xmlNamspace = {
-        default: { namespace: "http://opcfoundation.org/UA/2011/03/UANodeSet.xsd" }
-    };
-
-    xw.startElement("Extensions");
-    {
-        xw.startElement("Extension");
-        {
-            xw.startElement("ModelInfo");
-            xw.writeAttribute("NodeOPCUA");
-            xw.endElement();
-        }
-        xw.endElement();
-    }
-    xw.endElement();
-
-    for (const el of data.elements!) {
-        el.dumpXML(xw);
-    }
-
-    xw.endElement();
-    xw.endDocument();
-    return xw.toString();
-}
-
 UAMethodImpl.prototype.dumpXML = function (xw) {
     dumpUAMethod(xw, this);
 };
@@ -1360,17 +1329,21 @@ function makeTypeXsd(namespaceUri: string): string {
 
 // eslint-disable-next-line max-statements
 NamespaceImpl.prototype.toNodeset2XML = function (this: NamespaceImpl) {
-    const dependency = constructNamespaceDependency(this);
-    const translationTable = constructNamespaceTranslationTable(dependency);
+
 
     const namespaceArrayNode = this.addressSpace.findNode(VariableIds.Server_NamespaceArray);
     const namespaceArray: string[] = namespaceArrayNode
         ? namespaceArrayNode.readAttribute(null, AttributeIds.Value).value.value
         : [];
 
-    const xw = new XMLWriter(true);
+    const xw: XmlWriter = new XMLWriter(true);
+
+    xw.priorityTable = constructNamespacePriorityTable(this);
+    const dependency = constructNamespaceDependency(this, xw.priorityTable);
+    const translationTable = constructNamespaceTranslationTable(dependency);
     xw.translationTable = translationTable;
 
+
     xw.startDocument({ encoding: "utf-8", version: "1.0" });
     xw.startElement("UANodeSet");
 

package/src/ua_data_type_impl.ts

@@ -46,6 +46,7 @@ export interface EnumerationInfo {
 }
 export interface UADataTypeOptions extends InternalBaseNodeOptions {
     partialDefinition: StructureFieldOptions[] | EnumFieldOptions[];
+    isUnion?: boolean;
     isAbstract?: boolean;
     symbolicName?: string;
 }
@@ -78,6 +79,7 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
 
     public readonly isAbstract: boolean;
 
+    private $isUnion?: boolean;
     private enumStrings?: any;
     private enumValues?: any;
     private $partialDefinition?: StructureFieldOptions[] | EnumFieldOptions[];
@@ -87,6 +89,7 @@ export class UADataTypeImpl extends BaseNodeImpl implements UADataType {
         super(options);
         if (options.partialDefinition) {
             this.$partialDefinition = options.partialDefinition;
+            this.$isUnion = options.isUnion;
         }
         this.isAbstract = options.isAbstract === undefined || options.isAbstract === null ? false : options.isAbstract;
         this.symbolicName = options.symbolicName || this.browseName.name!;

package/src/ua_variable_impl.ts

@@ -348,23 +348,39 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
 
         this.semantic_version = 0;
     }
-
-    private checkPermissionAndAccessLevelPrivate(
+    private checkAccessLevelPrivate(
+        _context: ISessionContext,
+        accessLevel: AccessLevelFlag): boolean {
+        if (this.userAccessLevel === undefined) {
+            return true;
+        }
+        return (this.userAccessLevel & accessLevel) === accessLevel;
+    }
+    private checkPermissionPrivate(
         context: ISessionContext,
         permission: PermissionType,
-        accessLevel: AccessLevelFlag
-    ) {
+    ): boolean {
+        if (!context) return true;
         assert(context instanceof SessionContext);
         if (context.checkPermission) {
-            assert(context.checkPermission instanceof Function);
+            if (!(context.checkPermission instanceof Function)) {
+                errorLog("context checkPermission is not a function");
+                return false;
+            }
             if (!context.checkPermission(this, permission)) {
                 return false;
             }
         }
-        if (this.userAccessLevel === undefined) {
-            return true;
+        return true;
+    }
+    private checkPermissionAndAccessLevelPrivate(
+        context: ISessionContext,
+        permission: PermissionType,
+        accessLevel: AccessLevelFlag): boolean {
+        if (!this.checkPermissionPrivate(context, permission)) {
+            return false;
         }
-        return (this.userAccessLevel & accessLevel) === accessLevel;
+        return this.checkAccessLevelPrivate(context, accessLevel);
     }
 
     public isReadable(context: ISessionContext): boolean {
@@ -375,7 +391,10 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         if (!this.isReadable(context)) {
             return false;
         }
-        return this.checkPermissionAndAccessLevelPrivate(context, PermissionType.Read, AccessLevelFlag.CurrentRead);
+        if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
+            return false;
+        }
+        return this.checkAccessLevelPrivate(context, AccessLevelFlag.CurrentRead);
     }
 
     public isWritable(context: ISessionContext): boolean {
@@ -451,9 +470,12 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         if (!this.isReadable(context)) {
             return new DataValue({ statusCode: StatusCodes.BadNotReadable });
         }
-        if (!this.isUserReadable(context)) {
+        if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
             return new DataValue({ statusCode: StatusCodes.BadUserAccessDenied });
         }
+        if (!this.isUserReadable(context)) {
+            return new DataValue({ statusCode: StatusCodes.BadNotReadable });
+        }
         if (!isValidDataEncoding(dataEncoding)) {
             return new DataValue({ statusCode: StatusCodes.BadDataEncodingInvalid });
         }
@@ -484,10 +506,10 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         ) {
             debugLog(
                 chalk.red(" Warning:  UAVariable#readValue ") +
-                    chalk.cyan(this.browseName.toString()) +
-                    " (" +
-                    chalk.yellow(this.nodeId.toString()) +
-                    ") exists but dataValue has not been defined"
+                chalk.cyan(this.browseName.toString()) +
+                " (" +
+                chalk.yellow(this.nodeId.toString()) +
+                ") exists but dataValue has not been defined"
             );
         }
         return dataValue;
@@ -689,9 +711,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 if (variant.dataType === null || variant.dataType === undefined) {
                     throw new Error(
                         "Variant must provide a valid dataType : variant = " +
-                            variant.toString() +
-                            " this.dataType= " +
-                            this.dataType.toString()
+                        variant.toString() +
+                        " this.dataType= " +
+                        this.dataType.toString()
                     );
                 }
                 if (
@@ -700,9 +722,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 ) {
                     throw new Error(
                         "Variant must provide a valid Boolean : variant = " +
-                            variant.toString() +
-                            " this.dataType= " +
-                            this.dataType.toString()
+                        variant.toString() +
+                        " this.dataType= " +
+                        this.dataType.toString()
                     );
                 }
                 if (
@@ -713,9 +735,9 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 ) {
                     throw new Error(
                         "Variant must provide a valid LocalizedText : variant = " +
-                            variant.toString() +
-                            " this.dataType= " +
-                            this.dataType.toString()
+                        variant.toString() +
+                        " this.dataType= " +
+                        this.dataType.toString()
                     );
                 }
             }
@@ -870,8 +892,13 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         if (!this.isWritable(context)) {
             return callback!(null, StatusCodes.BadNotWritable);
         }
+        if (!this.checkPermissionPrivate(context, PermissionType.Write)) {
+            return new DataValue({ statusCode: StatusCodes.BadUserAccessDenied });
+        }
+
+
         if (!this.isUserWritable(context)) {
-            return callback!(null, StatusCodes.BadUserAccessDenied);
+            return callback!(null, StatusCodes.BadWriteNotSupported);
         }
 
         // adjust special case
@@ -997,9 +1024,14 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 if (writeValue.value!.value.dataType !== DataType.Boolean) {
                     return callback(null, StatusCodes.BadTypeMismatch);
                 }
-                if (!this.canUserWriteHistorizingAttribute(context)) {
+                if (!this.checkPermissionPrivate(context, PermissionType.WriteHistorizing)) {
                     return callback(null, StatusCodes.BadUserAccessDenied);
                 }
+
+                if (!this.canUserWriteHistorizingAttribute(context)) {
+                    return callback(null, StatusCodes.BadHistoryOperationUnsupported);
+                }
+
                 // if the variable has no historizing in place reject
                 if (!this.getChildByName("HA Configuration")) {
                     return callback(null, StatusCodes.BadNotSupported);
@@ -1227,11 +1259,16 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
                 const dataValue = new DataValue({ statusCode: StatusCodes.BadNotReadable });
                 innerCallback(null, dataValue);
             };
-        } else if (!this.isUserReadable(context)) {
+        } else if (!this.checkPermissionPrivate(context, PermissionType.Read)) {
             func = (innerCallback: (err: Error | null, dataValue: DataValue) => void) => {
                 const dataValue = new DataValue({ statusCode: StatusCodes.BadUserAccessDenied });
                 innerCallback(null, dataValue);
             };
+        } else if (!this.isUserReadable(context)) {
+            func = (innerCallback: (err: Error | null, dataValue: DataValue) => void) => {
+                const dataValue = new DataValue({ statusCode: StatusCodes.BadNotReadable });
+                innerCallback(null, dataValue);
+            };
         } else {
             func = typeof this.refreshFunc === "function" ? this.asyncRefresh.bind(this, new Date()) : readImmediate;
         }
@@ -1560,12 +1597,19 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
         continuationData: ContinuationData,
         callback: CallbackT<HistoryReadResult>
     ): void {
-        if (!this.canUserReadHistory(context)) {
+
+        if (!this.checkPermissionPrivate(context, PermissionType.ReadHistory)) {
             const result = new HistoryReadResult({
                 statusCode: StatusCodes.BadUserAccessDenied
             });
             callback(null, result);
         }
+        if (!this.canUserReadHistory(context)) {
+            const result = new HistoryReadResult({
+                statusCode: StatusCodes.BadHistoryOperationUnsupported
+            });
+            callback(null, result);
+        }
         const result = new HistoryReadResult({
             statusCode: StatusCodes.BadHistoryOperationUnsupported
         });
@@ -1634,8 +1678,7 @@ export class UAVariableImpl extends BaseNodeImpl implements UAVariable {
             const nbElements = dataValue.value.dimensions.reduce((acc, x) => acc * x, 1);
             if (dataValue.value.value.length !== 0 && dataValue.value.value.length !== nbElements) {
                 throw new Error(
-                    `Internal Error: matrix dimension doesn't match the number of element in the array : ${dataValue.toString()} "\n expecting ${nbElements} elements but got ${
-                        dataValue.value.value.length
+                    `Internal Error: matrix dimension doesn't match the number of element in the array : ${dataValue.toString()} "\n expecting ${nbElements} elements but got ${dataValue.value.value.length
                     }`
                 );
             }
@@ -1984,7 +2027,7 @@ function _Variable_bind_with_timestamped_get(
             errorLog(
                 chalk.red(" Bind variable error: "),
                 " the timestamped_get function must return a DataValue or a Promise<DataValue>" +
-                    "\n value_check.constructor.name ",
+                "\n value_check.constructor.name ",
                 dataValue_verify ? dataValue_verify.constructor.name : "null"
             );
 
@@ -2179,7 +2222,7 @@ export interface UAVariableImplT<T, DT extends DataType> extends UAVariableImpl,
     writeValue(context: ISessionContext, dataValue: DataValueT<T, DT>, callback: StatusCodeCallback): void;
     writeValue(context: ISessionContext, dataValue: DataValueT<T, DT>, indexRange?: NumericRange | null): Promise<StatusCode>;
 }
-export class UAVariableImplT<T, DT extends DataType> extends UAVariableImpl {}
+export class UAVariableImplT<T, DT extends DataType> extends UAVariableImpl { }
 // x TO DO
 // require("./data_access/ua_variable_data_access");
 // require("./historical_access/ua_variable_history");