node-opcua-client-dynamic-extension-object 2.51.0

package/source/convert_data_type_definition_to_structuretype_schema.ts

@@ -0,0 +1,326 @@
+import { assert } from "node-opcua-assert";
+import { AttributeIds, BrowseDirection, makeResultMask, NodeClassMask } from "node-opcua-data-model";
+import { DataValue } from "node-opcua-data-value";
+import { make_debugLog } from "node-opcua-debug";
+import { DataTypeFactory, EnumerationDefinitionSchema, FieldCategory, FieldInterfaceOptions, getBuildInType, StructuredTypeSchema, TypeDefinition } from "node-opcua-factory";
+import { NodeId, makeExpandedNodeId, resolveNodeId } from "node-opcua-nodeid";
+import { browseAll, BrowseDescriptionLike, IBasicSession } from "node-opcua-pseudo-session";
+import { StatusCodes } from "node-opcua-status-code";
+import { EnumDefinition, DataTypeDefinition, StructureDefinition, StructureType } from "node-opcua-types";
+//
+import { _findEncodings } from "./private/find_encodings";
+
+
+const debugLog = make_debugLog(__filename);
+
+async function findSuperType(session: IBasicSession, dataTypeNodeId: NodeId): Promise<NodeId> {
+    const nodeToBrowse3: BrowseDescriptionLike = {
+        browseDirection: BrowseDirection.Inverse,
+        includeSubtypes: false,
+        nodeClassMask: NodeClassMask.DataType,
+        nodeId: dataTypeNodeId,
+        referenceTypeId: resolveNodeId("HasSubtype"),
+        resultMask: makeResultMask("NodeId | ReferenceType | BrowseName | NodeClass")
+    };
+    const result3 = await browseAll(session, nodeToBrowse3);
+
+    /* istanbul ignore next */
+    if (result3.statusCode !== StatusCodes.Good) {
+        throw new Error("Cannot find superType for " + dataTypeNodeId.toString());
+    }
+    result3.references = result3.references || [];
+
+    /* istanbul ignore next */
+    if (result3.references.length !== 1) {
+        console.log(result3.toString());
+        throw new Error("Invalid dataType with more than one superType " + dataTypeNodeId.toString());
+    }
+    return result3.references[0].nodeId;
+}
+async function findDataTypeCategory(
+    session: IBasicSession,
+    cache: { [key: string]: CacheForFieldResolution },
+    dataTypeNodeId: NodeId
+): Promise<FieldCategory> {
+    const subTypeNodeId = await findSuperType(session, dataTypeNodeId);
+    debugLog("subTypeNodeId  of ", dataTypeNodeId.toString(), " is ", subTypeNodeId.toString());
+    const key = subTypeNodeId.toString();
+    if (cache[key]) {
+        return cache[key].category;
+    }
+    let category: FieldCategory;
+    if (subTypeNodeId.namespace === 0 && subTypeNodeId.value <= 29) {
+        // well known node ID !
+        switch (subTypeNodeId.value) {
+            case 22 /* Structure */:
+                category = FieldCategory.complex;
+                break;
+            case 29 /* Enumeration */:
+                category = FieldCategory.enumeration;
+                break;
+            default:
+                category = FieldCategory.basic;
+                break;
+        }
+        return category;
+    }
+    // must drill down ...
+    return await findDataTypeCategory(session, cache, subTypeNodeId);
+}
+
+async function findDataTypeBasicType(
+    session: IBasicSession,
+    cache: { [key: string]: CacheForFieldResolution },
+    dataTypeNodeId: NodeId
+): Promise<TypeDefinition> {
+    const subTypeNodeId = await findSuperType(session, dataTypeNodeId);
+
+    debugLog("subTypeNodeId  of ", dataTypeNodeId.toString(), " is ", subTypeNodeId.toString());
+
+    const key = subTypeNodeId.toString();
+    if (cache[key]) {
+        return cache[key].schema;
+    }
+    if (subTypeNodeId.namespace === 0 && subTypeNodeId.value < 29) {
+        switch (subTypeNodeId.value) {
+            case 22: /* Structure */
+            case 29 /* Enumeration */:
+                throw new Error("Not expecting Structure or Enumeration");
+            default:
+                break;
+        }
+        const nameDataValue: DataValue = await session.read({
+            attributeId: AttributeIds.BrowseName,
+            nodeId: subTypeNodeId
+        });
+        const name = nameDataValue.value.value.name!;
+        return getBuildInType(name);
+    }
+    // must drill down ...
+    return await findDataTypeBasicType(session, cache, subTypeNodeId);
+}
+
+
+export interface CacheForFieldResolution {
+    fieldTypeName: string;
+    schema: TypeDefinition;
+    category: FieldCategory;
+}
+
+async function readBrowseName(session: IBasicSession, nodeId: NodeId): Promise<string> {
+    const dataValue = await session.read({ nodeId, attributeId: AttributeIds.BrowseName });
+    if (dataValue.statusCode !== StatusCodes.Good) {
+        const message =
+            "cannot extract BrowseName of nodeId = " + nodeId.toString() + " statusCode = " + dataValue.statusCode.toString();
+        debugLog(message);
+        throw new Error(message);
+    }
+    return dataValue.value!.value.name;
+}
+
+async function resolveFieldType(
+    session: IBasicSession,
+    dataTypeNodeId: NodeId,
+    dataTypeFactory: DataTypeFactory,
+    cache: { [key: string]: CacheForFieldResolution }
+): Promise<CacheForFieldResolution | null> {
+    if (dataTypeNodeId.namespace === 0 && dataTypeNodeId.value === 22) {
+        return null;
+    }
+    const key = dataTypeNodeId.toString();
+    const v = cache[key];
+    if (v) {
+        return v;
+    }
+
+    if (dataTypeNodeId.value === 0) {
+        const v3: CacheForFieldResolution = {
+            category: FieldCategory.basic,
+            fieldTypeName: "Variant",
+            schema: dataTypeFactory.getSimpleType("Variant")
+        };
+        cache[key] = v3;
+        return v3;
+    }
+
+    const fieldTypeName = await readBrowseName(session, dataTypeNodeId);
+
+    let schema: TypeDefinition | undefined;
+    let category: FieldCategory = FieldCategory.enumeration;
+
+    if (dataTypeFactory.hasStructuredType(fieldTypeName!)) {
+        schema = dataTypeFactory.getStructuredTypeSchema(fieldTypeName);
+        category = FieldCategory.complex;
+    } else if (dataTypeFactory.hasSimpleType(fieldTypeName!)) {
+        category = FieldCategory.basic;
+        schema = dataTypeFactory.getSimpleType(fieldTypeName!);
+    } else if (dataTypeFactory.hasEnumeration(fieldTypeName!)) {
+        category = FieldCategory.enumeration;
+        schema = dataTypeFactory.getEnumeration(fieldTypeName!)!;
+    } else {
+        debugLog(" type " + fieldTypeName + " has not been seen yet, let resolve it");
+        category = await findDataTypeCategory(session, cache, dataTypeNodeId);
+        debugLog(" type " + fieldTypeName + " has not been seen yet, let resolve it => (category = ", category, " )");
+
+        switch (category) {
+            case FieldCategory.basic:
+                schema = await findDataTypeBasicType(session, cache, dataTypeNodeId);
+                /* istanbul ignore next */
+                if (!schema) {
+                    console.log("Cannot find basic type " + fieldTypeName);
+                }
+                break;
+            default:
+            case FieldCategory.enumeration:
+            case FieldCategory.complex:
+                const dataTypeDefinitionDataValue = await session.read({
+                    attributeId: AttributeIds.DataTypeDefinition,
+                    nodeId: dataTypeNodeId
+                });
+
+                /* istanbul ignore next */
+                if (dataTypeDefinitionDataValue.statusCode !== StatusCodes.Good) {
+                    throw new Error(" Cannot find dataType Definition ! with nodeId =" + dataTypeNodeId.toString());
+                }
+                const definition = dataTypeDefinitionDataValue.value.value;
+
+                if (category === FieldCategory.enumeration) {
+                    if (definition instanceof EnumDefinition) {
+                        const e = new EnumerationDefinitionSchema({
+                            enumValues: definition.fields,
+                            name: fieldTypeName
+                        });
+                        dataTypeFactory.registerEnumeration(e);
+
+                        schema = e;
+                    }
+                } else {
+                    schema = await convertDataTypeDefinitionToStructureTypeSchema(
+                        session,
+                        dataTypeNodeId,
+                        fieldTypeName,
+                        definition,
+                        dataTypeFactory,
+                        cache
+                    );
+                }
+                // xx const schema1 = dataTypeFactory.getStructuredTypeSchema(fieldTypeName);
+                break;
+        }
+    }
+
+    /* istanbul ignore next */
+    if (!schema) {
+        throw new Error(
+            "expecting a schema here fieldTypeName=" + fieldTypeName + " " + dataTypeNodeId.toString() + " category = " + category
+        );
+    }
+
+    const v2: CacheForFieldResolution = {
+        category,
+        fieldTypeName,
+        schema
+    };
+    cache[key] = v2;
+    return v2;
+}
+
+async function _setupEncodings(
+    session: IBasicSession,
+    dataTypeNodeId: NodeId,
+    schema: StructuredTypeSchema
+): Promise<StructuredTypeSchema> {
+    // read abstract flag
+    const isAbstractDV = await session.read({ nodeId: dataTypeNodeId, attributeId: AttributeIds.IsAbstract });
+    schema.dataTypeNodeId = dataTypeNodeId;
+    schema.id = dataTypeNodeId;
+
+    if (isAbstractDV.statusCode === StatusCodes.Good && isAbstractDV.value.value === false) {
+        const encodings = await _findEncodings(session, dataTypeNodeId);
+        schema.encodingDefaultBinary = makeExpandedNodeId(encodings.binaryEncodingNodeId);
+        schema.encodingDefaultXml = makeExpandedNodeId(encodings.xmlEncodingNodeId);
+        schema.encodingDefaultJson = makeExpandedNodeId(encodings.jsonEncodingNodeId);
+    }
+    return schema;
+}
+
+export async function convertDataTypeDefinitionToStructureTypeSchema(
+    session: IBasicSession,
+    dataTypeNodeId: NodeId,
+    name: string,
+    definition: DataTypeDefinition,
+    dataTypeFactory: DataTypeFactory,
+    cache: { [key: string]: CacheForFieldResolution }
+): Promise<StructuredTypeSchema> {
+    if (definition instanceof StructureDefinition) {
+        const fields: FieldInterfaceOptions[] = [];
+
+        const isUnion = definition.structureType === StructureType.Union;
+
+        switch (definition.structureType) {
+            case StructureType.Union:
+                // xx console.log("Union Found : ", name);
+                fields.push({
+                    fieldType: "UInt32",
+                    name: "SwitchField"
+                });
+                break;
+            case StructureType.Structure:
+            case StructureType.StructureWithOptionalFields:
+                break;
+        }
+
+        let switchValue = 1;
+        let switchBit = 0;
+
+        const bitFields: { name: string; length?: number }[] | undefined = isUnion ? undefined : [];
+
+        for (const fieldD of definition.fields!) {
+            const rt = (await resolveFieldType(session, fieldD.dataType, dataTypeFactory, cache))!;
+            if (!rt) {
+                console.log("convertDataTypeDefinitionToStructureTypeSchema cannot handle field", fieldD.name, "in", name);
+                continue;
+            }
+            const { schema, category, fieldTypeName } = rt;
+
+            const field: FieldInterfaceOptions = {
+                fieldType: fieldTypeName!,
+                name: fieldD.name!,
+                schema
+            };
+
+            if (fieldD.isOptional) {
+                field.switchBit = switchBit++;
+                bitFields?.push({ name: fieldD.name! + "Specified", length: 1 });
+            }
+            if (isUnion) {
+                field.switchValue = switchValue;
+                switchValue += 1;
+            }
+
+            assert(fieldD.valueRank === -1 || fieldD.valueRank === 1 || fieldD.valueRank === 0);
+            if (fieldD.valueRank === 1) {
+                field.isArray = true;
+            } else {
+                field.isArray = false;
+            }
+            field.category = category;
+            field.schema = schema;
+            fields.push(field);
+        }
+
+        const a = await resolveFieldType(session, definition.baseDataType, dataTypeFactory, cache);
+        const baseType = a ? a.fieldTypeName : "ExtensionObject";
+
+        const os = new StructuredTypeSchema({
+            baseType,
+            bitFields,
+            fields,
+            id: 0,
+            name
+        });
+        const structuredTypeSchema = await _setupEncodings(session, dataTypeNodeId, os);
+        return structuredTypeSchema;
+    }
+    throw new Error("Not Implemented");
+}

