node-opcua-client-dynamic-extension-object 2.178.0 → 2.179.0

package/source/convert_data_type_definition_to_structuretype_schema.ts

@@ -1,47 +1,54 @@
 import { DataTypeIds } from "node-opcua-constants";
 import { AttributeIds, BrowseDirection, makeResultMask, NodeClassMask } from "node-opcua-data-model";
-import { DataValue } from "node-opcua-data-value";
-import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
+import type { DataValue } from "node-opcua-data-value";
+import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
 import { ExtensionObject } from "node-opcua-extension-object";
 import {
-    BitField,
+    type BitField,
     EnumerationDefinitionSchema,
     extractAllPossibleFields,
     FieldCategory,
-    FieldInterfaceOptions,
+    type FieldInterfaceOptions,
     getBuiltInType,
-    IStructuredTypeSchema,
+    type IStructuredTypeSchema,
     StructuredTypeSchema,
-    TypeDefinition
+    type TypeDefinition
 } from "node-opcua-factory";
-import { coerceNodeId, INodeId, makeExpandedNodeId, NodeId, NodeIdType, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import {
-    BrowseDescriptionLike,
+    coerceNodeId,
+    type INodeId,
+    makeExpandedNodeId,
+    type NodeId,
+    NodeIdType,
+    resolveNodeId,
+    sameNodeId
+} from "node-opcua-nodeid";
+import {
+    type BrowseDescriptionLike,
     browseAll,
     findBasicDataType,
-    IBasicSessionAsync,
-    IBasicSessionAsync2,
-    IBasicSessionBrowseAsyncSimple,
-    IBasicSessionBrowseNextAsync
+    type IBasicSessionAsync,
+    type IBasicSessionAsync2,
+    type IBasicSessionBrowseAsyncSimple,
+    type IBasicSessionBrowseNextAsync
 } from "node-opcua-pseudo-session";
-import { DataTypeAndEncodingId, createDynamicObjectConstructor } from "node-opcua-schemas";
+import { createDynamicObjectConstructor, type DataTypeAndEncodingId } from "node-opcua-schemas";
 import {
-    DataTypeDefinition,
+    type DataTypeDefinition,
     EnumDefinition,
-    EnumField, 
+    type EnumField,
     StructureDefinition,
-    StructureField,
+    type StructureField,
     StructureType
 } from "node-opcua-types";
 //
 import { DataType } from "node-opcua-variant";
-import { ExtraDataTypeManager } from "./extra_data_type_manager";
+import type { ExtraDataTypeManager } from "./extra_data_type_manager";
 import { _findEncodings } from "./private/find_encodings";
 
 const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 const errorLog = make_errorLog(__filename);
-const warningLog = make_warningLog(__filename);
 
 export interface CacheForFieldResolution {
     fieldTypeName: string;
@@ -50,10 +57,7 @@ export interface CacheForFieldResolution {
     allowSubTypes?: boolean;
     dataType?: NodeId;
 }
-export type ResolveReject<T> = [
-    resolve: (value: T) => void,
-    reject: (err: Error) => void
-];
+export type ResolveReject<T> = [resolve: (value: T) => void, reject: (err: Error) => void];
 
 export interface ICache {
     superType?: Map<string, NodeId>;
@@ -62,14 +66,20 @@ export interface ICache {
     browseNameCache?: Map<string, string>;
     hitCount?: number;
 
-    $$resolveStuff?: Map<string, ResolveReject<any>[]>;
+    $$resolveStuff?: Map<string, ResolveReject<unknown>[]>;
 }
 
-async function memoize<T>(cache: ICache, cacheName: keyof Omit<ICache, "hitCount">, nodeId: NodeId, func: () => Promise<T>): Promise<T> {
+async function memoize<T>(
+    cache: ICache,
+    cacheName: keyof Omit<ICache, "hitCount">,
+    nodeId: NodeId,
+    func: () => Promise<T>
+): Promise<T> {
     const key = nodeId.toString();
-    if (cache[cacheName]?.has(key)) {
+    const m = cache[cacheName];
+    if (m?.has(key)) {
         cache.hitCount = cache.hitCount === undefined ? 0 : cache.hitCount + 1;
-        return cache[cacheName]?.get(key)! as T;
+        return m.get(key) as T;
     }
     const value = await func();
     if (!cache[cacheName]) {
@@ -77,25 +87,23 @@ async function memoize<T>(cache: ICache, cacheName: keyof Omit<ICache, "hitCount
     }
     (cache[cacheName] as Map<string, T>).set(key, value);
     return value as T;
-
 }
 function fromCache<T>(cache: ICache, cacheName: keyof Omit<ICache, "hitCount">, nodeId: NodeId): T | null {
     const key = nodeId.toString();
-    if (cache[cacheName]?.has(key)) {
+    const m = cache[cacheName];
+    if (m?.has(key)) {
         cache.hitCount = cache.hitCount === undefined ? 0 : cache.hitCount + 1;
-        return cache[cacheName]?.get(key)! as T;
+        return m.get(key) as T;
     }
     return null;
 }
 
 async function findSuperType(session: IBasicSessionAsync2, dataTypeNodeId: NodeId, cache: ICache): Promise<NodeId> {
-
     if (dataTypeNodeId.namespace === 0 && dataTypeNodeId.value === DataTypeIds.BaseDataType) {
         // BaseDataType !
         return coerceNodeId(0);
     }
     return await memoize(cache, "superType", dataTypeNodeId, async () => {
-
         const nodeToBrowse3: BrowseDescriptionLike = {
             browseDirection: BrowseDirection.Inverse,
             includeSubtypes: false,
@@ -108,7 +116,7 @@ async function findSuperType(session: IBasicSessionAsync2, dataTypeNodeId: NodeI
 
         /* c8 ignore next */
         if (result3.statusCode.isNotGood()) {
-            throw new Error("Cannot find superType for " + dataTypeNodeId.toString());
+            throw new Error(`Cannot find superType for ${dataTypeNodeId.toString()}`);
         }
         result3.references = result3.references || [];
 
@@ -116,17 +124,13 @@ async function findSuperType(session: IBasicSessionAsync2, dataTypeNodeId: NodeI
         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
+                `Invalid dataType with more than one (or 0) superType ${dataTypeNodeId.toString()} l=${result3.references.length}`
             );
         }
         return result3.references[0].nodeId;
     });
 }
-async function findDataTypeCategory(
-    session: IBasicSessionAsync2,
-    cache: ICache,
-    dataTypeNodeId: NodeId,
-): Promise<FieldCategory> {
+async function findDataTypeCategory(session: IBasicSessionAsync2, cache: ICache, dataTypeNodeId: NodeId): Promise<FieldCategory> {
     const subTypeNodeId = await findSuperType(session, dataTypeNodeId, cache);
     doDebug && debugLog("subTypeNodeId  of ", dataTypeNodeId.toString(), " is ", subTypeNodeId.toString());
 
@@ -156,11 +160,7 @@ async function findDataTypeCategory(
     return await findDataTypeCategory(session, cache, subTypeNodeId);
 }
 
-async function findDataTypeBasicType(
-    session: IBasicSessionAsync2,
-    cache: ICache,
-    dataTypeNodeId: NodeId
-): Promise<TypeDefinition> {
+async function findDataTypeBasicType(session: IBasicSessionAsync2, cache: ICache, dataTypeNodeId: NodeId): Promise<TypeDefinition> {
     const subTypeNodeId = await findSuperType(session, dataTypeNodeId, cache);
 
     doDebug && debugLog("subTypeNodeId  of ", dataTypeNodeId.toString(), " is ", subTypeNodeId.toString());
@@ -183,7 +183,10 @@ async function findDataTypeBasicType(
             attributeId: AttributeIds.BrowseName,
             nodeId: subTypeNodeId
         });
-        const name = nameDataValue.value.value.name!;
+        const name = nameDataValue.value.value.name;
+        if (!name) {
+            throw new Error(`Unexpected: BrowseName has no name for nodeId ${subTypeNodeId.toString()}`);
+        }
         return getBuiltInType(name);
     }
     // must drill down ...
@@ -191,18 +194,17 @@ async function findDataTypeBasicType(
     return td;
 }
 
-
 async function readBrowseNameWithCache(session: IBasicSessionAsync, nodeId: NodeId, cache: ICache): Promise<string> {
     return await memoize(cache, "browseNameCache", nodeId, async () => {
         const dataValue = await session.read({ nodeId, attributeId: AttributeIds.BrowseName });
         if (dataValue.statusCode.isNotGood()) {
-            const message =
-                "cannot extract BrowseName of nodeId = " + nodeId.toString() + " statusCode = " + dataValue.statusCode.toString();
-            debugLog(message);
+            const message = `cannot extract BrowseName of nodeId = ${nodeId.toString()} statusCode = ${dataValue.statusCode.toString()}`;
+            // c8 ignore next
+            doDebug && debugLog(message);
             throw new Error(message);
         }
-        return dataValue.value!.value.name;
-    })
+        return dataValue.value.value.name;
+    });
 }
 
 async function resolve2(
@@ -212,22 +214,20 @@ async function resolve2(
     fieldTypeName: string,
     cache: ICache
 ): Promise<{ schema: TypeDefinition | undefined; category: FieldCategory }> {
-
     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, " )");
+    doDebug && debugLog(` type ${fieldTypeName} has not been seen yet, let resolve it => (category = `, category, " )");
 
-    let schema: TypeDefinition | undefined = undefined;
+    let schema: TypeDefinition | undefined;
     switch (category) {
         case FieldCategory.basic:
             schema = await findDataTypeBasicType(session, cache, dataTypeNodeId);
             /* c8 ignore next */
             if (!schema) {
-                errorLog("Cannot find basic type " + fieldTypeName);
+                errorLog(`Cannot find basic type ${fieldTypeName}`);
             }
             break;
         default:
-        case FieldCategory.complex:
             {
                 const dataTypeDefinitionDataValue = await session.read({
                     attributeId: AttributeIds.DataTypeDefinition,
@@ -236,7 +236,7 @@ async function resolve2(
 
                 /* c8 ignore next */
                 if (dataTypeDefinitionDataValue.statusCode.isNotGood()) {
-                    throw new Error(" Cannot find dataType Definition ! with nodeId =" + dataTypeNodeId.toString());
+                    throw new Error(` Cannot find dataType Definition ! with nodeId =${dataTypeNodeId.toString()}`);
                 }
                 const definition = dataTypeDefinitionDataValue.value.value;
 
@@ -244,17 +244,23 @@ async function resolve2(
                 // Enumeration values are represented as a Int32 in the EnumValueType structure.
                 // but on 64 bit platform this value could be returned as a [ high, low] tuple.
                 // note that this is not correct as per the spec.
-                const convertIn64ToInteger = (a: number[] | number) => Array.isArray(a) ? a[1] : a;
+                const convertIn64ToInteger = (a: number[] | number) => (Array.isArray(a) ? a[1] : a);
 
                 const convert = (fields: EnumField[] | null) => {
                     const retVal: Record<string, number> = {};
-                    fields && fields.forEach((field: EnumField) => (retVal[field.name || ""] = convertIn64ToInteger(field.value as number[])));
+                    fields?.forEach((field: EnumField) => {
+                        retVal[field.name || ""] = convertIn64ToInteger(field.value as number[]);
+                    });
                     return retVal;
                 };
                 if (category === FieldCategory.enumeration) {
                     if (dataTypeFactory.hasEnumeration(fieldTypeName)) {
                         // skipping already known enumeration
-                        schema = dataTypeFactory.getEnumeration(fieldTypeName)!;
+                        const existingEnumeration = dataTypeFactory.getEnumeration(fieldTypeName);
+                        if (!existingEnumeration) {
+                            throw new Error(`Internal error: expecting enumeration ${fieldTypeName} to be registered`);
+                        }
+                        schema = existingEnumeration;
                     } else {
                         if (definition instanceof EnumDefinition) {
                             const e = new EnumerationDefinitionSchema(dataTypeNodeId, {
@@ -278,7 +284,10 @@ async function resolve2(
                         cache
                     );
                     const structuredTypeSchema = schema as IStructuredTypeSchema;
-                    if (structuredTypeSchema.encodingDefaultBinary && !dataTypeFactory.hasConstructor(structuredTypeSchema.encodingDefaultBinary)) {
+                    if (
+                        structuredTypeSchema.encodingDefaultBinary &&
+                        !dataTypeFactory.hasConstructor(structuredTypeSchema.encodingDefaultBinary)
+                    ) {
                         createDynamicObjectConstructor(structuredTypeSchema, dataTypeFactory);
                     }
                 }
@@ -312,10 +321,7 @@ async function resolveFieldType(
     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) {
@@ -341,7 +347,7 @@ async function resolveFieldType(
         }
 
         const readIsAbstract = async (dataTypeNodeId: NodeId): Promise<boolean> => {
-            return (await session.read({ nodeId: dataTypeNodeId, attributeId: AttributeIds.IsAbstract })).value.value
+            return (await session.read({ nodeId: dataTypeNodeId, attributeId: AttributeIds.IsAbstract })).value.value;
         };
 
         const [isAbstract, fieldTypeName, _unusedSuperType] = await Promise.all([
@@ -352,9 +358,8 @@ async function resolveFieldType(
 
         if (isAbstract) {
             const _isExtensionObject = await isExtensionObject(session, dataTypeNodeId, cache);
-            doDebug && debugLog(
-                " dataType " + dataTypeNodeId.toString() + " " + fieldTypeName + " is abstract => extObj ?= " + _isExtensionObject
-            );
+            doDebug &&
+                debugLog(` dataType ${dataTypeNodeId.toString()} ${fieldTypeName} is abstract => extObj ?= ${_isExtensionObject}`);
             if (_isExtensionObject) {
                 // we could have complex => Structure
                 const v3: CacheForFieldResolution = {
@@ -370,8 +375,7 @@ async function resolveFieldType(
                 // Note: Only BaseDataType (i=24) should be normalized to "Variant"
                 // Other abstract basic types (e.g. Number, Integer) must keep their name
                 // for proper subtype validation
-                const isBaseDataType = dataTypeNodeId.namespace === 0
-                    && dataTypeNodeId.value === DataTypeIds.BaseDataType;
+                const isBaseDataType = dataTypeNodeId.namespace === 0 && dataTypeNodeId.value === DataTypeIds.BaseDataType;
                 const v3: CacheForFieldResolution = {
                     category: FieldCategory.basic,
                     fieldTypeName: isBaseDataType ? "Variant" : fieldTypeName,
@@ -405,7 +409,7 @@ async function resolveFieldType(
         /* c8 ignore next */
         if (!schema) {
             throw new Error(
-                "expecting a schema here fieldTypeName=" + fieldTypeName + " " + dataTypeNodeId.toString() + " category = " + category
+                `expecting a schema here fieldTypeName=${fieldTypeName} ${dataTypeNodeId.toString()} category = ${category}`
             );
         }
 
@@ -428,7 +432,7 @@ async function _setupEncodings(
     schema.dataTypeNodeId = dataTypeNodeId;
 
     if (!isAbstract) {
-        const encodings = (dataTypeDescription && dataTypeDescription.encodings) || (await _findEncodings(session, dataTypeNodeId));
+        const encodings = dataTypeDescription?.encodings || (await _findEncodings(session, dataTypeNodeId));
         schema.encodingDefaultBinary = makeExpandedNodeId(encodings.binaryEncodingNodeId);
         schema.encodingDefaultXml = makeExpandedNodeId(encodings.xmlEncodingNodeId);
         schema.encodingDefaultJson = makeExpandedNodeId(encodings.jsonEncodingNodeId);
@@ -447,52 +451,58 @@ interface SessionWithCache {
     _$$cache2?: Map<string, DataType>;
     _$$cacheHits?: number;
 }
-async function findBasicDataTypeEx(session: IBasicSessionBrowseAsyncSimple, dataTypeNodeId: NodeId, cache: ICache): Promise<DataType> {
+async function findBasicDataTypeEx(
+    session: IBasicSessionBrowseAsyncSimple,
+    dataTypeNodeId: NodeId,
+    cache: ICache
+): Promise<DataType> {
     return await memoize(cache, "dataTypes", dataTypeNodeId, async () => {
         const sessionEx = session as SessionWithCache;
-        if (!sessionEx._$$cache2) { sessionEx._$$cache2 = new Map(); }
+        if (!sessionEx._$$cache2) {
+            sessionEx._$$cache2 = new Map();
+        }
+        const cache2 = sessionEx._$$cache2;
         const key = dataTypeNodeId.toString();
-        if (sessionEx._$$cache2.has(key)) {
-            sessionEx._$$cacheHits = sessionEx._$$cacheHits == undefined ? 0 : sessionEx._$$cacheHits + 1;
+        const cached = cache2.get(key);
+        if (cached !== undefined) {
+            sessionEx._$$cacheHits = sessionEx._$$cacheHits === undefined ? 0 : sessionEx._$$cacheHits + 1;
             // debugLog("cache hit 2", key);
-            return sessionEx._$$cache2.get(key)!;
+            return cached;
         }
         const d = await findBasicDataType(session, dataTypeNodeId);
-        sessionEx._$$cache2.set(key, d);
+        cache2.set(key, d);
         return d;
     });
 }
 
-
 async function nonReentrant<T>(cache: ICache, prefix: string, dataTypeNodeId: NodeId, func: () => Promise<T>): Promise<T> {
-
     const key = prefix + dataTypeNodeId.toString();
 
-    if (cache.$$resolveStuff?.has(key)) {
-        doDebug && debugLog(" re-entering !" + key);
+    const existingArr = cache.$$resolveStuff?.get(key);
+    if (existingArr) {
+        doDebug && debugLog(` re-entering !${key}`);
         return await new Promise<T>((resolve, reject) => {
-            cache.$$resolveStuff?.get(key)!.push([resolve, reject]);
+            existingArr.push([resolve, reject] as ResolveReject<unknown>);
         });
     }
+    const arr: ResolveReject<unknown>[] = [];
     cache.$$resolveStuff = cache.$$resolveStuff || new Map();
-    cache.$$resolveStuff.set(key, []);
+    cache.$$resolveStuff.set(key, arr);
 
     return await new Promise<T>((_resolve, _reject) => {
-        cache.$$resolveStuff!.get(key)!.push([_resolve, _reject]);
+        arr.push([_resolve, _reject] as ResolveReject<unknown>);
 
         (async () => {
             try {
                 const result = await func();
 
-                const tmp = cache.$$resolveStuff!.get(key)!;
-                cache.$$resolveStuff!.delete(key);
-                for (const [resolve] of tmp) {
+                cache.$$resolveStuff?.delete(key);
+                for (const [resolve] of arr) {
                     resolve(result);
                 }
             } catch (err) {
-                const tmp = cache.$$resolveStuff!.get(key)!;
-                cache.$$resolveStuff!.delete(key);
-                for (const [_resolve, reject] of tmp) {
+                cache.$$resolveStuff?.delete(key);
+                for (const [_resolve, reject] of arr) {
                     reject(err as Error);
                 }
             }
@@ -500,8 +510,6 @@ async function nonReentrant<T>(cache: ICache, prefix: string, dataTypeNodeId: No
     });
 }
 
-
-// eslint-disable-next-line max-statements, max-params
 export async function convertDataTypeDefinitionToStructureTypeSchema(
     session: IBasicSessionAsync2,
     dataTypeNodeId: NodeId,
@@ -512,13 +520,8 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
     isAbstract: boolean,
     cache: ICache
 ): Promise<IStructuredTypeSchema> {
-
     return await nonReentrant(cache, "convertDataTypeDefinitionToStructureTypeSchema", dataTypeNodeId, async () => {
-
-
-
         if (definition instanceof StructureDefinition) {
-
             const dataTypeFactory = dataTypeManager.getDataTypeFactoryForNamespace(dataTypeNodeId.namespace);
 
             let fieldCountToIgnore = 0;
@@ -552,7 +555,7 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
 
             let switchValue = 1;
 
-            // let's start at fieldCountToIgnore bits 
+            // let's start at fieldCountToIgnore bits
             let switchBit = fieldCountToIgnore;
 
             const bitFields: BitField[] | undefined = isUnion ? undefined : [];
@@ -560,7 +563,6 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
             const postActions: ((schema: IStructuredTypeSchema) => void)[] = [];
 
             if (definition.fields) {
-
                 // pre-fetch all dataTypes in parallel
                 const dataTypesToResolve: NodeId[] = [];
                 const seen = new Set<string>();
@@ -582,29 +584,44 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
                     !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 };
-                }));
-
+                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));
+                    ({
+                        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);
+                        if (!fieldTypeNameForSelfRef) {
+                            throw new Error(
+                                `Internal error: expecting fieldTypeNameForSelfRef to be defined for self-referencing field ${fieldD.name}`
+                            );
+                        }
+                        field.fieldType = fieldTypeNameForSelfRef;
+                        field.category = FieldCategory.complex;
                         fields.push(field);
                         const capturedField = field;
                         postActions.push((schema: IStructuredTypeSchema) => {
@@ -612,11 +629,14 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
                         });
                         continue;
                     }
-                    const resolvedField = rt!;
+                    if (!rt) {
+                        throw new Error(`Internal error: expecting resolved field type for field ${fieldD.name}`);
+                    }
+                    const resolvedField = rt;
 
                     const { schema, category, fieldTypeName, dataType } = resolvedField;
 
-                    field.fieldType = fieldTypeName!;
+                    field.fieldType = fieldTypeName;
                     field.category = category;
                     field.schema = schema;
                     field.dataType = dataType || fieldD.dataType;
@@ -624,7 +644,6 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
                     field.basicDataType = basicDataType;
                     fields.push(field);
                 }
-
             }
             /// some server may provide definition.baseDataType to be i=22 (ExtensionObject)
             /// instead of 12756 Union;
@@ -645,7 +664,9 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
             });
             const structuredTypeSchema = await _setupEncodings(session, dataTypeNodeId, dataTypeDescription, os, isAbstract);
 
-            postActions.forEach((action) => action(structuredTypeSchema));
+            postActions.forEach((action) => {
+                action(structuredTypeSchema);
+            });
 
             doDebug && debugLog("DONE ! convertDataTypeDefinitionToStructureTypeSchema = ", dataTypeNodeId.toString());
             return structuredTypeSchema;
@@ -661,24 +682,26 @@ export async function convertDataTypeDefinitionToStructureTypeSchema(
         bitFields: BitField[] | undefined,
         isUnion: boolean,
         switchValue: number
-    ): { field: FieldInterfaceOptions; switchBit: number; switchValue: number, allowSubTypes?: boolean } {
-
+    ): { field: FieldInterfaceOptions; switchBit: number; switchValue: number; allowSubTypes?: boolean } {
+        if (!fieldD.name) {
+            throw new Error("Internal error: expecting field name to be defined");
+        }
         const field: FieldInterfaceOptions = {
             fieldType: "",
-            name: fieldD.name!,
+            name: fieldD.name,
             schema: undefined
         };
 
         const definitionAllowSubTypes =
-            definition.structureType === StructureType.StructureWithSubtypedValues
-            || definition.structureType === StructureType.UnionWithSubtypedValues;
+            definition.structureType === StructureType.StructureWithSubtypedValues ||
+            definition.structureType === StructureType.UnionWithSubtypedValues;
 
         if (fieldD.isOptional) {
             // 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 });
+                bitFields?.push({ name: `${fieldD.name}Specified`, length: 1 });
             }
         }
         if (isUnion) {

package/source/convert_structuretype_schema_to_structure_definition.ts

@@ -1,29 +1,29 @@
-import { CommonInterface, FieldCategory, FieldEnumeration, FieldType, IStructuredTypeSchema } from "node-opcua-factory";
-import { StructureDefinition, StructureType, StructureDefinitionOptions, StructureFieldOptions } from "node-opcua-types";
+import { FieldCategory, type FieldType, type IStructuredTypeSchema } from "node-opcua-factory";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
-import { DataType } from "node-opcua-variant";
+import { StructureDefinition, type StructureDefinitionOptions, type StructureFieldOptions, StructureType } from "node-opcua-types";
 
 function _getDataType(field: FieldType): NodeId {
     switch (field.category) {
         case FieldCategory.complex:
-            return resolveNodeId((field.schema as any).dataTypeNodeId);
+            return resolveNodeId((field.schema as unknown as IStructuredTypeSchema).dataTypeNodeId);
         case FieldCategory.basic:
             return resolveNodeId(field.fieldType);
-        case FieldCategory.enumeration:
         default:
-            return resolveNodeId(field.dataType!);
+            // FieldCategory.enumeration: enumeration fields don't carry a resolvable
+            // dataType NodeId here; fall back to the null NodeId, matching the
+            // pre-existing (test-verified) behaviour.
+            return field.dataType ? resolveNodeId(field.dataType) : new NodeId();
     }
 }
 
 export function convertStructureTypeSchemaToStructureDefinition(st: IStructuredTypeSchema): StructureDefinition {
-
     let structureType = StructureType.Invalid;
     let isUnion = false;
     if (st.baseType === "Union") {
         structureType = StructureType.Union;
         isUnion = true;
     } else {
-        structureType =  StructureType.Structure;
+        structureType = StructureType.Structure;
     }
     // convert partial field (not including base class)
     const structureDefinition: StructureDefinitionOptions = {
@@ -42,7 +42,7 @@ export function convertStructureTypeSchemaToStructureDefinition(st: IStructuredT
             arrayDimensions: f.isArray ? [] : undefined,
             valueRank: f.isArray ? 1 : -1,
             dataType,
-            isOptional: isUnion ? undefined: f.switchValue !== undefined,
+            isOptional: isUnion ? undefined : f.switchValue !== undefined,
             description: f.documentation || undefined,
             name: f.originalName
         });