node-opcua-address-space 2.51.0

package/src/nodeset_tools/typedictionary_to_xml.ts

@@ -0,0 +1,175 @@
+import { IAddressSpace, INamespace, UADataType } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { StructureDefinition, EnumDefinition, EnumDescription } from "node-opcua-types";
+import { NodeId } from "node-opcua-nodeid";
+import { AddressSpacePrivate } from "../address_space_private";
+import { XmlWriter } from "../../source/xml_writer";
+import { UADataTypeImpl } from "../ua_data_type_impl";
+import { NamespacePrivate } from "../namespace_private";
+import { constructNamespaceDependency } from "./construct_namespace_dependency";
+
+// tslint:disable-next-line: no-var-requires
+const XMLWriter = require("xml-writer");
+
+function dumpEnumeratedType(xw: XmlWriter, e: EnumDefinition, name: string): void {
+    xw.startElement("opc:EnumeratedType");
+    xw.writeAttribute("Name", name);
+    xw.writeAttribute("LengthInBits", "32");
+    for (const f of e.fields || []) {
+        xw.startElement("opc:EnumeratedValue");
+        xw.writeAttribute("Name", f.name!);
+        assert(f.value[0] === 0, "unsuppor 64 bit value !");
+        xw.writeAttribute("Value", f.value[1].toString());
+        xw.endElement();
+    }
+    xw.endElement();
+}
+function buildXmlName(addressSpace: AddressSpacePrivate, map: { [key: number]: string }, nodeId: NodeId) {
+    if (NodeId.sameNodeId(nodeId, NodeId.nullNodeId)) {
+        return "ua:ExtensionObject";
+    }
+    const node = addressSpace.findNode(nodeId);
+    // istanbull ignore next
+    if (!node) {
+        throw new Error("Cannot find Node for" + nodeId?.toString());
+    }
+    const typeName = node.browseName.name!;
+    const prefix = node.nodeId.namespace === 0 ? (node.nodeId.value <= 15 ? "opc" : "ua") : map[node.nodeId.namespace];
+    return prefix + ":" + (typeName === "Structure" && prefix === "ua" ? "ExtensionObject" : typeName);
+}
+function dumpDataTypeStructure(
+    xw: XmlWriter,
+    addressSpace: IAddressSpace,
+    map: { [key: number]: string },
+    structureDefinition: StructureDefinition,
+    name: string,
+    doc?: string
+) {
+    xw.startElement("opc:StructuredType");
+    xw.writeAttribute("Name", name);
+    xw.writeAttribute("BaseType", buildXmlName(addressSpace as AddressSpacePrivate, map, structureDefinition.baseDataType));
+
+    if (doc) {
+        xw.startElement("opc:Documentation");
+        xw.text(doc);
+        xw.endElement();
+    }
+    let optionalsCount = 0;
+    for (const f of structureDefinition.fields || []) {
+        if (f.isOptional) {
+            xw.startElement("opc:Field");
+            xw.writeAttribute("Name", f.name + "Specified");
+            xw.writeAttribute("TypeName", "opc:Bit");
+            xw.endElement();
+            optionalsCount++;
+        }
+    }
+
+    // istanbul ignore next
+    if (optionalsCount >= 32) {
+        throw new Error("Too many optionals fields");
+    }
+
+    if (optionalsCount) {
+        /*
+                const padding = optionalsCount <= 8
+                    ? (8 - optionalsCount)
+                    : (optionalsCount <= 16)
+                        ? (16 - optionalsCount)
+                        : (32 - optionalsCount)
+                    ;
+        */
+        const padding = 32 - optionalsCount;
+        if (padding !== 0) {
+            xw.startElement("opc:Field");
+            xw.writeAttribute("Name", "Reserved1");
+            xw.writeAttribute("TypeName", "opc:Bit");
+            xw.writeAttribute("Length", padding.toString());
+            xw.endElement();
+        }
+    }
+    for (const f of structureDefinition.fields || []) {
+        const isArray = f.valueRank > 0 && f.arrayDimensions?.length;
+
+        if (isArray) {
+            xw.startElement("opc:Field");
+            xw.writeAttribute("Name", "NoOf" + f.name!);
+            xw.writeAttribute("TypeName", "opc:Int32");
+            if (f.isOptional) {
+                xw.writeAttribute("SwitchField", f.name + "Specified");
+            }
+            xw.endElement();
+        }
+
+        xw.startElement("opc:Field");
+        xw.writeAttribute("Name", f.name!);
+
+        const typeName = buildXmlName(addressSpace as AddressSpacePrivate, map, f.dataType);
+        xw.writeAttribute("TypeName", typeName);
+        if (isArray) {
+            xw.writeAttribute("LengthField", "NoOf" + f.name!);
+        }
+        if (f.isOptional) {
+            xw.writeAttribute("SwitchField", f.name + "Specified");
+        }
+        xw.endElement();
+    }
+    xw.endElement();
+}
+
+function dumpDataTypeToBSD(xw: XmlWriter, dataType: UADataType, map: { [key: number]: string }) {
+    const addressSpace = dataType.addressSpace;
+
+    const name: string = dataType.browseName.name!;
+
+    const def = (<UADataTypeImpl>dataType)._getDefinition(false);
+    if (def instanceof StructureDefinition) {
+        dumpDataTypeStructure(xw, addressSpace, map, def, name);
+    }
+    if (def instanceof EnumDefinition) {
+        dumpEnumeratedType(xw, def, name);
+    }
+}
+
+function shortcut(namespace: INamespace) {
+    return "n" + namespace.index;
+}
+export function dumpToBSD(namespace: NamespacePrivate) {
+    const dependency: INamespace[] = constructNamespaceDependency(namespace);
+
+    const addressSpace = namespace.addressSpace;
+
+    const xw = new XMLWriter(true);
+
+    xw.startDocument({ encoding: "utf-8", version: "1.0" });
+
+    xw.startElement("opc:TypeDictionary");
+
+    xw.writeAttribute("xmlns:opc", "http://opcfoundation.org/BinarySchema/");
+    xw.writeAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
+    xw.writeAttribute("xmlns:ua", "http://opcfoundation.org/UA/");
+
+    const map: { [key: number]: string } = {};
+
+    for (const dependantNamespace of dependency) {
+        const namespaceIndex = dependantNamespace.index;
+        if (namespaceIndex === 0) {
+            //|| namespaceIndex === namespace.index) {
+            continue;
+        }
+        const ns = shortcut(dependantNamespace);
+        map[namespaceIndex] = ns;
+        xw.writeAttribute(`xmlns:${ns}`, dependantNamespace.namespaceUri);
+    }
+
+    xw.writeAttribute("DefaultByteOrder", "LittleEndian");
+    xw.writeAttribute("TargetNamespace", namespace.namespaceUri);
+
+    for (const dataType of namespace._dataTypeIterator()) {
+        dumpDataTypeToBSD(xw, dataType, map);
+    }
+    xw.endElement();
+    xw.endDocument();
+
+    return xw.toString();
+}