package/source/extra_data_type_manager.ts

@@ -0,0 +1,89 @@
+/**
+ * @module node-opcua-client-dynamic-extension-object
+ */
+import { format } from "util";
+
+import { assert } from "node-opcua-assert";
+import { 
+    ConstructorFunc, 
+    DataTypeFactory, 
+    getStandardDataTypeFactory 
+} from "node-opcua-factory";
+import { NodeId } from "node-opcua-nodeid";
+import { AnyConstructorFunc } from "node-opcua-schemas";
+
+export class ExtraDataTypeManager {
+    public namespaceArray: string[] = [];
+
+    private readonly dataTypeFactoryMapByNamespace: { [key: number]: DataTypeFactory } = {};
+
+    constructor() {
+        /* */
+    }
+
+    public setNamespaceArray(namespaceArray: string[]): void {
+        this.namespaceArray = namespaceArray;
+    }
+
+    public hasDataTypeFactory(namespaceIndex: number): boolean {
+        return !!Object.prototype.hasOwnProperty.call(this.dataTypeFactoryMapByNamespace,namespaceIndex);
+    }
+
+    public registerDataTypeFactory(namespaceIndex: number, dataTypeFactory: DataTypeFactory): void {
+        /* istanbul ignore next */
+        assert(namespaceIndex !== 0, "registerTypeDictionary cannot be used for namespace 0");
+        if (this.hasDataTypeFactory(namespaceIndex)) {
+            throw new Error("Dictionary already registered");
+        }
+        this.dataTypeFactoryMapByNamespace[namespaceIndex] = dataTypeFactory;
+    }
+
+    public getDataTypeFactoryForNamespace(namespaceIndex: number): DataTypeFactory {
+        assert(namespaceIndex !== 0, "getTypeDictionaryForNamespace cannot be used for namespace 0");
+        return this.dataTypeFactoryMapByNamespace[namespaceIndex];
+    }
+    public getDataTypeFactory(namespaceIndex: number): DataTypeFactory {
+        if (namespaceIndex === 0) {
+            return getStandardDataTypeFactory();
+        }
+        return this.dataTypeFactoryMapByNamespace[namespaceIndex];
+    }
+
+    public getExtensionObjectConstructorFromDataType(dataTypeNodeId: NodeId): AnyConstructorFunc {
+        const dataTypeFactory = this.getDataTypeFactory(dataTypeNodeId.namespace);
+        if (!dataTypeFactory) {
+            throw new Error("cannot find dataFactory for namespace=" + dataTypeNodeId.namespace);
+        }
+        // find schema corresponding to dataTypeNodeId in typeDictionary
+        const Constructor = dataTypeFactory.findConstructorForDataType(dataTypeNodeId);
+        return Constructor;
+    }
+
+    public getExtensionObjectConstructorFromBinaryEncoding(binaryEncodingNodeId: NodeId): ConstructorFunc {
+        const dataTypeFactory = this.getDataTypeFactoryForNamespace(binaryEncodingNodeId.namespace);
+        const Constructor = dataTypeFactory.getConstructor(binaryEncodingNodeId);
+        if (!Constructor) {
+            throw new Error(
+                "getExtensionObjectConstructorFromBinaryEncoding cannot find constructor for binaryEncoding " +
+                    binaryEncodingNodeId.toString()
+            );
+        }
+        return Constructor;
+    }
+    public toString(): string {
+        const l: string[] = [];
+        function write(...args: [any, ...any[]]) {
+            l.push(format.apply(format, args));
+        }
+        write("ExtraDataTypeManager");
+        for (let n = 0; n < this.namespaceArray.length; n++) {
+            write("------------- namespace:", this.namespaceArray[n]);
+            const dataFactory = this.dataTypeFactoryMapByNamespace[n];
+            if (!dataFactory) {
+                continue;
+            }
+            write(dataFactory.toString());
+        }
+        return l.join("\n");
+    }
+}

