node-opcua-address-space 2.180.0 → 2.181.1

package/impl/nodeset_tools/construct_namespace_dependency.ts

@@ -0,0 +1,381 @@
+import type { IAddressSpace, INamespace, UADataType, UAVariable, UAVariableType } from "node-opcua-address-space-base";
+import assert from "node-opcua-assert";
+import { DataType } from "node-opcua-basic-types";
+import { NodeClass } from "node-opcua-data-model";
+import { make_debugLog, make_warningLog } from "node-opcua-debug";
+import type { ExtensionObject } from "node-opcua-extension-object";
+import type { StructureField } from "node-opcua-types";
+import { Variant } from "node-opcua-variant";
+import type { TranslationTable } from "../../api/xml_writer.js";
+import type { BaseNodeImpl } from "../base_node_impl.js";
+import type { NamespacePrivate } from "../namespace_private.js";
+import { ReferenceImpl } from "../reference_impl.js";
+import type { UAVariableImpl } from "../ua_variable_impl.js";
+
+const warningLog = make_warningLog("construct_namespace_dependency");
+const _debugLog = make_debugLog("construct_namespace_dependency");
+
+interface RequiredModel {
+    requiredNamespaceIndexes: number[];
+    nbTypes: number;
+}
+/** @internal */
+export function _recomputeRequiredModelsFromTypes(namespace: INamespace, cache?: Map<number, RequiredModel>): RequiredModel {
+    if (namespace.index === 0) {
+        return { requiredNamespaceIndexes: [], nbTypes: 1 };
+    }
+    if (cache) {
+        if (cache.has(namespace.index)) {
+            return cache.get(namespace.index) as RequiredModel;
+        }
+    }
+    const requiredNamespaceIndexes = [0];
+    const requiredModelsSet = new Set<number>();
+    requiredModelsSet.add(0);
+    const namespace_ = namespace as NamespacePrivate;
+    let nbTypes = 0;
+    const addressSpace = namespace.addressSpace;
+    const types = [NodeClass.VariableType, NodeClass.ObjectType, NodeClass.ReferenceType, NodeClass.DataType];
+    const instances = [NodeClass.Variable, NodeClass.Object, NodeClass.Method];
+
+    const consider = (requiredModel: number) => {
+        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
+            requiredModelsSet.add(requiredModel);
+            requiredNamespaceIndexes.push(requiredModel);
+        }
+    };
+
+    const _visitedDataType: Set<string> = new Set<string>();
+
+    function exploreDataTypeField(field: StructureField) {
+        const dataType = field.dataType;
+        const namespaceIndex = dataType.namespace;
+        consider(namespaceIndex);
+        const dataTypeNode = addressSpace.findDataType(field.dataType);
+        if (dataTypeNode) {
+            exploreDataTypes(dataTypeNode);
+        }
+    }
+    function exploreDataTypes(dataTypeNode: UADataType): void {
+        if (!dataTypeNode) {
+            return;
+        }
+        const dataType = dataTypeNode.nodeId;
+        if (_visitedDataType.has(dataType.toString())) {
+            return;
+        }
+        // c8 ignore next
+        if (dataTypeNode.nodeClass !== NodeClass.DataType) {
+            warningLog("exploreDataTypes! ignoring ", dataTypeNode.toString());
+            return;
+        }
+
+        const namespaceIndex = dataType.namespace;
+        consider(namespaceIndex);
+        // mark the dataType as visited *before* exploring its fields: a structure may refer to
+        // itself (directly or through a cycle), and marking it afterwards would recurse forever
+        _visitedDataType.add(dataType.toString());
+        if (dataTypeNode.isStructure()) {
+            const definition = dataTypeNode.getStructureDefinition();
+            for (const field of definition.fields || []) {
+                exploreDataTypeField(field);
+            }
+        }
+    }
+
+    function exploreExtensionObject(e: ExtensionObject) {
+        assert(!(e instanceof Variant));
+        const nodeId = e.schema.encodingDefaultXml || e.schema.dataTypeNodeId || e.schema.dataTypeNodeId;
+        consider(nodeId.namespace);
+        // c8 ignore next
+        if (e.schema.dataTypeNodeId.isEmpty()) {
+            warningLog("Cannot find dataTypeNodeId for ", e.schema.name);
+        }
+        const d = addressSpace.findNode(e.schema.dataTypeNodeId) as UADataType | null;
+        // c8 ignore next
+        if (!d) return;
+        exploreDataTypes(d);
+    }
+
+    function exploreDataValue(uaVariable: UAVariableImpl) {
+        if (uaVariable.getBasicDataType() !== DataType.ExtensionObject) {
+            return;
+        }
+        if (!uaVariable.$dataValue) return;
+        const variant = uaVariable.$dataValue.value;
+        if (!variant) return;
+        const value: unknown = variant.value;
+        if (!value) return;
+        if (Array.isArray(value)) {
+            (value as ExtensionObject[]).forEach(exploreExtensionObject);
+        } else {
+            exploreExtensionObject(value as ExtensionObject);
+        }
+    }
+    for (const node of namespace_.nodeIterator()) {
+        const isType = types.indexOf(node.nodeClass);
+        const isInstance = instances.indexOf(node.nodeClass);
+        if (isType !== -1) {
+            nbTypes++;
+            const superTypes = node.findReferencesAsObject("HasSubtype", false);
+            if (superTypes.length === 0) {
+                continue;
+            }
+            if (superTypes.length !== 1) {
+                continue;
+            }
+            const superType = superTypes[0];
+            if (superType.nodeId.namespace === 0) {
+                continue;
+            }
+            const requiredModel = superType.nodeId.namespace;
+            consider(requiredModel);
+        } else if (isInstance !== -1) {
+            if (node.nodeClass === NodeClass.Variable || node.nodeClass === NodeClass.VariableType) {
+                const dataTypeNodeId = (node as UAVariable | UAVariableType).dataType;
+                const dataTypeNode = addressSpace.findDataType(dataTypeNodeId);
+                if (dataTypeNode) {
+                    consider(dataTypeNode.nodeId.namespace);
+                } else {
+                    // c8 ignore next
+                    if (dataTypeNodeId.value !== 0) {
+                        warningLog("Warning: Cannot find dataType", dataTypeNodeId.toString());
+                    }
+                }
+                const nodeV = node as UAVariableImpl;
+                exploreDataValue(nodeV);
+            }
+
+            const typeDefinitions = node.findReferencesAsObject("HasTypeDefinition", true);
+            if (typeDefinitions.length === 0) {
+                continue;
+            }
+            if (typeDefinitions.length !== 1) {
+                continue;
+            }
+            const typeDefinition = typeDefinitions[0];
+            const requiredModel = typeDefinition.nodeId.namespace;
+            consider(requiredModel);
+        }
+    }
+
+    const result: RequiredModel = { requiredNamespaceIndexes: requiredNamespaceIndexes, nbTypes: nbTypes };
+    if (cache) {
+        cache.set(namespace.index, result);
+    }
+    return result;
+}
+
+/** @internal */
+export function _recomputeRequiredModelsFromTypes2(namespace: INamespace, cache?: Map<number, RequiredModel>): RequiredModel {
+    const addressSpace = namespace.addressSpace;
+
+    const { requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespace, cache);
+
+    const set = new Set<number>(requiredNamespaceIndexes);
+    const pass2: number[] = [];
+    for (const r of requiredNamespaceIndexes) {
+        if (r === 0) {
+            pass2.push(0);
+            continue;
+        }
+        const namespaces = _recomputeRequiredModelsFromTypes(addressSpace.getNamespace(r), cache);
+        for (const nIndex of namespaces.requiredNamespaceIndexes) {
+            if (!set.has(nIndex)) {
+                set.add(nIndex);
+                pass2.push(nIndex);
+            }
+        }
+        pass2.push(r);
+    }
+
+    return { requiredNamespaceIndexes: pass2, nbTypes: 0 };
+}
+
+/** @internal */
+export function _getCompleteRequiredModelsFromValuesAndReferences(
+    namespace: INamespace,
+    priorityList: number[],
+    cache?: Map<number, RequiredModel>
+): number[] {
+    const namespace_ = namespace as NamespacePrivate;
+
+    const thisPriority = priorityList[namespace.index];
+
+    const requiredNamespaceIndexes = _recomputeRequiredModelsFromTypes2(namespace, cache).requiredNamespaceIndexes;
+    const requiredModelsSet: Set<number> = new Set<number>([...requiredNamespaceIndexes]);
+
+    const consider = (requiredModel: number) => {
+        if (requiredModel !== namespace.index && !requiredModelsSet.has(requiredModel)) {
+            requiredModelsSet.add(requiredModel);
+            requiredNamespaceIndexes.push(requiredModel);
+        }
+    };
+
+    const addressSpace = namespace.addressSpace;
+    const nonHierarchicalReferencesType = addressSpace.findReferenceType("NonHierarchicalReferences");
+
+    //const maxIndex = Math.max(...requiredNamespaceIndexes);
+    for (const node of namespace_.nodeIterator()) {
+        const references = (<BaseNodeImpl>node).allReferences();
+        for (const reference of references) {
+            // check referenceId
+            // resolved here: a reference nobody has looked at since the load carries only the NodeId of its type
+            const namespaceIndexOfReferenceType = ReferenceImpl.resolveReferenceType(addressSpace, reference)?.nodeId.namespace;
+            if (namespaceIndexOfReferenceType !== 0 && namespaceIndexOfReferenceType !== namespace.index) {
+                const refPriority = priorityList[namespaceIndexOfReferenceType];
+                if (refPriority <= thisPriority) {
+                    consider(namespaceIndexOfReferenceType);
+                }
+            }
+            const namespaceIndexOfTargetNode = reference.nodeId.namespace;
+            if (namespaceIndexOfTargetNode !== 0 && namespaceIndexOfTargetNode !== namespace.index) {
+                const refPriority = priorityList[namespaceIndexOfTargetNode];
+                if (refPriority <= thisPriority) {
+                    consider(namespaceIndexOfTargetNode);
+                } else {
+                    const referenceType = ReferenceImpl.resolveReferenceType(addressSpace, reference);
+                    if (referenceType) {
+                        // For forward NonHierarchicalReferences (e.g. HasInterface),
+                        // always include the target namespace as a dependency
+                        // regardless of priority, since the current node owns
+                        // this relationship.
+                        if (
+                            reference.isForward &&
+                            nonHierarchicalReferencesType &&
+                            referenceType.isSubtypeOf(nonHierarchicalReferencesType)
+                        ) {
+                            consider(namespaceIndexOfTargetNode);
+                        }
+                        // For inverse HierarchicalReferences (e.g. Organizes),
+                        // always include the target namespace as a dependency
+                        // regardless of priority, since the reference is
+                        // stored on this node (organizedBy pattern).
+                        const hierarchicalReferencesType = addressSpace.findReferenceType("HierarchicalReferences");
+                        if (
+                            !reference.isForward &&
+                            hierarchicalReferencesType &&
+                            referenceType.isSubtypeOf(hierarchicalReferencesType)
+                        ) {
+                            consider(namespaceIndexOfTargetNode);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return requiredNamespaceIndexes;
+}
+
+/**
+ *
+ * @param namespace
+ * @returns the order
+ *
+ *      ---
+ *  ua, own , di  => 0 , 2,  1
+ *
+ *      ---
+ *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3, 1
+ *
+ *                           ---
+ *  ua, own , di , kitchen , own2,  adi  => 0 , 2,  3,  5, 1
+ */
+export function constructNamespacePriorityTable(addressSpace: IAddressSpace): { loadingOrder: number[]; priorityTable: number[] } {
+    // - Namespace 0 will always be 0
+    // - Namespace with requiredModels are considered to be companion specification,
+    //   so RequireModel will be used to determine the order
+    // - Namespaces with no requiredModel are more complicated:
+    //
+    //   we study ObjectType,ReferenceType, DataType and VariableType
+    //   to find strong dependencies between namespace.
+    //
+    //   if the namespace doesn't define ObjectType,ReferenceType, DataType and VariableType
+    //   it will be considered as instance namespaces and will added at the end
+    //   in the same order as they appear,
+    const namespaces = addressSpace.getNamespaceArray();
+
+    const loadingOrder: number[] = [0];
+
+    const map = new Map<number, { nbTypes: number; requiredNamespaceIndexes: number[]; namespace: INamespace }>();
+    for (let i = 0; i < namespaces.length; i++) {
+        const { nbTypes, requiredNamespaceIndexes } = _recomputeRequiredModelsFromTypes(namespaces[i], map);
+        map.set(namespaces[i].index, { nbTypes, requiredNamespaceIndexes, namespace: namespaces[i] });
+    }
+
+    const visited = new Set<number>();
+    visited.add(0);
+
+    const h = (n: INamespace) => {
+        if (visited.has(n.index)) {
+            return;
+        }
+        visited.add(n.index);
+        const data = map.get(n.index);
+        if (!data) return;
+        const { requiredNamespaceIndexes } = data;
+        for (const r of requiredNamespaceIndexes || []) {
+            h(namespaces[r]);
+        }
+        loadingOrder.push(n.index);
+    };
+
+    for (let i = 0; i < namespaces.length; i++) {
+        const entry = map.get(i);
+        if (entry?.nbTypes) {
+            h(namespaces[i]);
+        }
+    }
+    for (let i = 0; i < namespaces.length; i++) {
+        const entry = map.get(i);
+        if (!entry?.nbTypes) {
+            h(namespaces[i]);
+        }
+    }
+
+    const priorityTable: number[] = [];
+    for (let i = 0; i < loadingOrder.length; i++) {
+        const namespaceIndex = loadingOrder[i];
+        assert(namespaceIndex !== -1);
+        priorityTable[namespaceIndex] = i;
+    }
+
+    return { loadingOrder, priorityTable };
+}
+
+const _doDebug = false;
+export function constructNamespaceDependency(namespace: INamespace, priorityTable?: number[]): INamespace[] {
+    const addressSpace = namespace.addressSpace;
+    priorityTable = priorityTable || constructNamespacePriorityTable(addressSpace).priorityTable;
+    const requiredNamespaceIndexes = _getCompleteRequiredModelsFromValuesAndReferences(namespace, priorityTable);
+    return [...requiredNamespaceIndexes.map((r) => addressSpace.getNamespace(r)), namespace];
+}
+
+/**
+ * @private
+ * @internal
+ */
+export function _constructNamespaceTranslationTable(dependency: INamespace[], exportedNamespace: INamespace): TranslationTable {
+    const translationTable: TranslationTable = new Map();
+    if (!dependency || dependency.length === 0) {
+        translationTable.set(0, 0);
+        return translationTable;
+        // throw new Error("Cannot constructNamespaceTranslationTable on empty dependency");
+    }
+    assert(dependency[0].namespaceUri === "http://opcfoundation.org/UA/");
+
+    let counter = 0;
+    translationTable.set(dependency[0].index, counter++);
+    //
+    if (exportedNamespace) {
+        translationTable.set(exportedNamespace.index, counter++);
+    }
+    for (let i = 1; i < dependency.length; i++) {
+        const dep = dependency[i];
+        if (exportedNamespace && exportedNamespace === dep) {
+            continue;
+        }
+        translationTable.set(dep.index, counter++);
+    }
+    return translationTable;
+}

package/impl/nodeset_tools/dump_to_bsd.ts

@@ -0,0 +1,210 @@
+import type { IAddressSpace, INamespace, UADataType } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { type INodeId, NodeId, NodeIdType } from "node-opcua-nodeid";
+import { EnumDefinition, StructureDefinition } from "node-opcua-types";
+import XMLWriter from "xml-writer";
+import type { Namespace } from "../../api/namespace.js";
+import type { XmlWriter } from "../../api/xml_writer.js";
+import type { AddressSpacePrivate } from "../address_space_private.js";
+import type { NamespacePrivate } from "../namespace_private.js";
+import { constructNamespaceDependency } from "./construct_namespace_dependency.js";
+
+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, "unsupported 64 bit value !");
+        xw.writeAttribute("Value", f.value[1].toString());
+        xw.endElement();
+    }
+    xw.endElement();
+}
+function buildXmlName(addressSpace: AddressSpacePrivate, map: Map<number, string>, nodeId: NodeId): string {
+    if (NodeId.sameNodeId(nodeId, NodeId.nullNodeId)) {
+        return "ua:ExtensionObject";
+    }
+    const node = addressSpace.findNode(nodeId);
+    // c8 ignore next
+    if (!node) {
+        throw new Error(`Cannot find Node for${nodeId?.toString()}`);
+    }
+    const typeName = node.browseName.name || "";
+
+    const n = node.nodeId as INodeId;
+    const prefix =
+        n.identifierType === NodeIdType.NUMERIC && n.namespace === 0
+            ? n.value <= 15
+                ? "opc"
+                : "ua"
+            : map.get(node.nodeId.namespace);
+    return `${prefix}:${typeName === "Structure" && prefix === "ua" ? "ExtensionObject" : typeName}`;
+}
+
+function dumpDataTypeStructure(
+    xw: XmlWriter,
+    addressSpace: IAddressSpace,
+    map: Map<number, string>,
+    structureDefinition: StructureDefinition,
+    structureDefinitionBase: StructureDefinition | undefined | null,
+    name: string,
+    doc?: string
+): void {
+    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();
+    }
+
+    const fields = structureDefinition.fields || [];
+    // get base class
+    const nbFieldsInBase = structureDefinitionBase ? structureDefinitionBase.fields?.length || 0 : 0;
+
+    let optionalsCount = 0;
+    for (let index = nbFieldsInBase; index < fields.length; index++) {
+        const f = fields[index];
+        if (f.isOptional) {
+            xw.startElement("opc:Field");
+            xw.writeAttribute("Name", `${f.name}Specified`);
+            xw.writeAttribute("TypeName", "opc:Bit");
+            xw.endElement();
+            optionalsCount++;
+        }
+    }
+
+    // c8 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 (let index = nbFieldsInBase; index < fields.length; index++) {
+        const f = fields[index];
+
+        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: Map<number, string>) {
+    const addressSpace = dataType.addressSpace;
+
+    const name: string = dataType.browseName.name || "";
+
+    const definition = dataType.getDefinition();
+    if (definition instanceof StructureDefinition) {
+        const structureDefinitionBase = dataType.subtypeOfObj?.getStructureDefinition();
+        dumpDataTypeStructure(xw, addressSpace, map, definition, structureDefinitionBase, name);
+    }
+    if (definition instanceof EnumDefinition) {
+        dumpEnumeratedType(xw, definition, name);
+    }
+}
+
+function shortcut(namespace: INamespace) {
+    return `n${namespace.index}`;
+}
+/**
+ * Takes the published Namespace, not NamespacePrivate.
+ *
+ * This function is exported from the package entry, and NamespacePrivate is not: asking for
+ * one made it impossible to call from outside, since there is no public way to obtain the
+ * argument. The data types it walks now come from the published iterator; the narrowing that
+ * remains is for constructNamespaceDependency, which is internal.
+ */
+export function dumpToBSD(namespace: Namespace): string {
+    const _namespace = namespace as unknown as NamespacePrivate;
+    const dependency: INamespace[] = constructNamespaceDependency(_namespace);
+
+    const _addressSpace = _namespace.addressSpace;
+
+    const xw: XmlWriter = new XMLWriter(true);
+
+    //xx 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/");
+    xw.writeAttribute("xmlns:tns", namespace.namespaceUri);
+
+    const map: Map<number, string> = new Map();
+
+    map.set(namespace.index, "tns");
+
+    for (const dependantNamespace of dependency) {
+        const namespaceIndex = dependantNamespace.index;
+        if (namespaceIndex === 0 || namespaceIndex === namespace.index) {
+            continue;
+        }
+        const ns = shortcut(dependantNamespace);
+        map.set(namespaceIndex, ns);
+        xw.writeAttribute(`xmlns:${ns}`, dependantNamespace.namespaceUri);
+    }
+
+    xw.writeAttribute("DefaultByteOrder", "LittleEndian");
+    xw.writeAttribute("TargetNamespace", namespace.namespaceUri);
+
+    // <opc:Import Namespace="http://opcfoundation.org/UA/"/>
+    for (const dependantNamespace of dependency) {
+        if (dependantNamespace.index === namespace.index) {
+            continue;
+        }
+        xw.startElement("opc:Import").writeAttribute("Namespace", dependantNamespace.namespaceUri).endElement();
+    }
+    //
+    for (const dataType of namespace.dataTypeIterator()) {
+        dumpDataTypeToBSD(xw, dataType, map);
+    }
+    xw.endElement();
+    //    xw.endDocument();
+
+    return xw.toString();
+}