node-opcua-client-dynamic-extension-object 2.127.0 → 2.128.0

package/dist/convert_data_type_definition_to_structuretype_schema.d.ts

@@ -3,6 +3,7 @@ import { NodeId } from "node-opcua-nodeid";
 import { IBasicSessionAsync2 } from "node-opcua-pseudo-session";
 import { DataTypeDefinition } from "node-opcua-types";
 import { DataTypeAndEncodingId } from "node-opcua-schemas";
+import { DataType } from "node-opcua-variant";
 export interface CacheForFieldResolution {
     fieldTypeName: string;
     schema: TypeDefinition;
@@ -10,10 +11,20 @@ export interface CacheForFieldResolution {
     allowSubType?: boolean;
     dataType?: NodeId;
 }
+export type ResolveReject = [
+    resolve: (value: any) => void,
+    reject: (err: Error) => void
+];
+export interface ICache {
+    superType?: Map<string, NodeId>;
+    fieldResolution?: Map<string, CacheForFieldResolution>;
+    dataTypes?: Map<string, DataType>;
+    browseNameCache?: Map<string, string>;
+    hitCount?: number;
+    $$resolveStuff?: Map<string, ResolveReject[]>;
+}
 export interface IDataTypeDescriptionMini {
     encodings?: DataTypeAndEncodingId;
     isAbstract?: boolean;
 }
-export declare function convertDataTypeDefinitionToStructureTypeSchema(session: IBasicSessionAsync2, dataTypeNodeId: NodeId, name: string, definition: DataTypeDefinition, dataTypeDescription: IDataTypeDescriptionMini | null, dataTypeFactory: DataTypeFactory, isAbstract: boolean, cache: {
-    [key: string]: CacheForFieldResolution;
-}): Promise<IStructuredTypeSchema>;
+export declare function convertDataTypeDefinitionToStructureTypeSchema(session: IBasicSessionAsync2, dataTypeNodeId: NodeId, name: string, definition: DataTypeDefinition, dataTypeDescription: IDataTypeDescriptionMini | null, dataTypeFactory: DataTypeFactory, isAbstract: boolean, cache: ICache): Promise<IStructuredTypeSchema>;

package/dist/convert_data_type_definition_to_structuretype_schema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertDataTypeDefinitionToStructureTypeSchema = void 0;
+exports.convertDataTypeDefinitionToStructureTypeSchema = convertDataTypeDefinitionToStructureTypeSchema;
 const node_opcua_data_model_1 = require("node-opcua-data-model");
 const node_opcua_debug_1 = require("node-opcua-debug");
 const node_opcua_nodeid_1 = require("node-opcua-nodeid");
@@ -16,38 +16,62 @@ const find_encodings_1 = require("./private/find_encodings");
 const debugLog = (0, node_opcua_debug_1.make_debugLog)(__filename);
 const errorLog = (0, node_opcua_debug_1.make_errorLog)(__filename);
 const warningLog = (0, node_opcua_debug_1.make_warningLog)(__filename);
-async function findSuperType(session, dataTypeNodeId) {
+const doDebug = false;
+async function memoize(cache, cacheName, nodeId, func) {
+    const key = nodeId.toString();
+    if (cache[cacheName]?.has(key)) {
+        cache.hitCount = cache.hitCount === undefined ? 0 : cache.hitCount + 1;
+        return cache[cacheName]?.get(key);
+    }
+    const value = await func();
+    if (!cache[cacheName]) {
+        cache[cacheName] = new Map();
+    }
+    cache[cacheName].set(key, value);
+    return value;
+}
+function fromCache(cache, cacheName, nodeId) {
+    const key = nodeId.toString();
+    if (cache[cacheName]?.has(key)) {
+        cache.hitCount = cache.hitCount === undefined ? 0 : cache.hitCount + 1;
+        return cache[cacheName]?.get(key);
+    }
+    return null;
+}
+async function findSuperType(session, dataTypeNodeId, cache) {
     if (dataTypeNodeId.namespace === 0 && dataTypeNodeId.value === 24) {
         // BaseDataType !
         return (0, node_opcua_nodeid_2.coerceNodeId)(0);
     }
-    const nodeToBrowse3 = {
-        browseDirection: node_opcua_data_model_1.BrowseDirection.Inverse,
-        includeSubtypes: false,
-        nodeClassMask: node_opcua_data_model_1.NodeClassMask.DataType,
-        nodeId: dataTypeNodeId,
-        referenceTypeId: (0, node_opcua_nodeid_2.resolveNodeId)("HasSubtype"),
-        resultMask: (0, node_opcua_data_model_1.makeResultMask)("NodeId | ReferenceType | BrowseName | NodeClass")
-    };
-    const result3 = await (0, node_opcua_pseudo_session_1.browseAll)(session, nodeToBrowse3);
-    /* istanbul ignore next */
-    if (result3.statusCode.isNotGood()) {
-        throw new Error("Cannot find superType for " + dataTypeNodeId.toString());
-    }
-    result3.references = result3.references || [];
-    /* istanbul ignore next */
-    if (result3.references.length !== 1) {
-        errorLog("Invalid dataType with more than one (or 0) superType", result3.toString());
-        throw new Error("Invalid dataType with more than one (or 0) superType " + dataTypeNodeId.toString() + " l=" + result3.references.length);
-    }
-    return result3.references[0].nodeId;
+    return await memoize(cache, "superType", dataTypeNodeId, async () => {
+        const nodeToBrowse3 = {
+            browseDirection: node_opcua_data_model_1.BrowseDirection.Inverse,
+            includeSubtypes: false,
+            nodeClassMask: node_opcua_data_model_1.NodeClassMask.DataType,
+            nodeId: dataTypeNodeId,
+            referenceTypeId: (0, node_opcua_nodeid_2.resolveNodeId)("HasSubtype"),
+            resultMask: (0, node_opcua_data_model_1.makeResultMask)("NodeId | ReferenceType | BrowseName | NodeClass")
+        };
+        const result3 = await (0, node_opcua_pseudo_session_1.browseAll)(session, nodeToBrowse3);
+        /* istanbul ignore next */
+        if (result3.statusCode.isNotGood()) {
+            throw new Error("Cannot find superType for " + dataTypeNodeId.toString());
+        }
+        result3.references = result3.references || [];
+        /* istanbul ignore next */
+        if (result3.references.length !== 1) {
+            errorLog("Invalid dataType with more than one (or 0) superType", result3.toString());
+            throw new Error("Invalid dataType with more than one (or 0) superType " + dataTypeNodeId.toString() + " l=" + result3.references.length);
+        }
+        return result3.references[0].nodeId;
+    });
 }
-async function findDataTypeCategory(session, cache, dataTypeNodeId) {
-    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;
+async function findDataTypeCategory(session, dataTypeFactory, cache, dataTypeNodeId) {
+    const subTypeNodeId = await findSuperType(session, dataTypeNodeId, cache);
+    doDebug && debugLog("subTypeNodeId  of ", dataTypeNodeId.toString(), " is ", subTypeNodeId.toString());
+    const fieldResolution = fromCache(cache, "fieldResolution", subTypeNodeId);
+    if (fieldResolution) {
+        return fieldResolution.category;
     }
     let category;
     const n = subTypeNodeId;
@@ -67,14 +91,14 @@ async function findDataTypeCategory(session, cache, dataTypeNodeId) {
         return category;
     }
     // must drill down ...
-    return await findDataTypeCategory(session, cache, subTypeNodeId);
+    return await findDataTypeCategory(session, dataTypeFactory, cache, subTypeNodeId);
 }
 async function findDataTypeBasicType(session, cache, dataTypeNodeId) {
-    const subTypeNodeId = await findSuperType(session, dataTypeNodeId);
+    const subTypeNodeId = await findSuperType(session, dataTypeNodeId, cache);
     debugLog("subTypeNodeId  of ", dataTypeNodeId.toString(), " is ", subTypeNodeId.toString());
-    const key = subTypeNodeId.toString();
-    if (cache[key]) {
-        return cache[key].schema;
+    const fieldResolution = fromCache(cache, "fieldResolution", subTypeNodeId);
+    if (fieldResolution) {
+        return fieldResolution.schema;
     }
     const n = subTypeNodeId;
     if (n.identifierType === node_opcua_nodeid_1.NodeIdType.NUMERIC && n.namespace === 0 && n.value < 29) {
@@ -93,19 +117,22 @@ async function findDataTypeBasicType(session, cache, dataTypeNodeId) {
         return (0, node_opcua_factory_1.getBuiltInType)(name);
     }
     // must drill down ...
-    return await findDataTypeBasicType(session, cache, subTypeNodeId);
+    const td = await findDataTypeBasicType(session, cache, subTypeNodeId);
+    return td;
 }
-async function readBrowseName(session, nodeId) {
-    const dataValue = await session.read({ nodeId, attributeId: node_opcua_data_model_1.AttributeIds.BrowseName });
-    if (dataValue.statusCode.isNotGood()) {
-        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 readBrowseNameWithCache(session, nodeId, cache) {
+    return await memoize(cache, "browseNameCache", nodeId, async () => {
+        const dataValue = await session.read({ nodeId, attributeId: node_opcua_data_model_1.AttributeIds.BrowseName });
+        if (dataValue.statusCode.isNotGood()) {
+            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 resolve2(session, dataTypeNodeId, dataTypeFactory, fieldTypeName, cache) {
-    const category = await findDataTypeCategory(session, cache, dataTypeNodeId);
+    const category = await findDataTypeCategory(session, dataTypeFactory, cache, dataTypeNodeId);
     debugLog(" type " + fieldTypeName + " has not been seen yet, let resolve it => (category = ", category, " )");
     let schema = undefined;
     switch (category) {
@@ -154,11 +181,11 @@ async function resolve2(session, dataTypeNodeId, dataTypeFactory, fieldTypeName,
     }
     return { schema, category };
 }
-const isExtensionObject = async (session, dataTypeNodeId) => {
+const isExtensionObject = async (session, dataTypeNodeId, cache) => {
     if (dataTypeNodeId.namespace === 0 && dataTypeNodeId.value === node_opcua_variant_1.DataType.ExtensionObject) {
         return true;
     }
-    const baseDataType = await findSuperType(session, dataTypeNodeId);
+    const baseDataType = await findSuperType(session, dataTypeNodeId, cache);
     const bn = baseDataType;
     if (bn.identifierType === node_opcua_nodeid_1.NodeIdType.NUMERIC) {
         if (bn.namespace === 0 && bn.value === node_opcua_variant_1.DataType.ExtensionObject) {
@@ -168,98 +195,96 @@ const isExtensionObject = async (session, dataTypeNodeId) => {
             return false;
         }
     }
-    return await isExtensionObject(session, baseDataType);
+    return await isExtensionObject(session, baseDataType, cache);
 };
 // eslint-disable-next-line max-statements
 async function resolveFieldType(session, dataTypeNodeId, dataTypeFactory, cache) {
-    if (dataTypeNodeId.namespace === 0 && dataTypeNodeId.value === 22) {
-        // ERN   return null;
-        const category = node_opcua_factory_1.FieldCategory.complex;
-        const fieldTypeName = "Structure";
-        const schema = node_opcua_extension_object_1.ExtensionObject.schema;
-        return {
-            category,
-            fieldTypeName,
-            schema,
-            allowSubType: true,
-            dataType: (0, node_opcua_nodeid_2.coerceNodeId)(node_opcua_variant_1.DataType.ExtensionObject)
-        };
-    }
-    const key = dataTypeNodeId.toString();
-    const v = cache[key];
-    if (v) {
-        return v;
-    }
-    if (dataTypeNodeId.value === 0) {
-        const v3 = {
-            category: node_opcua_factory_1.FieldCategory.basic,
-            fieldTypeName: "Variant",
-            schema: dataTypeFactory.getBuiltInType("Variant")
-        };
-        cache[key] = v3;
-        return v3;
-    }
-    const isAbstract = (await session.read({ nodeId: dataTypeNodeId, attributeId: node_opcua_data_model_1.AttributeIds.IsAbstract })).value.value;
-    const fieldTypeName = await readBrowseName(session, dataTypeNodeId);
-    if (isAbstract) {
-        const _isExtensionObject = await isExtensionObject(session, dataTypeNodeId);
-        debugLog(" dataType " + dataTypeNodeId.toString() + " " + fieldTypeName + " is abstract => extObj ?= " + _isExtensionObject);
-        if (_isExtensionObject) {
-            // we could have complex => Structure
-            const v3 = {
-                category: node_opcua_factory_1.FieldCategory.complex,
-                fieldTypeName: fieldTypeName,
-                schema: node_opcua_extension_object_1.ExtensionObject.schema,
+    return await memoize(cache, "fieldResolution", dataTypeNodeId, async () => {
+        if (dataTypeNodeId.namespace === 0 && dataTypeNodeId.value === 22) {
+            // ERN   return null;
+            const category = node_opcua_factory_1.FieldCategory.complex;
+            const fieldTypeName = "Structure";
+            const schema = node_opcua_extension_object_1.ExtensionObject.schema;
+            return {
+                category,
+                fieldTypeName,
+                schema,
                 allowSubType: true,
-                dataType: dataTypeNodeId
+                dataType: (0, node_opcua_nodeid_2.coerceNodeId)(node_opcua_variant_1.DataType.ExtensionObject)
             };
-            cache[key] = v3;
-            return v3;
         }
-        else {
-            // we could have basic => Variant
+        if (dataTypeNodeId.value === 0) {
             const v3 = {
                 category: node_opcua_factory_1.FieldCategory.basic,
-                fieldTypeName: fieldTypeName,
-                schema: dataTypeFactory.getBuiltInType("Variant"),
-                allowSubType: true,
-                dataType: dataTypeNodeId
+                fieldTypeName: "Variant",
+                schema: dataTypeFactory.getBuiltInType("Variant")
             };
-            cache[key] = v3;
             return v3;
         }
-    }
-    let schema;
-    let category = node_opcua_factory_1.FieldCategory.enumeration;
-    if (dataTypeFactory.hasStructureByTypeName(fieldTypeName)) {
-        schema = dataTypeFactory.getStructuredTypeSchema(fieldTypeName);
-        category = node_opcua_factory_1.FieldCategory.complex;
-    }
-    else if (dataTypeFactory.hasBuiltInType(fieldTypeName)) {
-        category = node_opcua_factory_1.FieldCategory.basic;
-        schema = dataTypeFactory.getBuiltInType(fieldTypeName);
-    }
-    else if (dataTypeFactory.hasEnumeration(fieldTypeName)) {
-        category = node_opcua_factory_1.FieldCategory.enumeration;
-        schema = dataTypeFactory.getEnumeration(fieldTypeName);
-    }
-    else {
-        debugLog(" type " + fieldTypeName + " has not been seen yet, let resolve it");
-        const res = await resolve2(session, dataTypeNodeId, dataTypeFactory, fieldTypeName, cache);
-        schema = res.schema;
-        category = res.category;
-    }
-    /* istanbul ignore next */
-    if (!schema) {
-        throw new Error("expecting a schema here fieldTypeName=" + fieldTypeName + " " + dataTypeNodeId.toString() + " category = " + category);
-    }
-    const v2 = {
-        category,
-        fieldTypeName,
-        schema
-    };
-    cache[key] = v2;
-    return v2;
+        const readIsAbstract = async (dataTypeNodeId) => {
+            return (await session.read({ nodeId: dataTypeNodeId, attributeId: node_opcua_data_model_1.AttributeIds.IsAbstract })).value.value;
+        };
+        const [isAbstract, fieldTypeName] = await Promise.all([
+            readIsAbstract(dataTypeNodeId),
+            readBrowseNameWithCache(session, dataTypeNodeId, cache)
+        ]);
+        if (isAbstract) {
+            const _isExtensionObject = await isExtensionObject(session, dataTypeNodeId, cache);
+            debugLog(" dataType " + dataTypeNodeId.toString() + " " + fieldTypeName + " is abstract => extObj ?= " + _isExtensionObject);
+            if (_isExtensionObject) {
+                // we could have complex => Structure
+                const v3 = {
+                    category: node_opcua_factory_1.FieldCategory.complex,
+                    fieldTypeName: fieldTypeName,
+                    schema: node_opcua_extension_object_1.ExtensionObject.schema,
+                    allowSubType: true,
+                    dataType: dataTypeNodeId
+                };
+                return v3;
+            }
+            else {
+                // we could have basic => Variant
+                const v3 = {
+                    category: node_opcua_factory_1.FieldCategory.basic,
+                    fieldTypeName: fieldTypeName,
+                    schema: dataTypeFactory.getBuiltInType("Variant"),
+                    allowSubType: true,
+                    dataType: dataTypeNodeId
+                };
+                return v3;
+            }
+        }
+        let schema;
+        let category = node_opcua_factory_1.FieldCategory.enumeration;
+        if (dataTypeFactory.hasStructureByTypeName(fieldTypeName)) {
+            schema = dataTypeFactory.getStructuredTypeSchema(fieldTypeName);
+            category = node_opcua_factory_1.FieldCategory.complex;
+        }
+        else if (dataTypeFactory.hasBuiltInType(fieldTypeName)) {
+            category = node_opcua_factory_1.FieldCategory.basic;
+            schema = dataTypeFactory.getBuiltInType(fieldTypeName);
+        }
+        else if (dataTypeFactory.hasEnumeration(fieldTypeName)) {
+            category = node_opcua_factory_1.FieldCategory.enumeration;
+            schema = dataTypeFactory.getEnumeration(fieldTypeName);
+        }
+        else {
+            debugLog(" type " + fieldTypeName + " has not been seen yet, let resolve it");
+            const res = await resolve2(session, dataTypeNodeId, dataTypeFactory, fieldTypeName, cache);
+            schema = res.schema;
+            category = res.category;
+        }
+        /* istanbul ignore next */
+        if (!schema) {
+            throw new Error("expecting a schema here fieldTypeName=" + fieldTypeName + " " + dataTypeNodeId.toString() + " category = " + category);
+        }
+        const v2 = {
+            category,
+            fieldTypeName,
+            schema
+        };
+        return v2;
+    });
 }
 async function _setupEncodings(session, dataTypeNodeId, dataTypeDescription, schema) {
     // read abstract flag
@@ -276,89 +301,146 @@ async function _setupEncodings(session, dataTypeNodeId, dataTypeDescription, sch
     }
     return schema;
 }
-// eslint-disable-next-line max-statements, max-params
-async function convertDataTypeDefinitionToStructureTypeSchema(session, dataTypeNodeId, name, definition, dataTypeDescription, dataTypeFactory, isAbstract, cache) {
-    if (definition instanceof node_opcua_types_1.StructureDefinition) {
-        let fieldCountToIgnore = 0;
-        const structureInfo = dataTypeFactory.getStructureInfoForDataType(definition.baseDataType);
-        const baseSchema = structureInfo?.schema;
-        if (baseSchema) {
-            const possibleFields = (0, node_opcua_factory_1.extractAllPossibleFields)(baseSchema);
-            fieldCountToIgnore += possibleFields.length;
+async function findBasicDataTypeEx(session, dataTypeNodeId, cache) {
+    return await memoize(cache, "dataTypes", dataTypeNodeId, async () => {
+        const sessionEx = session;
+        if (!sessionEx._$$cache2) {
+            sessionEx._$$cache2 = new Map();
         }
-        // while (base && !(base.dataTypeNodeId.value === DataType.ExtensionObject && base.dataTypeNodeId.namespace === 0)) {
-        //     fieldCountToIgnore += base..length;
-        //     base = base.getBaseSchema();
-        // }
-        const fields = [];
-        const isUnion = definition.structureType === node_opcua_types_1.StructureType.Union;
-        switch (definition.structureType) {
-            case node_opcua_types_1.StructureType.Union:
-                fields.push({
-                    fieldType: "UInt32",
-                    name: "SwitchField"
-                });
-                break;
-            case node_opcua_types_1.StructureType.Structure:
-            case node_opcua_types_1.StructureType.StructureWithOptionalFields:
-                break;
+        const key = dataTypeNodeId.toString();
+        if (sessionEx._$$cache2.has(key)) {
+            sessionEx._$$cacheHits = sessionEx._$$cacheHits == undefined ? 0 : sessionEx._$$cacheHits + 1;
+            // console.log("cache hit 2", key);
+            return sessionEx._$$cache2.get(key);
         }
-        let switchValue = 1;
-        let switchBit = 0;
-        const bitFields = isUnion ? undefined : [];
-        const postActions = [];
-        if (definition.fields) {
-            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
-                let field;
-                ({ 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 readBrowseName(session, dataTypeNodeId);
-                    (field.fieldType = fieldTypeName), (field.category = node_opcua_factory_1.FieldCategory.complex);
-                    fields.push(field);
-                    const capturedField = field;
-                    postActions.push((schema) => {
-                        capturedField.schema = schema;
-                    });
-                    continue;
+        const d = await (0, node_opcua_pseudo_session_1.findBasicDataType)(session, dataTypeNodeId);
+        sessionEx._$$cache2.set(key, d);
+        return d;
+    });
+}
+async function nonReentrant(cache, prefix, dataTypeNodeId, func) {
+    const key = prefix + dataTypeNodeId.toString();
+    if (cache.$$resolveStuff?.has(key)) {
+        doDebug && console.log(" re-entering !" + key);
+        return await new Promise((resolve, reject) => {
+            cache.$$resolveStuff?.get(key).push([resolve, reject]);
+        });
+    }
+    cache.$$resolveStuff = cache.$$resolveStuff || new Map();
+    cache.$$resolveStuff.set(key, []);
+    return await new Promise((_resolve, _reject) => {
+        cache.$$resolveStuff.get(key).push([_resolve, _reject]);
+        (async () => {
+            try {
+                const result = await func();
+                const tmp = cache.$$resolveStuff.get(key);
+                cache.$$resolveStuff.delete(key);
+                for (const [resolve] of tmp) {
+                    resolve(result);
                 }
-                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");
-                    continue;
+            }
+            catch (err) {
+                const tmp = cache.$$resolveStuff.get(key);
+                cache.$$resolveStuff.delete(key);
+                for (const [_resolve, reject] of tmp) {
+                    reject(err);
                 }
-                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 (0, node_opcua_pseudo_session_1.findBasicDataType)(session, field.dataType);
-                fields.push(field);
             }
+        })();
+    });
+}
+// eslint-disable-next-line max-statements, max-params
+async function convertDataTypeDefinitionToStructureTypeSchema(session, dataTypeNodeId, name, definition, dataTypeDescription, dataTypeFactory, isAbstract, cache) {
+    return await nonReentrant(cache, "convertDataTypeDefinitionToStructureTypeSchema", dataTypeNodeId, async () => {
+        // warningLog(">> convertDataTypeDefinitionToStructureTypeSchema = ", dataTypeNodeId.toString());
+        if (definition instanceof node_opcua_types_1.StructureDefinition) {
+            let fieldCountToIgnore = 0;
+            const structureInfo = dataTypeFactory.getStructureInfoForDataType(definition.baseDataType);
+            const baseSchema = structureInfo?.schema;
+            if (baseSchema) {
+                const possibleFields = (0, node_opcua_factory_1.extractAllPossibleFields)(baseSchema);
+                fieldCountToIgnore += possibleFields.length;
+            }
+            // while (base && !(base.dataTypeNodeId.value === DataType.ExtensionObject && base.dataTypeNodeId.namespace === 0)) {
+            //     fieldCountToIgnore += base..length;
+            //     base = base.getBaseSchema();
+            // }
+            const fields = [];
+            const isUnion = definition.structureType === node_opcua_types_1.StructureType.Union;
+            switch (definition.structureType) {
+                case node_opcua_types_1.StructureType.Union:
+                    fields.push({
+                        fieldType: "UInt32",
+                        name: "SwitchField"
+                    });
+                    break;
+                case node_opcua_types_1.StructureType.Structure:
+                case node_opcua_types_1.StructureType.StructureWithOptionalFields:
+                    break;
+            }
+            let switchValue = 1;
+            let switchBit = 0;
+            const bitFields = isUnion ? undefined : [];
+            const postActions = [];
+            if (definition.fields) {
+                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;
+                        ({ 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 = node_opcua_factory_1.FieldCategory.complex);
+                            fields.push(field);
+                            const capturedField = field;
+                            postActions.push((schema) => {
+                                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);
+                        fields.push(field);
+                    })();
+                    // ));
+                }
+            }
+            /// some server may provide definition.baseDataType to be i=22 (ExtensionObject)
+            /// instead of 12756 Union;
+            if (isUnion && (0, node_opcua_nodeid_1.sameNodeId)(definition.baseDataType, (0, node_opcua_nodeid_2.coerceNodeId)("i=22"))) {
+                definition.baseDataType = (0, node_opcua_nodeid_2.resolveNodeId)("i=1276"); // aka DataTypeIds.Union
+            }
+            const a = await resolveFieldType(session, definition.baseDataType, dataTypeFactory, cache);
+            const baseType = a ? a.fieldTypeName : isUnion ? "Union" : "ExtensionObject";
+            const os = new node_opcua_factory_1.StructuredTypeSchema({
+                baseType,
+                bitFields,
+                fields,
+                name,
+                dataTypeFactory
+            });
+            const structuredTypeSchema = await _setupEncodings(session, dataTypeNodeId, dataTypeDescription, os);
+            postActions.forEach((action) => action(structuredTypeSchema));
+            doDebug && console.log("DONE ! convertDataTypeDefinitionToStructureTypeSchema = ", dataTypeNodeId.toString());
+            return structuredTypeSchema;
         }
-        /// some server may provide definition.baseDataType to be i=22 (ExtensionObject)
-        /// instead of 12756 Union;
-        if (isUnion && (0, node_opcua_nodeid_1.sameNodeId)(definition.baseDataType, (0, node_opcua_nodeid_2.coerceNodeId)("i=22"))) {
-            definition.baseDataType = (0, node_opcua_nodeid_2.resolveNodeId)("i=1276"); // aka DataTypeIds.Union
-        }
-        const a = await resolveFieldType(session, definition.baseDataType, dataTypeFactory, cache);
-        const baseType = a ? a.fieldTypeName : isUnion ? "Union" : "ExtensionObject";
-        const os = new node_opcua_factory_1.StructuredTypeSchema({
-            baseType,
-            bitFields,
-            fields,
-            name,
-            dataTypeFactory
-        });
-        const structuredTypeSchema = await _setupEncodings(session, dataTypeNodeId, dataTypeDescription, os);
-        postActions.forEach((action) => action(structuredTypeSchema));
-        return structuredTypeSchema;
-    }
-    throw new Error("Not Implemented");
+        throw new Error("Not Implemented");
+    });
     function createField(fieldD, switchBit, bitFields, isUnion, switchValue) {
         const field = {
             fieldType: "",
@@ -384,5 +466,4 @@ async function convertDataTypeDefinitionToStructureTypeSchema(session, dataTypeN
         return { field, switchBit, switchValue };
     }
 }
-exports.convertDataTypeDefinitionToStructureTypeSchema = convertDataTypeDefinitionToStructureTypeSchema;
 //# sourceMappingURL=convert_data_type_definition_to_structuretype_schema.js.map