package/source/get_extension_object_constructor.ts

@@ -0,0 +1,28 @@
+import { QualifiedName, AttributeIds } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { IBasicSession } from "node-opcua-pseudo-session";
+import { AnyConstructorFunc } from "node-opcua-schemas";
+//
+import { getExtraDataTypeManager } from "./get_extra_data_type_manager";
+import { readDataTypeDefinitionAndBuildType } from "./private/populate_data_type_manager_104";
+
+/**
+ *
+ */
+export async function getExtensionObjectConstructor(session: IBasicSession, dataTypeNodeId: NodeId): Promise<AnyConstructorFunc> {
+    const extraDataTypeManager = await getExtraDataTypeManager(session);
+
+    const dataTypeFactory = extraDataTypeManager.getDataTypeFactory(dataTypeNodeId.namespace);
+    const Constructor = dataTypeFactory.getConstructorForDataType(dataTypeNodeId);
+    if (Constructor) {
+        return Constructor;
+    }
+    const dataValue = await session.read({
+        nodeId: dataTypeNodeId,
+        attributeId: AttributeIds.BrowseName
+    });
+    const browseName = dataValue.value.value as QualifiedName;
+    await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, browseName.name!, dataTypeFactory, {});
+
+    return await extraDataTypeManager.getExtensionObjectConstructorFromDataType(dataTypeNodeId);
+}

