node-opcua-client-dynamic-extension-object 2.162.0 → 2.163.1

package/source/convert_data_type_definition_to_structuretype_schema.ts

@@ -4,7 +4,6 @@ import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "n
 import { INodeId, NodeIdType, sameNodeId } from "node-opcua-nodeid";
 import {
     BitField,
-    DataTypeFactory,
     EnumerationDefinitionSchema,
     extractAllPossibleFields,
     FieldCategory,
@@ -33,11 +32,12 @@ import {
     EnumField
 } from "node-opcua-types";
 import { ExtensionObject } from "node-opcua-extension-object";
-import { DataTypeAndEncodingId } from "node-opcua-schemas";
+import { DataTypeAndEncodingId, createDynamicObjectConstructor } from "node-opcua-schemas";
 //
 import { DataType } from "node-opcua-variant";
 import { DataTypeIds } from "node-opcua-constants";
 import { _findEncodings } from "./private/find_encodings";
+import { ExtraDataTypeManager } from "./extra_data_type_manager";
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
@@ -48,7 +48,7 @@ export interface CacheForFieldResolution {
     fieldTypeName: string;
     schema: TypeDefinition;
     category: FieldCategory;
-    allowSubType?: boolean;
+    allowSubTypes?: boolean;
     dataType?: NodeId;
 }
 export type ResolveReject<T> = [
@@ -125,7 +125,6 @@ async function findSuperType(session: IBasicSessionAsync2, dataTypeNodeId: NodeI
 }
 async function findDataTypeCategory(
     session: IBasicSessionAsync2,
-    dataTypeFactory: DataTypeFactory,
     cache: ICache,
     dataTypeNodeId: NodeId,
 ): Promise<FieldCategory> {
@@ -155,7 +154,7 @@ async function findDataTypeCategory(
         return category;
     }
     // must drill down ...
-    return await findDataTypeCategory(session, dataTypeFactory, cache, subTypeNodeId);
+    return await findDataTypeCategory(session, cache, subTypeNodeId);
 }
 
 async function findDataTypeBasicType(
@@ -210,12 +209,13 @@ async function readBrowseNameWithCache(session: IBasicSessionAsync, nodeId: Node
 async function resolve2(
     session: IBasicSessionAsync2,
     dataTypeNodeId: NodeId,
-    dataTypeFactory: DataTypeFactory,
+    dataTypeManager: ExtraDataTypeManager,
     fieldTypeName: string,
     cache: ICache
 ): Promise<{ schema: TypeDefinition | undefined; category: FieldCategory }> {
 
-    const category = await findDataTypeCategory(session, dataTypeFactory, cache, dataTypeNodeId);
+    const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dataTypeNodeId.namespace);
+    const category = await findDataTypeCategory(session, cache, dataTypeNodeId);
     doDebug && debugLog(" type " + fieldTypeName + " has not been seen yet, let resolve it => (category = ", category, " )");
 
     let schema: TypeDefinition | undefined = undefined;
@@ -274,12 +274,15 @@ async function resolve2(
                         fieldTypeName,
                         definition,
                         null,
-                        dataTypeFactory,
+                        dataTypeManager,
                         isAbstract,
                         cache
                     );
+                    const structuredTypeSchema = schema as IStructuredTypeSchema;
+                    if (structuredTypeSchema.encodingDefaultBinary && !dataTypeFactory.hasConstructor(structuredTypeSchema.encodingDefaultBinary)) {
+                        createDynamicObjectConstructor(structuredTypeSchema, dataTypeFactory);
+                    }
                 }
-                // xx const schema1 = dataTypeFactory.getStructuredTypeSchema(fieldTypeName);
             }
             break;
     }
@@ -304,19 +307,19 @@ const isExtensionObject = async (session: IBasicSessionAsync2, dataTypeNodeId: N
     return await isExtensionObject(session, baseDataType, cache);
 };
 
-// eslint-disable-next-line max-statements
 async function resolveFieldType(
     session: IBasicSessionAsync2,
     dataTypeNodeId: NodeId,
-    dataTypeFactory: DataTypeFactory,
+    dataTypeManager: ExtraDataTypeManager,
     cache: ICache
 ): Promise<CacheForFieldResolution | null> {
 
 
     return await memoize(cache, "fieldResolution", dataTypeNodeId, async () => {
 
+        const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dataTypeNodeId.namespace);
+
         if (dataTypeNodeId.namespace === 0 && dataTypeNodeId.value === DataTypeIds.Structure) {
-            // ERN   return null;
             const category: FieldCategory = FieldCategory.complex;
             const fieldTypeName = "Structure";
             const schema = ExtensionObject.schema;
@@ -324,7 +327,7 @@ async function resolveFieldType(
                 category,
                 fieldTypeName,
                 schema,
-                allowSubType: true,
+                allowSubTypes: true,
                 dataType: coerceNodeId(DataType.ExtensionObject)
             };
         }
@@ -333,7 +336,7 @@ async function resolveFieldType(
             const v3: CacheForFieldResolution = {
                 category: FieldCategory.basic,
                 fieldTypeName: "Variant",
-                schema: dataTypeFactory.getBuiltInType("Variant")
+                schema: dataTypeManager.getBuiltInType("Variant")
             };
             return v3;
         }
@@ -342,9 +345,10 @@ async function resolveFieldType(
             return (await session.read({ nodeId: dataTypeNodeId, attributeId: AttributeIds.IsAbstract })).value.value
         };
 
-        const [isAbstract, fieldTypeName] = await Promise.all([
+        const [isAbstract, fieldTypeName, _unusedSuperType] = await Promise.all([
             readIsAbstract(dataTypeNodeId),
-            readBrowseNameWithCache(session, dataTypeNodeId, cache)
+            readBrowseNameWithCache(session, dataTypeNodeId, cache),
+            findSuperType(session, dataTypeNodeId, cache)
         ]);
 
         if (isAbstract) {
@@ -358,7 +362,7 @@ async function resolveFieldType(
                     category: FieldCategory.complex,
                     fieldTypeName: fieldTypeName,
                     schema: ExtensionObject.schema,
-                    allowSubType: true,
+                    allowSubTypes: true,
                     dataType: dataTypeNodeId
                 };
                 return v3;
@@ -367,8 +371,8 @@ async function resolveFieldType(
                 const v3: CacheForFieldResolution = {
                     category: FieldCategory.basic,
                     fieldTypeName: fieldTypeName,
-                    schema: dataTypeFactory.getBuiltInType("Variant"),
-                    allowSubType: true,
+                    schema: dataTypeManager.getBuiltInType("Variant"),
+                    allowSubTypes: true,
                     dataType: dataTypeNodeId
                 };
                 return v3;
@@ -389,7 +393,7 @@ async function resolveFieldType(
             schema = dataTypeFactory.getEnumeration(fieldTypeName!)!;
         } else {
             doDebug && debugLog(" type " + fieldTypeName + " has not been seen yet, let resolve it");
-            const res = await resolve2(session, dataTypeNodeId, dataTypeFactory, fieldTypeName, cache);
+            const res = await resolve2(session, dataTypeNodeId, dataTypeManager, fieldTypeName, cache);
             schema = res.schema;
             category = res.category;
         }
@@ -414,13 +418,12 @@ async function _setupEncodings(
     session: IBasicSessionAsync & IBasicSessionBrowseNextAsync,
     dataTypeNodeId: NodeId,
     dataTypeDescription: IDataTypeDescriptionMini | null,
-    schema: IStructuredTypeSchema
+    schema: IStructuredTypeSchema,
+    isAbstract: boolean
 ): Promise<IStructuredTypeSchema> {
-    // read abstract flag
-    const isAbstractDV = await session.read({ nodeId: dataTypeNodeId, attributeId: AttributeIds.IsAbstract });
     schema.dataTypeNodeId = dataTypeNodeId;
 
-    if (isAbstractDV.statusCode.isGood() && isAbstractDV.value.value === false) {
+    if (!isAbstract) {
         const encodings = (dataTypeDescription && dataTypeDescription.encodings) || (await _findEncodings(session, dataTypeNodeId));
         schema.encodingDefaultBinary = makeExpandedNodeId(encodings.binaryEncodingNodeId);
         schema.encodingDefaultXml = makeExpandedNodeId(encodings.xmlEncodingNodeId);
@@ -501,27 +504,27 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
     name: string,
     definition: DataTypeDefinition,
     dataTypeDescription: IDataTypeDescriptionMini | null,
-    dataTypeFactory: DataTypeFactory,
+    dataTypeManager: ExtraDataTypeManager,
     isAbstract: boolean,
     cache: ICache
 ): Promise<IStructuredTypeSchema> {
- 
+
     return await nonReentrant(cache, "convertDataTypeDefinitionToStructureTypeSchema", dataTypeNodeId, async () => {
 
-        // warningLog(">> convertDataTypeDefinitionToStructureTypeSchema = ", dataTypeNodeId.toString());
+
         if (definition instanceof StructureDefinition) {
+
+            const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dataTypeNodeId.namespace);
+
             let fieldCountToIgnore = 0;
-            const structureInfo = dataTypeFactory.getStructureInfoForDataType(definition.baseDataType);
+
+            const structureInfo = dataTypeManager.getStructureInfoForDataType(definition.baseDataType);
             const baseSchema: IStructuredTypeSchema | undefined | null = structureInfo?.schema;
 
             if (baseSchema) {
                 const possibleFields = extractAllPossibleFields(baseSchema);
                 fieldCountToIgnore += possibleFields.length;
             }
-            // while (base && !(base.dataTypeNodeId.value === DataType.ExtensionObject && base.dataTypeNodeId.namespace === 0)) {
-            //     fieldCountToIgnore += base..length;
-            //     base = base.getBaseSchema();
-            // }
 
             const fields: FieldInterfaceOptions[] = [];
 
@@ -536,6 +539,9 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
                     break;
                 case StructureType.Structure:
                 case StructureType.StructureWithOptionalFields:
+                // new in 1.05
+                case StructureType.StructureWithSubtypedValues:
+                case StructureType.UnionWithSubtypedValues:
                     break;
             }
 
@@ -548,51 +554,67 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
 
             if (definition.fields) {
 
-
+                // pre-fetch all dataTypes in parallel
+                const dataTypesToResolve: NodeId[] = [];
+                const seen = new Set<string>();
+                if (!sameNodeId(definition.baseDataType, dataTypeNodeId)) {
+                    dataTypesToResolve.push(definition.baseDataType);
+                    seen.add(definition.baseDataType.toString());
+                }
                 for (let i = fieldCountToIgnore; i < definition.fields.length; i++) {
                     const fieldD = definition.fields[i];
-                    // we need to skip fields that have already been handled in base class
-                    // promises.push((
-                    await (async () => {
-
-                        let field: FieldInterfaceOptions | undefined;
-                        ({ field, switchBit, switchValue } = createField(fieldD, switchBit, bitFields, isUnion, switchValue));
-
-                        if (fieldD.dataType.value === dataTypeNodeId.value && fieldD.dataType.namespace === dataTypeNodeId.namespace) {
-                            // this is a structure with a field of the same type
-                            // push an empty placeholder that we will fill later
-                            const fieldTypeName = await readBrowseNameWithCache(session, dataTypeNodeId, cache);
-                            (field.fieldType = fieldTypeName!), (field.category = FieldCategory.complex);
-                            fields.push(field);
-                            const capturedField = field;
-                            postActions.push((schema: IStructuredTypeSchema) => {
-                                capturedField.schema = schema;
-                            });
-                            return;;
-                        }
-                        const rt = (await resolveFieldType(session, fieldD.dataType, dataTypeFactory, cache))!;
-                        if (!rt) {
-                            errorLog(
-                                "convertDataTypeDefinitionToStructureTypeSchema cannot handle field",
-                                fieldD.name,
-                                "in",
-                                name,
-                                "because " + fieldD.dataType.toString() + " cannot be resolved"
-                            );
-                            return;
-                        }
-                        const { schema, category, fieldTypeName, dataType, allowSubType } = rt;
-
-                        field.fieldType = fieldTypeName!;
-                        field.category = category;
-                        field.schema = schema;
-                        field.dataType = dataType || fieldD.dataType;
-                        field.allowSubType = allowSubType || false;
-                        field.basicDataType = await findBasicDataTypeEx(session, field.dataType, cache);
+                    const key = fieldD.dataType.toString();
+                    if (seen.has(key)) continue;
+                    seen.add(key);
+                    if (sameNodeId(fieldD.dataType, dataTypeNodeId)) continue;
+                    dataTypesToResolve.push(fieldD.dataType);
+                }
+                await Promise.all([
+                    ...dataTypesToResolve.map((dataType) => resolveFieldType(session, dataType, dataTypeManager, cache)),
+                    ...dataTypesToResolve.map((dataType) => findBasicDataTypeEx(session, dataType, cache)),
+                    !isAbstract ? _findEncodings(session, dataTypeNodeId) : Promise.resolve(null)
+                ]);
+
+                const results = await Promise.all(definition.fields.slice(fieldCountToIgnore).map(async (fieldD) => {
+                    const isSelf = sameNodeId(fieldD.dataType, dataTypeNodeId);
+                    // Pre-fetch async data for each field in parallel
+                    const rt = isSelf ? null : await resolveFieldType(session, fieldD.dataType, dataTypeManager, cache);
+                    const basicDataType = rt ? await findBasicDataTypeEx(session, rt.dataType || fieldD.dataType, cache) : (isSelf ? DataType.ExtensionObject : undefined);
+                    const fieldTypeNameForSelfRef = (isSelf)
+                        ? await readBrowseNameWithCache(session, dataTypeNodeId, cache)
+                        : undefined;
+                    return { fieldD, rt, basicDataType, fieldTypeNameForSelfRef };
+                }));
+
+                for (const { fieldD, rt, basicDataType, fieldTypeNameForSelfRef } of results) {
+
+                    let field: FieldInterfaceOptions | undefined;
+                    let currentAllowSubTypes: boolean | undefined;
+
+                    ({ field, switchBit, switchValue, allowSubTypes: currentAllowSubTypes } = createField(definition, fieldD, switchBit, bitFields, isUnion, switchValue));
+
+                    if (fieldD.dataType.value === dataTypeNodeId.value && fieldD.dataType.namespace === dataTypeNodeId.namespace) {
+                        // this is a structure with a field of the same type
+                        // push an empty placeholder that we will fill later
+                        (field.fieldType = fieldTypeNameForSelfRef!), (field.category = FieldCategory.complex);
                         fields.push(field);
-                    })();
-                    // ));
+                        const capturedField = field;
+                        postActions.push((schema: IStructuredTypeSchema) => {
+                            capturedField.schema = schema;
+                        });
+                        continue;
+                    }
+                    const resolvedField = rt!;
 
+                    const { schema, category, fieldTypeName, dataType } = resolvedField;
+
+                    field.fieldType = fieldTypeName!;
+                    field.category = category;
+                    field.schema = schema;
+                    field.dataType = dataType || fieldD.dataType;
+                    field.allowSubTypes = currentAllowSubTypes;
+                    field.basicDataType = basicDataType;
+                    fields.push(field);
                 }
 
             }
@@ -602,7 +624,8 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
                 definition.baseDataType = resolveNodeId(DataTypeIds.Union); // aka DataTypeIds.Union
             }
 
-            const a = await resolveFieldType(session, definition.baseDataType, dataTypeFactory, cache);
+            const a = await resolveFieldType(session, definition.baseDataType, dataTypeManager, cache);
+
             const baseType = a ? a.fieldTypeName : isUnion ? "Union" : "ExtensionObject";
 
             const os = new StructuredTypeSchema({
@@ -612,7 +635,7 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
                 name,
                 dataTypeFactory
             });
-            const structuredTypeSchema = await _setupEncodings(session, dataTypeNodeId, dataTypeDescription, os);
+            const structuredTypeSchema = await _setupEncodings(session, dataTypeNodeId, dataTypeDescription, os, isAbstract);
 
             postActions.forEach((action) => action(structuredTypeSchema));
 
@@ -621,28 +644,42 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
         }
         throw new Error("Not Implemented");
     });
+
     function createField(
+        definition: StructureDefinition,
         fieldD: StructureField,
+
         switchBit: number,
         bitFields: BitField[] | undefined,
         isUnion: boolean,
         switchValue: number
-    ): { field: FieldInterfaceOptions; switchBit: number; switchValue: number } {
+    ): { field: FieldInterfaceOptions; switchBit: number; switchValue: number, allowSubTypes?: boolean } {
+
         const field: FieldInterfaceOptions = {
             fieldType: "",
             name: fieldD.name!,
             schema: undefined
         };
 
+        const definitionAllowSubTypes =
+            definition.structureType === StructureType.StructureWithSubtypedValues
+            || definition.structureType === StructureType.UnionWithSubtypedValues;
+
         if (fieldD.isOptional) {
-            field.switchBit = switchBit++;
-            bitFields?.push({ name: fieldD.name! + "Specified", length: 1 });
+            // Optional has a special handling
+            if (!definitionAllowSubTypes) {
+                // we are in a true optional field structure
+                field.switchBit = switchBit++;
+                bitFields?.push({ name: fieldD.name! + "Specified", length: 1 });
+            }
         }
         if (isUnion) {
             field.switchValue = switchValue;
             switchValue += 1;
         }
 
+        const allowSubTypes = definitionAllowSubTypes && fieldD.isOptional;
+
         // (fieldD.valueRank === -1 || fieldD.valueRank === 1 || fieldD.valueRank === 0);
 
         if (fieldD.valueRank >= 1) {
@@ -651,6 +688,6 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
         } else {
             field.isArray = false;
         }
-        return { field, switchBit, switchValue };
+        return { field, switchBit, switchValue, allowSubTypes };
     }
 }

package/source/extra_data_type_manager.ts

@@ -4,18 +4,26 @@
 import { format } from "util";
 
 import { assert } from "node-opcua-assert";
-import { ConstructorFunc, DataTypeFactory, getStandardDataTypeFactory } from "node-opcua-factory";
+import { BrowseDirection, NodeClassMask, ResultMask } from "node-opcua-data-model";
+import { ConstructorFunc, DataTypeFactory, getStandardDataTypeFactory, StructureInfo } from "node-opcua-factory";
 import { NodeId } from "node-opcua-nodeid";
+import { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
 import { AnyConstructorFunc } from "node-opcua-schemas";
 
 export class ExtraDataTypeManager {
     public namespaceArray: string[] = [];
     private dataTypeFactoryMapByNamespace: { [key: number]: DataTypeFactory } = {};
+    private _session: IBasicSessionAsync2 | null = null;
+    private _pendingExtractions: Map<string, Promise<StructureInfo>> = new Map();
 
     constructor() {
         /* */
     }
 
+    public setSession(session: IBasicSessionAsync2): void {
+        this._session = session;
+    }
+
     public setNamespaceArray(namespaceArray: string[]): void {
         this.namespaceArray = namespaceArray;
     }
@@ -34,7 +42,9 @@ export class ExtraDataTypeManager {
     }
 
     public getDataTypeFactoryForNamespace(namespaceIndex: number): DataTypeFactory {
-        assert(namespaceIndex !== 0, "getTypeDictionaryForNamespace cannot be used for namespace 0");
+        if (namespaceIndex === 0) {
+            return getStandardDataTypeFactory();
+        }
         return this.dataTypeFactoryMapByNamespace[namespaceIndex];
     }
 
@@ -45,31 +55,130 @@ export class ExtraDataTypeManager {
         return this.dataTypeFactoryMapByNamespace[namespaceIndex];
     }
 
+    public getBuiltInType(fieldTypeName: string) {
+        // fallback to standard factory
+        const standardDataTypeFactory = getStandardDataTypeFactory();
+        if (standardDataTypeFactory.hasBuiltInType(fieldTypeName)) {
+            return standardDataTypeFactory.getBuiltInType(fieldTypeName);
+        }
+        throw new Error("Cannot find built-in type " + fieldTypeName);
+    }
+
+    public getStructureInfoForDataType(dataTypeNodeId: NodeId): StructureInfo | null {
+        const dataTypeFactory = this.getDataTypeFactory(dataTypeNodeId.namespace);
+        if (!dataTypeFactory) {
+            throw new Error("cannot find dataFactory for namespace=" + dataTypeNodeId.namespace + " when requested for " + dataTypeNodeId.toString());
+        }
+        return dataTypeFactory.getStructureInfoForDataType(dataTypeNodeId);
+    }
+
+    public async getStructureInfoForDataTypeAsync(dataTypeNodeId: NodeId): Promise<StructureInfo> {
+        const structureInfo = this.getStructureInfoForDataType(dataTypeNodeId);
+        if (structureInfo) {
+            return structureInfo;
+        }
+        if (!this._session) {
+            throw new Error("Session is required for lazy loading. Call setSession first.");
+        }
+
+        const key = dataTypeNodeId.toString();
+        if (this._pendingExtractions.has(key)) {
+            return await this._pendingExtractions.get(key)!;
+        }
+
+        const promise = (async () => {
+            // We'll need to make sure it's accessible and correctly used.
+            // For now, let's assume we can import it or move it.
+            // Actually, populate_data_type_manager_104.ts exports readDataTypeDefinitionAndBuildType
+            const { readDataTypeDefinitionAndBuildType } = require("./private/populate_data_type_manager_104");
+            const cache = {}; // local cache for this extraction
+            await readDataTypeDefinitionAndBuildType(this._session!, dataTypeNodeId, undefined, this, cache);
+
+            const info = this.getStructureInfoForDataType(dataTypeNodeId);
+            if (!info) {
+                throw new Error("Failed to extract data type structure for " + dataTypeNodeId.toString());
+            }
+            return info;
+        })();
+
+        this._pendingExtractions.set(key, promise);
+        try {
+            return await promise;
+        } finally {
+            this._pendingExtractions.delete(key);
+        }
+    }
+
     public getExtensionObjectConstructorFromDataType(dataTypeNodeId: NodeId): AnyConstructorFunc {
         const dataTypeFactory = this.getDataTypeFactory(dataTypeNodeId.namespace);
         if (!dataTypeFactory) {
             throw new Error("cannot find dataFactory for namespace=" + dataTypeNodeId.namespace + " when requested for " + dataTypeNodeId.toString());
         }
         // find schema corresponding to dataTypeNodeId in typeDictionary
-        const Constructor = dataTypeFactory.findStructureInfoForDataType(dataTypeNodeId).constructor;
+        const structureInfo = dataTypeFactory.findStructureInfoForDataType(dataTypeNodeId);
+        const Constructor = structureInfo.constructor;
         if (!Constructor) {
             throw new Error("Cannot find Extension Object Constructor for Abstract dataType");
         }
         return Constructor;
     }
 
+    public async getExtensionObjectConstructorFromDataTypeAsync(dataTypeNodeId: NodeId): Promise<AnyConstructorFunc> {
+        const structureInfo = await this.getStructureInfoForDataTypeAsync(dataTypeNodeId);
+        const Constructor = structureInfo.constructor;
+        if (!Constructor) {
+            throw new Error("Cannot find Extension Object Constructor for Abstract dataType " + dataTypeNodeId.toString());
+        }
+        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()
+                binaryEncodingNodeId.toString()
             );
         }
         return Constructor;
     }
 
+    public async getExtensionObjectConstructorFromBinaryEncodingAsync(binaryEncodingNodeId: NodeId): Promise<ConstructorFunc> {
+        const dataTypeFactory = this.getDataTypeFactoryForNamespace(binaryEncodingNodeId.namespace);
+        let Constructor = dataTypeFactory.getConstructor(binaryEncodingNodeId);
+        if (Constructor) {
+            return Constructor;
+        }
+
+        if (!this._session) {
+            throw new Error("Session is required for lazy loading. Call setSession first.");
+        }
+
+        // Need to find the DataType for this binary encoding
+        const browseResult = await this._session.browse({
+            nodeId: binaryEncodingNodeId,
+            referenceTypeId: "HasEncoding",
+            browseDirection: BrowseDirection.Inverse,
+            includeSubtypes: false,
+            nodeClassMask: NodeClassMask.DataType,
+            resultMask: ResultMask.BrowseName
+        });
+
+        if (browseResult.statusCode.isNotGood() || !browseResult.references || browseResult.references.length !== 1) {
+            throw new Error("Cannot find DataType for binary encoding " + binaryEncodingNodeId.toString());
+        }
+
+        const dataTypeNodeId = browseResult.references[0].nodeId;
+        await this.getStructureInfoForDataTypeAsync(dataTypeNodeId);
+
+        Constructor = dataTypeFactory.getConstructor(binaryEncodingNodeId);
+        if (!Constructor) {
+            throw new Error("Cannot find constructor for binary encoding " + binaryEncodingNodeId.toString() + " after extraction");
+        }
+        return Constructor;
+    }
+
     public toString(): string {
         const l: string[] = [];
         function write(...args: [any, ...any[]]) {

package/source/get_extension_object_constructor.ts

@@ -10,9 +10,10 @@ import { readDataTypeDefinitionAndBuildType } from "./private/populate_data_type
  *
  */
 export async function getExtensionObjectConstructor(session: IBasicSessionAsync2, dataTypeNodeId: NodeId): Promise<AnyConstructorFunc> {
-    const extraDataTypeManager = await getExtraDataTypeManager(session);
+   
+    const dataTypeManager = await getExtraDataTypeManager(session);
 
-    const dataTypeFactory = extraDataTypeManager.getDataTypeFactory(dataTypeNodeId.namespace);
+    const dataTypeFactory = dataTypeManager.getDataTypeFactory(dataTypeNodeId.namespace);
     const structureInfo = dataTypeFactory.getStructureInfoForDataType(dataTypeNodeId);
     if (structureInfo) {
         return structureInfo.constructor as unknown as AnyConstructorFunc;
@@ -22,7 +23,7 @@ export async function getExtensionObjectConstructor(session: IBasicSessionAsync2
         attributeId: AttributeIds.BrowseName
     });
     const browseName = dataValue.value.value as QualifiedName;
-    await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, browseName.name!, dataTypeFactory, {});
+    await readDataTypeDefinitionAndBuildType(session, dataTypeNodeId, browseName.name!, dataTypeManager, {});
 
-    return await extraDataTypeManager.getExtensionObjectConstructorFromDataType(dataTypeNodeId);
+    return await dataTypeManager.getExtensionObjectConstructorFromDataType(dataTypeNodeId);
 }