node-opcua-factory 2.76.2 → 2.77.0

package/source/datatype_factory.ts

@@ -24,30 +24,19 @@ const debugLog = make_debugLog(__filename);
 const doDebug = checkDebugFlag(__filename);
 const warningLog = make_warningLog(__filename);
 
-export function _findFieldSchema(typeDictionary: DataTypeFactory, field: StructuredTypeField, value: any): IStructuredTypeSchema {
-    const fieldType = field.fieldType;
-
-    if (field.allowSubType && field.category === "complex") {
-        const fieldTypeConstructor = value ? value.constructor : field.fieldTypeConstructor;
-
-        const _newFieldSchema = fieldTypeConstructor.schema;
-
-        return _newFieldSchema as IStructuredTypeSchema;
-    }
-
-    const fieldTypeConstructor = field.fieldTypeConstructor || typeDictionary.getStructureTypeConstructor(fieldType);
-
-    return (field.schema as IStructuredTypeSchema) || (fieldTypeConstructor as any).schema;
+export interface StructureInfo {
+    constructor: ConstructorFuncWithSchema | null; // null if abstract
+    schema: IStructuredTypeSchema;
 }
-
 export class DataTypeFactory {
     public defaultByteOrder: string;
     public targetNamespace: string;
     public imports: string[] = [];
 
-    private _structureTypeConstructorByNameMap: Map<string, ConstructorFuncWithSchema> = new Map();
-    private _structureTypeConstructorByDataTypeMap: Map<string, ConstructorFuncWithSchema> = new Map();
-    private _structureTypeConstructorByEncodingNodeIdMap: Map<string, any> = new Map();
+    private _structureInfoByName: Map<string, StructureInfo> = new Map();
+    private _structureInfoByDataTypeMap: Map<string, StructureInfo> = new Map();
+
+    private _structureInfoByEncodingMap: Map<string, StructureInfo> = new Map();
     private _enumerations: Map<string, EnumerationDefinitionSchema> = new Map();
 
     private baseDataFactories: DataTypeFactory[];
@@ -113,23 +102,23 @@ export class DataTypeFactory {
     }
     //  ----------------------------
 
-    public findConstructorForDataType(dataTypeNodeId: NodeId): ConstructorFuncWithSchema {
-        const constructor = this.getConstructorForDataType(dataTypeNodeId);
-        if (constructor) {
-            return constructor;
+    public findStructureInfoForDataType(dataTypeNodeId: NodeId): StructureInfo {
+        const structureInfo = this.getStructureInfoForDataType(dataTypeNodeId);
+        if (structureInfo) {
+            return structureInfo;
         }
-        this.getConstructorForDataType(dataTypeNodeId);
+        this.getStructureInfoForDataType(dataTypeNodeId);
         throw new Error("Cannot find StructureType constructor for dataType " + dataTypeNodeId.toString());
     }
-    public getConstructorForDataType(dataTypeNodeId: NodeId): ConstructorFuncWithSchema | null {
-        const constructor = this._structureTypeConstructorByDataTypeMap.get(dataTypeNodeId.toString());
-        if (constructor) {
-            return constructor;
+    public getStructureInfoForDataType(dataTypeNodeId: NodeId): StructureInfo | null {
+        const structureInfo = this._structureInfoByDataTypeMap.get(dataTypeNodeId.toString());
+        if (structureInfo) {
+            return structureInfo;
         }
         for (const factory of this.baseDataFactories) {
-            const constructor2 = factory.getConstructorForDataType(dataTypeNodeId);
-            if (constructor2) {
-                return constructor2;
+            const structureInfo2 = factory.getStructureInfoForDataType(dataTypeNodeId);
+            if (structureInfo2) {
+                return structureInfo2;
             }
         }
         return null;
@@ -138,21 +127,24 @@ export class DataTypeFactory {
     // Access by typeName
     // ----------------------------------------------------------------------------------------------------
     public structuredTypesNames(): IterableIterator<string> {
-        return this._structureTypeConstructorByNameMap.keys();
+        return this._structureInfoByName.keys();
+    }
+    public enumerations(): IterableIterator<string> {
+        return this._enumerations.keys();
     }
 
-    public getStructureTypeConstructor(typeName: string): ConstructorFuncWithSchema {
-        const constructor = this._structureTypeConstructorByNameMap.get(typeName);
-        if (constructor) {
-            return constructor;
+    public getStructureInfoByTypeName(typeName: string): StructureInfo {
+        const structureInfo = this._structureInfoByName.get(typeName);
+        if (structureInfo) {
+            return structureInfo;
         }
         for (const factory of this.baseDataFactories) {
-            if (!factory.hasStructuredType(typeName)) {
+            if (!factory.hasStructureByTypeName(typeName)) {
                 continue;
             }
-            const constructor2 = factory.getStructureTypeConstructor(typeName);
-            if (constructor2) {
-                return constructor2;
+            const structureInfo2 = factory.getStructureInfoByTypeName(typeName);
+            if (structureInfo2) {
+                return structureInfo2;
             }
         }
         // istanbul ignore next
@@ -165,12 +157,12 @@ export class DataTypeFactory {
         );
     }
 
-    public hasStructuredType(typeName: string): boolean {
-        if (this._structureTypeConstructorByNameMap.has(typeName)) {
+    public hasStructureByTypeName(typeName: string): boolean {
+        if (this._structureInfoByName.has(typeName)) {
             return true;
         }
         for (const factory of this.baseDataFactories) {
-            if (factory.hasStructuredType(typeName)) {
+            if (factory.hasStructureByTypeName(typeName)) {
                 return true;
             }
         }
@@ -178,8 +170,8 @@ export class DataTypeFactory {
     }
 
     public getStructuredTypeSchema(typeName: string): IStructuredTypeSchema {
-        const constructor = this.getStructureTypeConstructor(typeName);
-        return constructor.schema;
+        const structureInfo = this.getStructureInfoByTypeName(typeName);
+        return structureInfo.schema;
     }
 
     // istanbul ignore next
@@ -192,8 +184,13 @@ export class DataTypeFactory {
         console.log(" done");
     }
 
+    public registerAbstractStructure(dataTypeNodeId: NodeId, className: string, schema: IStructuredTypeSchema) {
+        schema.isAbstract = true;
+        this._registerFactory(dataTypeNodeId, className, null, schema);
+    }
+
     public registerClassDefinition(dataTypeNodeId: NodeId, className: string, classConstructor: ConstructorFuncWithSchema): void {
-        this._registerFactory(dataTypeNodeId, className, classConstructor);
+        this._registerFactory(dataTypeNodeId, className, classConstructor, classConstructor.schema);
         if (classConstructor.encodingDefaultBinary && classConstructor.encodingDefaultBinary.value !== 0) {
             this.associateWithBinaryEncoding(className, classConstructor.encodingDefaultBinary);
         } else {
@@ -207,14 +204,16 @@ export class DataTypeFactory {
     // ----------------------------------------------------------------------------------------------------
     public getConstructor(binaryEncodingNodeId: NodeId): ConstructorFunc | null {
         const expandedNodeIdKey = makeExpandedNodeIdKey(binaryEncodingNodeId);
-        const constructor = this._structureTypeConstructorByEncodingNodeIdMap.get(expandedNodeIdKey);
-        if (constructor) {
-            return constructor;
+        const structureInfo = this._structureInfoByEncodingMap.get(expandedNodeIdKey);
+        if (!structureInfo) return null;
+        const Constructor = structureInfo.constructor;
+        if (Constructor) {
+            return Constructor;
         }
         for (const factory of this.baseDataFactories) {
-            const constructor2 = factory.getConstructor(binaryEncodingNodeId);
-            if (constructor2) {
-                return constructor2;
+            const Constructor2 = factory.getConstructor(binaryEncodingNodeId);
+            if (Constructor2) {
+                return Constructor2;
             }
         }
         debugLog(chalk.red("#getConstructor : cannot find constructor for expandedId "), binaryEncodingNodeId.toString());
@@ -225,13 +224,10 @@ export class DataTypeFactory {
         if (!binaryEncodingNodeId) {
             return false;
         }
-        /* istanbul ignore next */
-        if (!verifyExpandedNodeId(binaryEncodingNodeId)) {
-            console.log("Invalid expandedNodeId");
-            return false;
-        }
+        verifyExpandedNodeId(binaryEncodingNodeId);
+
         const expandedNodeIdKey = makeExpandedNodeIdKey(binaryEncodingNodeId);
-        const constructor = this._structureTypeConstructorByEncodingNodeIdMap.get(expandedNodeIdKey);
+        const constructor = this._structureInfoByEncodingMap.get(expandedNodeIdKey);
         if (constructor) {
             return true;
         }
@@ -245,43 +241,40 @@ export class DataTypeFactory {
     }
 
     public constructObject(binaryEncodingNodeId: NodeId): IBaseUAObject {
-        if (!verifyExpandedNodeId(binaryEncodingNodeId)) {
-            throw new Error(" constructObject : invalid expandedNodeId provided " + binaryEncodingNodeId.toString());
-        }
-        const constructor = this.getConstructor(binaryEncodingNodeId);
+        verifyExpandedNodeId(binaryEncodingNodeId);
+
+        const Constructor = this.getConstructor(binaryEncodingNodeId);
 
-        if (!constructor) {
+        if (!Constructor) {
             debugLog("Cannot find constructor for " + binaryEncodingNodeId.toString());
             throw new Error("Cannot find constructor for " + binaryEncodingNodeId.toString());
         }
-        return new constructor();
+        return new Constructor();
     }
 
     public associateWithBinaryEncoding(className: string, expandedNodeId: ExpandedNodeId): void {
-        const classConstructor = this.getStructureTypeConstructor(className);
+        const structureInfo = this.getStructureInfoByTypeName(className);
         if (doDebug) {
             debugLog(" associateWithBinaryEncoding ", className, expandedNodeId.toString());
         }
 
-        /* istanbul ignore next */
-        if (!verifyExpandedNodeId(expandedNodeId)) {
-            throw new Error("Invalid expandedNodeId " + expandedNodeId.toString() + " className = " + className);
-        }
+        verifyExpandedNodeId(expandedNodeId);
+
         const expandedNodeIdKey = makeExpandedNodeIdKey(expandedNodeId);
 
         /* istanbul ignore next */
-        if (this._structureTypeConstructorByEncodingNodeIdMap.has(expandedNodeIdKey)) {
+        if (this._structureInfoByEncodingMap.has(expandedNodeIdKey)) {
             throw new Error(
                 " Class " +
                     className +
                     " with ID " +
                     expandedNodeId +
                     "  already in constructorMap for  " +
-                    this._structureTypeConstructorByEncodingNodeIdMap.get(expandedNodeIdKey).name
+                    this._structureInfoByEncodingMap.get(expandedNodeIdKey)!.schema.name
             );
         }
 
-        this._structureTypeConstructorByEncodingNodeIdMap.set(expandedNodeIdKey, classConstructor);
+        this._structureInfoByEncodingMap.set(expandedNodeIdKey, structureInfo);
     }
 
     public toString(): string {
@@ -293,25 +286,34 @@ export class DataTypeFactory {
         return l.join("\n");
     }
 
-    private _registerFactory(dataTypeNodeId: NodeId, typeName: string, constructor: ConstructorFuncWithSchema): void {
-
+    private _registerFactory(
+        dataTypeNodeId: NodeId,
+        typeName: string,
+        constructor: ConstructorFuncWithSchema | null,
+        schema: IStructuredTypeSchema
+    ): void {
         /* istanbul ignore next */
-        if (this._structureTypeConstructorByNameMap.has(typeName)) {
-            warningLog(this.getStructureTypeConstructor(typeName));
+        if (this._structureInfoByName.has(typeName)) {
+            warningLog(this.getStructureInfoByTypeName(typeName));
             warningLog("target namespace = `" + this.targetNamespace + "`");
             warningLog(" registerFactory  : " + typeName + " already registered. dataTypeNodeId=", dataTypeNodeId.toString());
             return;
         }
-        debugLog("registering typeName ", typeName, dataTypeNodeId.toString());
-        this._structureTypeConstructorByNameMap.set(typeName, constructor);
+        debugLog("registering typeName ", typeName, dataTypeNodeId.toString(), "isAbstract ", schema.isAbstract);
+        const structureInfo = { constructor, schema };
+        this._structureInfoByName.set(typeName, structureInfo);
         if (dataTypeNodeId.value !== 0) {
-            this._structureTypeConstructorByDataTypeMap.set(dataTypeNodeId.toString(), constructor);
+            this._structureInfoByDataTypeMap.set(dataTypeNodeId.toString(), structureInfo);
         }
-        Object.defineProperty(constructor.schema, "$$factory", {
-            enumerable: false,
-            value: this,
-            writable: false
-        });
+
+        // console.log("is this neceesary anymore ?");
+        // if (constructor) {
+        //     Object.defineProperty(constructor.schema, "$$factory", {
+        //         enumerable: false,
+        //         value: this,
+        //         writable: false
+        //     });
+        // }
     }
 }
 
@@ -329,7 +331,7 @@ function dumpDataFactory(dataFactory: DataTypeFactory, write: any) {
 
         write("structureTypeName =", structureTypeName);
 
-        if (!dataFactory.getConstructorForDataType(schema.dataTypeNodeId)) {
+        if (!dataFactory.getStructureInfoForDataType(schema.dataTypeNodeId)) {
             write("  ( No constructor for " + schema.name + "  " + schema.dataTypeNodeId.toString());
         }
         if (!schema.encodingDefaultBinary) {

package/source/get_standard_data_type_factory.ts

@@ -18,20 +18,16 @@ export function getStandardDataTypeFactory(): DataTypeFactory {
 }
 
 export function getStructureTypeConstructor(typeName: string): ConstructorFuncWithSchema {
-    return getStandardDataTypeFactory().getStructureTypeConstructor(typeName);
-}
-
-export function hasStructuredType(typeName: string): boolean {
-    return getStandardDataTypeFactory().hasStructuredType(typeName);
-}
-
-export function getConstructor(binaryEncodingNodeId: ExpandedNodeId): ConstructorFunc | null {
-    return getStandardDataTypeFactory().getConstructor(binaryEncodingNodeId);
+    const structureInfo =  getStandardDataTypeFactory().getStructureInfoByTypeName(typeName);
+    if (!structureInfo) {
+        throw new Error("cannot find Structure Information for "+ typeName)
+    }
+    if (!structureInfo.constructor) {
+        throw new Error("cannot  Structure is Abstract ! "+ typeName)
+    }
+    return structureInfo.constructor;
 }
 
-export function hasConstructor(binaryEncodingNodeId: ExpandedNodeId): boolean {
-    return getStandardDataTypeFactory().hasConstructor(binaryEncodingNodeId);
-}
 
 
 /* istanbul ignore next */

package/source/get_structured_type_schema.ts

@@ -2,9 +2,9 @@ import { ExpandedNodeId } from "node-opcua-nodeid";
 import { getStandardDataTypeFactory } from "./get_standard_data_type_factory";
 import { IBaseUAObject, IStructuredTypeSchema } from "./types";
 
-export function getStructuredTypeSchema(typeName: string): IStructuredTypeSchema {
-    return getStandardDataTypeFactory().getStructuredTypeSchema(typeName);
-}
-export function constructObject(binaryEncodingNodeId: ExpandedNodeId): IBaseUAObject {
-    return getStandardDataTypeFactory().constructObject(binaryEncodingNodeId);
-}
+// export function getStructuredTypeSchema(typeName: string): IStructuredTypeSchema {
+//     return getStandardDataTypeFactory().getStructuredTypeSchema(typeName);
+// }
+// export function constructObject(binaryEncodingNodeId: ExpandedNodeId): IBaseUAObject {
+//     return getStandardDataTypeFactory().constructObject(binaryEncodingNodeId);
+// }

package/source/schema_helpers.ts

@@ -46,7 +46,7 @@ export function initialize_field(field: StructuredTypeField, value: unknown, fac
     }
     if (field.category === FieldCategory.complex) {
         if (field.fieldTypeConstructor) {
-            return new field.fieldTypeConstructor(value);
+            return new field.fieldTypeConstructor(value as Record<string,unknown>);
         } else {
             debugLog("xxxx => missing constructor for field type", field.fieldType);
         }

package/source/structured_type_schema.ts

@@ -5,15 +5,14 @@ import * as chalk from "chalk";
 
 import { assert } from "node-opcua-assert";
 import { BinaryStream } from "node-opcua-binary-stream";
+import { make_warningLog } from "node-opcua-debug";
 import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
 import { lowerFirstLetter } from "node-opcua-utils";
-
-import { getBuiltInType, hasBuiltInType, TypeSchemaBase } from "./builtin_types";
-import { getBuiltInEnumeration, hasBuiltInEnumeration } from "./enumerations";
+import { TypeSchemaBase } from "./builtin_types";
 import { parameters } from "./parameters";
-import { getStructureTypeConstructor, hasStructuredType } from "./get_standard_data_type_factory";
-import { getStructuredTypeSchema } from "./get_structured_type_schema";
+import { getStandardDataTypeFactory } from "./get_standard_data_type_factory";
 import {
+    BitField,
     CommonInterface,
     FieldCategory,
     FieldInterfaceOptions,
@@ -21,29 +20,33 @@ import {
     IStructuredTypeSchema,
     StructuredTypeOptions
 } from "./types";
+import { DataTypeFactory } from "./datatype_factory";
+
+const warningLog = make_warningLog(__filename);
 
-function figureOutFieldCategory(field: FieldInterfaceOptions): FieldCategory {
+function figureOutFieldCategory(field: FieldInterfaceOptions, dataTypeFactory: DataTypeFactory): FieldCategory {
     const fieldType = field.fieldType;
 
     if (field.category) {
         return field.category;
     }
-
-    if (hasBuiltInEnumeration(fieldType)) {
+    if (dataTypeFactory.hasEnumeration(fieldType)) {
         return FieldCategory.enumeration;
-    } else if (hasBuiltInType(fieldType)) {
+    } else if (dataTypeFactory.hasBuiltInType(fieldType)) {
         return FieldCategory.basic;
-    } else if (hasStructuredType(fieldType)) {
+    } else if (dataTypeFactory.hasStructureByTypeName(fieldType)) {
         assert(fieldType !== "LocalizedText"); // LocalizedText should be treated as BasicType!!!
         return FieldCategory.complex;
     }
+    warningLog("Cannot figure out field category for ", field);
     return FieldCategory.basic;
 }
 
 const regExp = /((ns[0-9]+:)?)(.*)/;
 
 function figureOutSchema(
-    underConstructSchema: StructuredTypeSchema,
+    underConstructSchema: IStructuredTypeSchema,
+    dataTypeFactory: DataTypeFactory,
     field: FieldInterfaceOptions,
     category: FieldCategory
 ): CommonInterface {
@@ -67,29 +70,32 @@ function figureOutSchema(
 
     switch (category) {
         case FieldCategory.complex:
-            if (hasStructuredType(field.fieldType)) {
-                returnValue = getStructuredTypeSchema(fieldTypeWithoutNS);
+            if (dataTypeFactory.hasStructureByTypeName(field.fieldType)) {
+                returnValue = dataTypeFactory.getStructuredTypeSchema(fieldTypeWithoutNS);
             } else {
                 // LocalizedText etc ...
-                returnValue = getBuiltInType(fieldTypeWithoutNS);
+                returnValue = dataTypeFactory.getBuiltInType(fieldTypeWithoutNS);
             }
             break;
         case FieldCategory.basic:
-            returnValue = getBuiltInType(fieldTypeWithoutNS);
+            returnValue = dataTypeFactory.getBuiltInType(fieldTypeWithoutNS);
             if (!returnValue) {
-                returnValue = getStructuredTypeSchema(fieldTypeWithoutNS);
+                if (dataTypeFactory.hasEnumeration(fieldTypeWithoutNS)) {
+                    warningLog("expecing a enumeration!");
+                }
+                returnValue = dataTypeFactory.getStructuredTypeSchema(fieldTypeWithoutNS);
                 if (returnValue) {
                     console.log("Why ?");
                 }
             }
             break;
         case FieldCategory.enumeration:
-            returnValue = getBuiltInEnumeration(fieldTypeWithoutNS);
+            returnValue = dataTypeFactory.getEnumeration(fieldTypeWithoutNS);
             break;
     }
     if (null === returnValue || undefined === returnValue) {
         try {
-            returnValue = getBuiltInEnumeration(fieldTypeWithoutNS);
+            returnValue = dataTypeFactory.getEnumeration(fieldTypeWithoutNS);
         } catch (err) {
             console.log(err);
         }
@@ -108,9 +114,14 @@ function figureOutSchema(
     return returnValue;
 }
 
-function buildField(underConstructSchema: StructuredTypeSchema, fieldLight: FieldInterfaceOptions): FieldType {
-    const category = figureOutFieldCategory(fieldLight);
-    const schema = figureOutSchema(underConstructSchema, fieldLight, category);
+function buildField(
+    underConstructSchema: IStructuredTypeSchema,
+    dataTypeFactory: DataTypeFactory,
+    fieldLight: FieldInterfaceOptions,
+    _index: number
+): FieldType {
+    const category = figureOutFieldCategory(fieldLight, dataTypeFactory);
+    const schema = figureOutSchema(underConstructSchema, dataTypeFactory, fieldLight, category);
 
     /* istanbul ignore next */
     if (!schema) {
@@ -120,7 +131,9 @@ function buildField(underConstructSchema: StructuredTypeSchema, fieldLight: Fiel
                 " with type " +
                 fieldLight.fieldType +
                 " category" +
-                category
+                category +
+                " at index" +
+                _index
         );
     }
 
@@ -142,14 +155,13 @@ function buildField(underConstructSchema: StructuredTypeSchema, fieldLight: Fiel
         schema
     };
 }
+
 export class StructuredTypeSchema extends TypeSchemaBase implements IStructuredTypeSchema {
     public fields: FieldType[];
-    public id: NodeId;
     public dataTypeNodeId: NodeId;
 
     public baseType: string;
-    public _possibleFields: string[];
-    public _baseSchema: IStructuredTypeSchema | null;
+    private _baseSchema: IStructuredTypeSchema | null | undefined;
 
     public documentation?: string;
 
@@ -162,7 +174,9 @@ export class StructuredTypeSchema extends TypeSchemaBase implements IStructuredT
     public encodingDefaultXml?: ExpandedNodeId;
     public encodingDefaultJson?: ExpandedNodeId;
 
-    public bitFields?: any[];
+    public bitFields?: BitField[];
+
+    private _dataTypeFactory: DataTypeFactory;
 
     constructor(options: StructuredTypeOptions) {
         super(options);
@@ -172,21 +186,36 @@ export class StructuredTypeSchema extends TypeSchemaBase implements IStructuredT
         this.baseType = options.baseType;
         this.category = FieldCategory.complex;
 
-        if (hasBuiltInType(options.name)) {
+        this._dataTypeFactory = options.dataTypeFactory;
+        if (this._dataTypeFactory.hasBuiltInType(options.name)) {
             this.category = FieldCategory.basic;
         }
-        this.fields = options.fields.map(buildField.bind(null, this));
-        this.id = new NodeId();
         this.dataTypeNodeId = new NodeId();
+        this._baseSchema = undefined;
+        this.fields = options.fields.map(buildField.bind(null, this, this._dataTypeFactory));
+    }
+
+    getDataTypeFactory(): DataTypeFactory {
+        return this._dataTypeFactory || getStandardDataTypeFactory();
+    }
 
-        this._possibleFields = this.fields.map((field) => field.name);
-        this._baseSchema = null;
+    getBaseSchema(): IStructuredTypeSchema | null {
+        if (this._baseSchema !== undefined && this._baseSchema === null && this.baseType === "ExtensionObject") {
+            return this._baseSchema;
+        }
+        const _schemaBase = _get_base_schema(this);
+        this._baseSchema = _schemaBase;
+        return _schemaBase || null;
     }
+
+    public getPossibleFieldsLocal() {
+        return this.fields.map((field) => field.name);
+    }
+
     public toString(): string {
         const str: string[] = [];
         str.push("name           = " + this.name);
         str.push("baseType       = " + this.baseType);
-        str.push("id             = " + this.id.toString());
         str.push("bitFields      = " + (this.bitFields ? this.bitFields.map((b) => b.name).join(" ") : undefined));
         str.push("dataTypeNodeId = " + (this.dataTypeNodeId ? this.dataTypeNodeId.toString() : undefined));
         str.push("documentation  = " + this.documentation);
@@ -209,18 +238,8 @@ export class StructuredTypeSchema extends TypeSchemaBase implements IStructuredT
     }
 }
 
-/**
- *
- * @method get_base_schema
- * @param schema
- * @return {*}
- *
- */
-export function get_base_schema(schema: IStructuredTypeSchema): IStructuredTypeSchema | null {
-    let baseSchema = schema._baseSchema;
-    if (baseSchema) {
-        return baseSchema;
-    }
+function _get_base_schema(schema: IStructuredTypeSchema): IStructuredTypeSchema | null | undefined {
+    const dataTypeFactory = schema.getDataTypeFactory();
 
     if (schema.baseType === "ExtensionObject" || schema.baseType === "DataTypeDefinition") {
         return null;
@@ -229,23 +248,28 @@ export function get_base_schema(schema: IStructuredTypeSchema): IStructuredTypeS
         return null;
     }
 
-    if (schema.baseType && schema.baseType !== "BaseUAObject" && schema.baseType !== "DataTypeDefinition") {
-        if (!hasStructuredType(schema.baseType)) {
-            return null;
+    if (
+        schema.baseType &&
+        schema.baseType !== "BaseUAObject" &&
+        schema.baseType !== "Structure" &&
+        schema.baseType !== "DataTypeDefinition"
+    ) {
+        if (!dataTypeFactory.hasStructureByTypeName(schema.baseType)) {
+            warningLog(`Cannot find schema for ${schema.baseType} in dataTypeFactory for ${schema.name}: fix me !`);
+            return undefined;
         }
-        const baseType = getStructureTypeConstructor(schema.baseType);
+        const structureInfo = dataTypeFactory.getStructureInfoByTypeName(schema.baseType);
 
         // istanbul ignore next
-        if (!baseType) {
+        if (!structureInfo) {
             throw new Error(" cannot find factory for " + schema.baseType);
         }
-        if (baseType.prototype.schema) {
-            baseSchema = baseType.prototype.schema;
+        if (structureInfo.schema) {
+            return structureInfo.schema;
         }
     }
     // put in  cache for speedup
-    schema._baseSchema = baseSchema;
-    return baseSchema;
+    return null;
 }
 
 /**
@@ -253,25 +277,18 @@ export function get_base_schema(schema: IStructuredTypeSchema): IStructuredTypeS
  * (by walking up the inheritance chain)
  *
  */
-export function extract_all_fields(schema: IStructuredTypeSchema): string[] {
+export function extractAllPossibleFields(schema: IStructuredTypeSchema): string[] {
     // returns cached result if any
     // istanbul ignore next
-    if (schema._possibleFields) {
-        return schema._possibleFields;
-    }
     // extract the possible fields from the schema.
     let possibleFields = schema.fields.map((field) => field.name);
 
-    const baseSchema = get_base_schema(schema);
-
+    const baseSchema = schema.getBaseSchema();
     // istanbul ignore next
     if (baseSchema) {
-        const fields = extract_all_fields(baseSchema);
+        const fields = extractAllPossibleFields(baseSchema);
         possibleFields = fields.concat(possibleFields);
     }
-
-    // put in cache to speed up
-    schema._possibleFields = possibleFields;
     return possibleFields;
 }
 
@@ -304,7 +321,7 @@ export function check_options_correctness_against_schema(obj: any, schema: IStru
     }
 
     // extract the possible fields from the schema.
-    const possibleFields: string[] = obj.constructor.possibleFields || schema._possibleFields;
+    const possibleFields: string[] = obj.constructor.possibleFields || extractAllPossibleFields(schema);
 
     // extracts the fields exposed by the option object
     const currentFields = Object.keys(options);
@@ -335,6 +352,9 @@ export function check_options_correctness_against_schema(obj: any, schema: IStru
     return true;
 }
 
-export function buildStructuredType(schemaLight: StructuredTypeOptions): StructuredTypeSchema {
-    return new StructuredTypeSchema(schemaLight);
+export function buildStructuredType(schemaLight: Omit<StructuredTypeOptions, "dataTypeFactory">): IStructuredTypeSchema {
+    return new StructuredTypeSchema({
+        ...schemaLight,
+        dataTypeFactory: getStandardDataTypeFactory()
+    });
 }