package/source/get_extra_data_type_manager.ts

@@ -0,0 +1,43 @@
+import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
+import { DataTypeFactory, getStandardDataTypeFactory } from "node-opcua-factory";
+import { IBasicSession, readNamespaceArray } from "node-opcua-pseudo-session";
+//
+import { ExtraDataTypeManager } from "./extra_data_type_manager";
+import { populateDataTypeManager } from "./populate_data_type_manager";
+
+const doDebug = checkDebugFlag(__filename);
+const debugLog = make_debugLog(__filename);
+const errorLog = make_errorLog(__filename);
+
+interface IBasicSessionEx extends IBasicSession {
+    $$extraDataTypeManager?: ExtraDataTypeManager;
+}
+
+export async function getExtraDataTypeManager(session: IBasicSession): Promise<ExtraDataTypeManager> {
+    const sessionPriv: IBasicSessionEx = session as IBasicSessionEx;
+    if (!sessionPriv.$$extraDataTypeManager) {
+        const dataTypeManager = new ExtraDataTypeManager();
+
+        const namespaceArray = await readNamespaceArray(sessionPriv);
+        // istanbul ignore next
+        if (namespaceArray.length === 0) {
+            errorLog("namespaceArray is not populated ! Your server must expose a list of namespace ");
+        }
+        // istanbul ignore next
+        if (doDebug) {
+            debugLog("Namespace Array = ", namespaceArray.join("\n                   "));
+        }
+        sessionPriv.$$extraDataTypeManager = dataTypeManager;
+        dataTypeManager.setNamespaceArray(namespaceArray);
+        for (let namespaceIndex = 1; namespaceIndex < namespaceArray.length; namespaceIndex++) {
+            const dataTypeFactory1 = new DataTypeFactory([getStandardDataTypeFactory()]);
+            dataTypeManager.registerDataTypeFactory(namespaceIndex, dataTypeFactory1);
+        }
+        await populateDataTypeManager(session, dataTypeManager, false);
+    }
+    // istanbul ignore next
+    if (sessionPriv.$$extraDataTypeManager.namespaceArray.length === 0) {
+        throw new Error("namespaceArray is not populated ! Your server must expose a list of namespace ");
+    }
+    return sessionPriv.$$extraDataTypeManager;
+}