package/src/reference_impl.ts

@@ -0,0 +1,169 @@
+/**
+ * @module node-opcua-address-space
+ */
+// tslint:disable:no-console
+import * as chalk from "chalk";
+import { AddReferenceOpts, UAReference, BaseNode, UAReferenceType } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { coerceNodeId, NodeId, NodeIdLike, sameNodeId } from "node-opcua-nodeid";
+import * as utils from "node-opcua-utils";
+
+export function isNodeIdString(str: string): boolean {
+    assert(typeof str === "string");
+    return str.substring(0, 2) === "i=" || str.substring(0, 3) === "ns=";
+}
+
+function is_valid_reference(ref: UAReference): boolean {
+    const hasRequestedProperties =
+        Object.prototype.hasOwnProperty.call(ref,"referenceType") && Object.prototype.hasOwnProperty.call(ref,"nodeId") && !utils.isNullOrUndefined(ref.isForward);
+
+    if (!hasRequestedProperties) {
+        return false;
+    }
+    assert(ref.referenceType instanceof NodeId);
+    assert(!ref.node || sameNodeId(ref.node.nodeId, ref.nodeId));
+    // xx assert(!ref.referenceTypeName || typeof ref.referenceTypeName === "string");
+    // xx // referenceType shall no be a nodeId string (this could happen by mistake)
+    // xx assert(!isNodeIdString(ref.referenceType));
+    return true;
+}
+
+/**
+ * @private
+ *
+ * @example
+ *       ---- some text ----->
+ */
+function _arrow(text: string, length: number, isForward: boolean): string {
+    length = Math.max(length, text.length + 8);
+    const nb = Math.floor((length - text.length - 2) / 2);
+    const h = Array(nb).join("-");
+
+    const extra = text.length % 2 === 1 ? "-" : "";
+
+    if (isForward) {
+        return extra + h + " " + text + " " + h + "> ";
+    }
+    return "<" + h + " " + text + " " + h + extra + " ";
+}
+
+function _w(str: string, width: number): string {
+    return (str + "                                         ").substr(0, width);
+}
+
+function _localCoerceToNodeID(nodeIdLike: string | NodeId | BaseNode) {
+    if ((nodeIdLike as any).nodeId) {
+        return (nodeIdLike as BaseNode).nodeId;
+    }
+    return coerceNodeId(nodeIdLike);
+}
+
+export interface MinimalistAddressSpace {
+    findNode(nodeId: NodeIdLike): BaseNode | null;
+
+    findReferenceType(referenceTypeId: NodeIdLike | UAReferenceType, namespaceIndex?: number): UAReferenceType | null;
+}
+
+export function resolveReferenceNode(addressSpace: MinimalistAddressSpace, reference: UAReference): BaseNode {
+    const _reference = reference as ReferenceImpl;
+    if (!_reference.node) {
+        _reference.node = addressSpace.findNode(reference.nodeId)!;
+    }
+    return _reference.node;
+}
+
+export function resolveReferenceType(addressSpace: MinimalistAddressSpace, reference: UAReference): UAReferenceType {
+    const _reference = reference as ReferenceImpl;
+    if (!_reference._referenceType) {
+        if (!_reference.referenceType) {
+            console.log(chalk.red("ERROR MISSING reference"), reference);
+        }
+        _reference._referenceType = addressSpace.findReferenceType(reference.referenceType)!;
+    }
+    return _reference._referenceType;
+}
+
+/**
+ * @class Reference
+ * @param options.referenceType {NodeId}
+ * @param options.nodeId        {NodeId}
+ * @param options.isForward     {Boolean}
+ * @constructor
+ */
+export class ReferenceImpl implements UAReference {
+    public static resolveReferenceNode(addressSpace: MinimalistAddressSpace, reference: UAReference): BaseNode {
+        return resolveReferenceNode(addressSpace, reference);
+    }
+
+    public static resolveReferenceType(addressSpace: MinimalistAddressSpace, reference: UAReference): UAReferenceType {
+        return resolveReferenceType(addressSpace, reference);
+    }
+
+    public nodeId: NodeId;
+    public referenceType: NodeId;
+    public _referenceType?: UAReferenceType;
+    public readonly isForward: boolean;
+
+    public node?: BaseNode;
+
+    // cache
+    private __hash?: string;
+
+    constructor(options: AddReferenceOpts | UAReference) {
+        assert(options.referenceType instanceof NodeId);
+        assert(options.nodeId instanceof NodeId);
+
+        this.referenceType = coerceNodeId(options.referenceType);
+        this.isForward = options.isForward === undefined ? true : !!options.isForward;
+        this.nodeId = _localCoerceToNodeID(options.nodeId);
+
+        // optional to speed up when AddReferenceOpts is in fact a Reference !
+        this._referenceType = (options as any)._referenceType;
+        this.node = (options as any).node;
+
+        assert(is_valid_reference(this));
+    }
+
+    /**
+     * turn reference into a arrow :   ---- ReferenceType --> [NodeId]
+     * @method toString
+     * @return {String}
+     */
+    public toString(options?: { addressSpace?: any }): string {
+        let infoNode = _w(this.nodeId.toString(), 24);
+        let refType = this.referenceType.toString();
+
+        if (options && options.addressSpace) {
+            const node = options.addressSpace.findNode(this.nodeId);
+            infoNode = "[" + infoNode + "]" + _w(node?.browseName.toString(), 40);
+
+            const ref = options.addressSpace.findReferenceType(this.referenceType);
+            const refNode = options.addressSpace.findNode(ref.nodeId);
+            refType = refNode.browseName.toString() + " (" + ref.nodeId.toString() + ")";
+        }
+        return _arrow(refType, 40, this.isForward) + infoNode;
+    }
+
+    /**
+     * @internal
+     */
+    get hash(): string {
+        if (!this.__hash) {
+            this.__hash = (this.isForward ? "" : "!") + this.referenceType.toString() + "-" + this.nodeId.toString();
+        }
+        return this.__hash;
+    }
+
+    /**
+     * @internal
+     */
+    public dispose() {
+        this.__hash = undefined;
+        this.node = undefined;
+        /*
+        this._referenceType = null;
+        this.nodeId = null as NodeId;
+        this.referenceType = null as NodeId;
+        */
+    }
+}

package/src/role_permissions.ts

@@ -0,0 +1,6 @@
+import { RolePermissionType, RolePermissionTypeOptions } from "node-opcua-types";
+
+export function coerceRolePermissions(rolePermissions: RolePermissionTypeOptions[] | undefined): RolePermissionType[] | undefined {
+    if (!rolePermissions) return undefined;
+    return rolePermissions.map((rp) => new RolePermissionType(rp));
+}