package/source/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @module node-opcua-client-dynamic-extension-object
+ */
+export * from "./populate_data_type_manager";
+export * from "./extra_data_type_manager";
+export * from "./resolve_dynamic_extension_object";
+export * from "./promote_opaque_structure";
+export * from "./get_extension_object_constructor";
+export * from "./get_extra_data_type_manager";
+export * from "./resolve_dynamic_extension_object";
+export * from "./convert_data_type_definition_to_structuretype_schema";

package/source/populate_data_type_manager.ts

@@ -0,0 +1,14 @@
+import { IBasicSession } from "node-opcua-pseudo-session";
+//
+import { ExtraDataTypeManager } from "./extra_data_type_manager";
+import { populateDataTypeManager103 } from "./private/populate_data_type_manager_103";
+import { populateDataTypeManager104 } from "./private/populate_data_type_manager_104";
+
+export async function populateDataTypeManager(session: IBasicSession, dataTypeManager: ExtraDataTypeManager, force: boolean ): Promise<void> {
+    // old way for 1.03 and early 1.04 prototype
+    await populateDataTypeManager103(session, dataTypeManager);
+    // new way for 1.04 and later
+    if (force) {
+        await populateDataTypeManager104(session, dataTypeManager);
+    }
+}

package/source/private/find_encodings.ts

@@ -0,0 +1,44 @@
+import { BrowseDirection, makeNodeClassMask, makeResultMask } from "node-opcua-data-model";
+import { NodeId, resolveNodeId } from "node-opcua-nodeid";
+import { IBasicSession, BrowseDescriptionLike, browseAll } from "node-opcua-pseudo-session";
+import { DataTypeAndEncodingId } from "node-opcua-schemas";
+
+
+export async function _findEncodings(session: IBasicSession, dataTypeNodeId: NodeId): Promise<DataTypeAndEncodingId> {
+    const nodeToBrowse: BrowseDescriptionLike = {
+        browseDirection: BrowseDirection.Forward,
+        includeSubtypes: true,
+        nodeClassMask: makeNodeClassMask("Object"),
+        nodeId: dataTypeNodeId,
+        referenceTypeId: resolveNodeId("HasEncoding"),
+        resultMask: makeResultMask("ReferenceType | IsForward | BrowseName | NodeClass | TypeDefinition")
+    };
+    const result = await browseAll(session, nodeToBrowse);
+    const references = result.references || [];
+    if (references.length === 0) {
+        // xx throw new Error("Cannot find encodings on type " + dataTypeNodeId.toString() + " statusCode " + result.statusCode.toString());
+    }
+    const encodings: DataTypeAndEncodingId = {
+        dataTypeNodeId,
+
+        binaryEncodingNodeId: NodeId.nullNodeId,
+        jsonEncodingNodeId: NodeId.nullNodeId,
+        xmlEncodingNodeId: NodeId.nullNodeId
+    };
+    for (const ref of references) {
+        switch (ref.browseName.name) {
+            case "Default Binary":
+                encodings.binaryEncodingNodeId = ref.nodeId;
+                break;
+            case "Default XML":
+                encodings.xmlEncodingNodeId = ref.nodeId;
+                break;
+            case "Default JSON":
+                encodings.jsonEncodingNodeId = ref.nodeId;
+                break;
+            default:
+                console.log(" ignoring encoding ", ref.browseName.toString());
+        }
+    }
+    return encodings;
+}