node-opcua-schemas 2.76.2 → 2.78.0

package/source/dynamic_extension_object.ts

@@ -4,6 +4,7 @@
 import { assert } from "node-opcua-assert";
 import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
 import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
+import { sameNodeId } from "node-opcua-nodeid";
 import { decodeExtensionObject, encodeExtensionObject, ExtensionObject } from "node-opcua-extension-object";
 import { DataType } from "node-opcua-variant";
 
@@ -17,8 +18,7 @@ import {
     initialize_field,
     initialize_field_array,
     IStructuredTypeSchema,
-    StructuredTypeField,
-    StructuredTypeSchema
+    StructuredTypeField
 } from "node-opcua-factory";
 
 import { coerceNodeId, ExpandedNodeId, NodeId, NodeIdType } from "node-opcua-nodeid";
@@ -33,8 +33,9 @@ export function getOrCreateConstructor(
     encodingDefaultBinary?: ExpandedNodeId,
     encodingDefaultXml?: ExpandedNodeId
 ): AnyConstructorFunc {
-    if (dataTypeFactory.hasStructuredType(dataTypeName)) {
-        return dataTypeFactory.getStructureTypeConstructor(dataTypeName) as unknown as AnyConstructorFunc;
+    if (dataTypeFactory.hasStructureByTypeName(dataTypeName)) {
+        const structureInfo = dataTypeFactory.getStructureInfoByTypeName(dataTypeName);
+        return (structureInfo.constructor || ExtensionObject) as AnyConstructorFunc;
     }
     const schema = dataTypeFactory.getStructuredTypeSchema(dataTypeName);
 
@@ -46,11 +47,11 @@ export function getOrCreateConstructor(
     const constructor = createDynamicObjectConstructor(schema, dataTypeFactory);
 
     if (!constructor) {
-        return constructor;
+        return ExtensionObject as AnyConstructorFunc;
     }
     // istanbul ignore next
-    if (!dataTypeFactory.hasStructuredType(dataTypeName)) {
-        dataTypeFactory.registerClassDefinition(schema.id, dataTypeName, constructor as ConstructorFuncWithSchema);
+    if (!dataTypeFactory.hasStructureByTypeName(dataTypeName)) {
+        dataTypeFactory.registerClassDefinition(schema.dataTypeNodeId, dataTypeName, constructor as ConstructorFuncWithSchema);
         return constructor;
         // hrow new Error("constructor should now be registered - " + fieldType);
     }
@@ -109,7 +110,7 @@ function encodeArrayOrElement(
 }
 
 function decodeElement(
-    factory: DataTypeFactory,
+    dataTypeFactory: DataTypeFactory,
     field: FieldType,
     stream: BinaryStream,
     decodeFunc?: (stream: BinaryStream) => any
@@ -122,15 +123,18 @@ function decodeElement(
             return element;
         } else {
             // construct an instance
-            const constructor = factory.getStructureTypeConstructor(field.fieldType);
-            const element = new constructor({});
+            const structureInfo = dataTypeFactory.getStructureInfoByTypeName(field.fieldType);
+            if (!structureInfo.constructor) {
+                throw new Error("Cannot instantiate an abstract dataStructure: " + field.fieldType);
+            }
+            const element = new structureInfo.constructor({});
             element.decode(stream);
             return element;
         }
     }
 }
 function decodeArrayOrElement(
-    factory: DataTypeFactory,
+    dataTypeFactory: DataTypeFactory,
     field: FieldType,
     obj: any,
     stream: BinaryStream,
@@ -143,29 +147,30 @@ function decodeArrayOrElement(
             obj[field.name] = null;
         } else {
             for (let i = 0; i < nbElements; i++) {
-                const element = decodeElement(factory, field, stream, decodeFunc);
+                const element = decodeElement(dataTypeFactory, field, stream, decodeFunc);
                 array.push(element);
             }
             obj[field.name] = array;
         }
     } else {
-        obj[field.name] = decodeElement(factory, field, stream, decodeFunc);
+        obj[field.name] = decodeElement(dataTypeFactory, field, stream, decodeFunc);
     }
 }
 
-function isSubtype(factory: DataTypeFactory, dataTypeNodeId: NodeId, schema: IStructuredTypeSchema): boolean {
-    if (dataTypeNodeId.toString() === schema.dataTypeNodeId.toString()) {
+function isSubtype(dataTypeFactory: DataTypeFactory, dataTypeNodeId: NodeId, schema: IStructuredTypeSchema): boolean {
+    if (sameNodeId(dataTypeNodeId, schema.dataTypeNodeId)) {
         return true;
     }
-    if (!schema._baseSchema || !schema._baseSchema?.dataTypeNodeId) return false;
-    const c = factory.getConstructorForDataType(schema._baseSchema.dataTypeNodeId);
-    if (!c) {
+    const baseSchema = schema.getBaseSchema();
+    if (!baseSchema || !baseSchema?.dataTypeNodeId) return false;
+    const structureInfo = dataTypeFactory.getStructureInfoForDataType(baseSchema.dataTypeNodeId);
+    if (!structureInfo) {
         return false;
     }
-    return isSubtype(factory, dataTypeNodeId, c.schema);
+    return isSubtype(dataTypeFactory, dataTypeNodeId, structureInfo.schema);
 }
 
-function _validateSubType(factory: DataTypeFactory, field: StructuredTypeField, value: any): void {
+function _validateSubType(dataTypeFactory: DataTypeFactory, field: StructuredTypeField, value: any): void {
     assert(field.allowSubType);
     if (!value) {
         value = { dataType: DataType.Null, value: null };
@@ -180,8 +185,8 @@ function _validateSubType(factory: DataTypeFactory, field: StructuredTypeField,
             errorLog(msg);
             throw new Error(msg);
         }
-        const c = factory.getBuiltInTypeByDataType(coerceNodeId(`i=${value.dataType}`, 0));
-        const d = factory.getBuiltInType(field.fieldType);
+        const c = dataTypeFactory.getBuiltInTypeByDataType(coerceNodeId(`i=${value.dataType}`, 0));
+        const d = dataTypeFactory.getBuiltInType(field.fieldType);
         if (c && c.isSubTypeOf(d)) {
             return;
         }
@@ -201,14 +206,14 @@ function _validateSubType(factory: DataTypeFactory, field: StructuredTypeField,
             throw new Error(`${field.name}: array element must be an ExtensionObject`);
         }
         const e = value as ExtensionObject;
-        if (!isSubtype(factory, field.dataType!, e.schema)) {
+        if (!isSubtype(dataTypeFactory, field.dataType!, e.schema)) {
             const msg =
                 "initializeField: invalid subtype for field " +
                 field.name +
                 " expecting " +
                 field.fieldType +
                 " but got " +
-                e.schema.id.toString() +
+                e.schema.dataTypeNodeId.toString() +
                 " " +
                 e.schema.name;
             errorLog(msg);
@@ -216,24 +221,24 @@ function _validateSubType(factory: DataTypeFactory, field: StructuredTypeField,
         }
     }
 }
-function validateSubTypeA(factory: DataTypeFactory, field: FieldType, value: any) {
+function validateSubTypeA(dataTypeFactory: DataTypeFactory, field: FieldType, value: any) {
     if (field.isArray) {
         const arr = (value as unknown[]) || [];
         for (const e of arr) {
             // now check that element is of the correct type
-            _validateSubType(factory, field, e);
+            _validateSubType(dataTypeFactory, field, e);
         }
     } else {
-        _validateSubType(factory, field, value);
+        _validateSubType(dataTypeFactory, field, value);
     }
 }
 
 function initializeField(
     field: FieldType,
-    thisAny: any,
+    thisAny: Record<string, unknown>,
     options: Record<string, unknown>,
     schema: IStructuredTypeSchema,
-    factory: DataTypeFactory
+    dataTypeFactory: DataTypeFactory
 ) {
     const name = field.name;
     const value = getFieldValue(field, options);
@@ -241,7 +246,7 @@ function initializeField(
     switch (field.category) {
         case FieldCategory.complex: {
             if (field.allowSubType) {
-                validateSubTypeA(factory, field, value);
+                validateSubTypeA(dataTypeFactory, field, value);
                 if (field.isArray) {
                     const arr = (value as unknown[]) || [];
                     thisAny[name] = arr.map((x: any) => x.clone());
@@ -254,12 +259,15 @@ function initializeField(
                     thisAny[name] = e.clone();
                 }
             } else {
-                const constructor = factory.getStructureTypeConstructor(field.fieldType);
+                const constructor = dataTypeFactory.getStructureInfoByTypeName(field.fieldType).constructor;
+                if (!constructor) {
+                    throw new Error("Cannot instantiate an abstract dataType" + field.fieldType);
+                }
                 if (field.isArray) {
                     const arr = (value as unknown[]) || [];
                     thisAny[name] = arr.map((x: any) => (constructor ? new constructor(x) : null));
                 } else {
-                    thisAny[name] = constructor ? new constructor(value) : null;
+                    thisAny[name] = constructor ? new constructor(value as Record<string, unknown>) : null;
                 }
             }
             // getOrCreateConstructor(field.fieldType, factory) || BaseUAObject;
@@ -269,12 +277,12 @@ function initializeField(
         case FieldCategory.enumeration:
         case FieldCategory.basic:
             if (field.allowSubType) {
-                validateSubTypeA(factory, field, value);
+                validateSubTypeA(dataTypeFactory, field, value);
             }
             if (field.isArray) {
-                thisAny[name] = initialize_field_array(field, value, factory);
+                thisAny[name] = initialize_field_array(field, value, dataTypeFactory);
             } else {
-                thisAny[name] = initialize_field(field, value, factory);
+                thisAny[name] = initialize_field(field, value, dataTypeFactory);
             }
             break;
     }
@@ -289,15 +297,16 @@ function getFieldValue(field: FieldType, options: Record<string, unknown>) {
 }
 
 function initializeFields(
-    thisAny: any,
+    thisAny: Record<string, unknown>,
     options: Record<string, unknown>,
     schema: IStructuredTypeSchema,
-    factory: DataTypeFactory,
+    dataTypeFactory: DataTypeFactory,
     params: InitializeFieldOptions
 ) {
+    const baseSchema = schema.getBaseSchema();
     // initialize base class first
-    if (schema._baseSchema && schema._baseSchema.fields.length) {
-        initializeFields(thisAny, options, schema._baseSchema!, factory, params);
+    if (baseSchema && baseSchema.fields.length) {
+        initializeFields(thisAny, options, baseSchema, dataTypeFactory, params);
     }
     // finding fields that are in options but not in schema!
     for (const field of schema.fields) {
@@ -309,7 +318,7 @@ function initializeFields(
             thisAny[name] = undefined;
             continue;
         }
-        initializeField(field, thisAny, options, schema, factory);
+        initializeField(field, thisAny, options, schema, dataTypeFactory);
     }
 }
 
@@ -317,13 +326,15 @@ function hasOptionalFieldsF(schema: IStructuredTypeSchema): boolean {
     if (schema.bitFields && schema.bitFields.length > 0) {
         return true;
     }
-    return schema._baseSchema ? hasOptionalFieldsF(schema._baseSchema) : false;
+    const baseSchema = schema.getBaseSchema();
+    return baseSchema ? hasOptionalFieldsF(baseSchema) : false;
 }
 
 function _internal_encodeFields(thisAny: any, schema: IStructuredTypeSchema, stream: OutputBinaryStream) {
+    const baseSchema = schema.getBaseSchema();
     // encodeFields base class first
-    if (schema._baseSchema && schema._baseSchema.fields.length) {
-        _internal_encodeFields(thisAny, schema._baseSchema!, stream);
+    if (baseSchema && baseSchema.fields.length) {
+        _internal_encodeFields(thisAny, baseSchema, stream);
     }
     for (const field of schema.fields) {
         // ignore
@@ -351,7 +362,8 @@ interface BitfieldOffset {
     allOptional: boolean;
 }
 function makeBitField(thisAny: any, schema: IStructuredTypeSchema, bo: BitfieldOffset): BitfieldOffset {
-    const data = schema._baseSchema ? makeBitField(thisAny, schema._baseSchema, bo) : bo;
+    const baseSchema = schema.getBaseSchema();
+    const data = baseSchema ? makeBitField(thisAny, baseSchema, bo) : bo;
     let { bitField, allOptional } = data;
     const { offset } = data;
 
@@ -389,11 +401,12 @@ function internal_decodeFields(
     hasOptionalFields: boolean,
     schema: IStructuredTypeSchema,
     stream: BinaryStream,
-    factory: DataTypeFactory
+    dataTypeFactory: DataTypeFactory
 ) {
+    const baseSchema = schema.getBaseSchema();
     // encodeFields base class first
-    if (schema._baseSchema && schema._baseSchema.fields.length) {
-        internal_decodeFields(thisAny, bitField, hasOptionalFields, schema._baseSchema, stream, factory);
+    if (baseSchema && baseSchema.fields.length) {
+        internal_decodeFields(thisAny, bitField, hasOptionalFields, baseSchema, stream, dataTypeFactory);
     }
     for (const field of schema.fields) {
         // ignore fields that have a switch bit when bit is not set
@@ -405,18 +418,18 @@ function internal_decodeFields(
             } else {
                 if (field.category === FieldCategory.complex && thisAny[field.name] === undefined) {
                     // need to create empty structure for deserialisation
-                    initializeField(field, thisAny, {}, schema, factory);
+                    initializeField(field, thisAny, {}, schema, dataTypeFactory);
                 }
             }
         }
 
         switch (field.category) {
             case FieldCategory.complex:
-                decodeArrayOrElement(factory, field, thisAny, stream);
+                decodeArrayOrElement(dataTypeFactory, field, thisAny, stream);
                 break;
             case FieldCategory.enumeration:
             case FieldCategory.basic:
-                decodeArrayOrElement(factory, field, thisAny, stream, field.schema.decode);
+                decodeArrayOrElement(dataTypeFactory, field, thisAny, stream, field.schema.decode);
                 break;
             default:
                 /* istanbul ignore next*/
@@ -425,7 +438,7 @@ function internal_decodeFields(
     }
 }
 
-function decodeFields(thisAny: any, schema: IStructuredTypeSchema, stream: BinaryStream, factory: DataTypeFactory) {
+function decodeFields(thisAny: any, schema: IStructuredTypeSchema, stream: BinaryStream, dataTypeFactory: DataTypeFactory) {
     // ============ Deal with switchBits
     const hasOptionalFields = hasOptionalFieldsF(schema);
     let bitField = 0;
@@ -433,7 +446,7 @@ function decodeFields(thisAny: any, schema: IStructuredTypeSchema, stream: Binar
         bitField = stream.readUInt32();
     }
 
-    internal_decodeFields(thisAny, bitField, hasOptionalFields, schema, stream, factory);
+    internal_decodeFields(thisAny, bitField, hasOptionalFields, schema, stream, dataTypeFactory);
 }
 
 function ___fieldToJson(field: FieldType, value: any): any {
@@ -458,8 +471,9 @@ function fieldToJSON(field: FieldType, value: any): any {
     }
 }
 function encodeToJson(thisAny: any, schema: IStructuredTypeSchema, pojo: any) {
-    if (schema._baseSchema && schema._baseSchema.fields.length) {
-        encodeToJson(thisAny, schema._baseSchema!, pojo);
+    const baseSchema = schema.getBaseSchema();
+    if (baseSchema && baseSchema.fields.length) {
+        encodeToJson(thisAny, baseSchema, pojo);
     }
     for (const field of schema.fields) {
         const value = (thisAny as any)[field.name];
@@ -472,7 +486,7 @@ function encodeToJson(thisAny: any, schema: IStructuredTypeSchema, pojo: any) {
 
 interface T {
     factory?: DataTypeFactory;
-    schema?: StructuredTypeSchema;
+    schema?: IStructuredTypeSchema;
 }
 const _private = new WeakMap<T>();
 
@@ -480,18 +494,18 @@ export class DynamicExtensionObject extends ExtensionObject {
     public static schema: IStructuredTypeSchema = ExtensionObject.schema;
     public static possibleFields: string[] = [];
 
-    constructor(options: Record<string, unknown>, schema: IStructuredTypeSchema, factory: DataTypeFactory) {
+    constructor(options: Record<string, unknown>, schema: IStructuredTypeSchema, dataTypeFactory: DataTypeFactory) {
         assert(schema, "expecting a schema here ");
-        assert(factory, "expecting a DataTypeFactory");
+        assert(dataTypeFactory, "expecting a DataTypeFactory");
 
         super(options);
         options = options || {};
 
-        _private.set(this, { schema, factory });
+        _private.set(this, { schema, factory: dataTypeFactory });
 
         check_options_correctness_against_schema(this, this.schema, options);
 
-        initializeFields(this as any, options, this.schema, factory, { caseInsensitive: true });
+        initializeFields(this as Record<string, unknown>, options, this.schema, dataTypeFactory, { caseInsensitive: true });
     }
 
     public encode(stream: OutputBinaryStream): void {
@@ -504,7 +518,7 @@ export class DynamicExtensionObject extends ExtensionObject {
         decodeFields(this, this.schema, stream, _private.get(this).factory);
     }
 
-    public get schema(): StructuredTypeSchema {
+    public get schema(): IStructuredTypeSchema {
         const r = _private.get(this);
         return r.schema!;
     }
@@ -528,11 +542,11 @@ export type AnyConstructorFunc = AnyConstructable;
 // tslint:disable-next-line:max-classes-per-file
 class UnionBaseClass extends BaseUAObject {
     // eslint-disable-next-line max-statements
-    constructor(options: any, schema: IStructuredTypeSchema, factory: DataTypeFactory) {
+    constructor(options: any, schema: IStructuredTypeSchema, dataTypeFactory: DataTypeFactory) {
         super();
 
         assert(schema, "expecting a schema here ");
-        assert(factory, "expecting a typeDic");
+        assert(dataTypeFactory, "expecting a typeDic");
         options = options || {};
 
         _private.set(this, { schema });
@@ -585,12 +599,15 @@ class UnionBaseClass extends BaseUAObject {
 
             switch (field.category) {
                 case FieldCategory.complex: {
-                    const constuctor = factory.getStructureTypeConstructor(field.fieldType);
+                    const Constructor = dataTypeFactory.getStructureInfoByTypeName(field.fieldType).constructor;
+                    if (!Constructor) {
+                        throw new Error("Cannot instantiate an abstract dataType" + field.fieldType);
+                    }
                     // getOrCreateConstructor(field.fieldType, factory) || BaseUAObject;
                     if (field.isArray) {
-                        (this as any)[name] = ((value as any) || []).map((x: any) => (constuctor ? new constuctor(x) : null));
+                        (this as any)[name] = ((value as any) || []).map((x: any) => (Constructor ? new Constructor(x) : null));
                     } else {
-                        (this as any)[name] = constuctor ? new constuctor(value) : null;
+                        (this as any)[name] = Constructor ? new Constructor(value as Record<string, unknown>) : null;
                     }
                     // xx processStructuredType(fieldSchema);
                     break;
@@ -659,7 +676,7 @@ class UnionBaseClass extends BaseUAObject {
     }
 
     public decode(stream: BinaryStream): void {
-        const factory: DataTypeFactory = (this.schema as any).$$factory;
+        const factory = this.schema.getDataTypeFactory();
 
         const switchValue = stream.readUInt32();
         const switchFieldName = this.schema.fields[0].name;
@@ -687,7 +704,7 @@ class UnionBaseClass extends BaseUAObject {
         }
     }
 
-    public get schema(): StructuredTypeSchema {
+    public get schema(): IStructuredTypeSchema {
         return _private.get(this).schema!;
     }
 
@@ -720,16 +737,22 @@ class UnionBaseClass extends BaseUAObject {
     }
 }
 
-function _createDynamicUnionConstructor(schema: IStructuredTypeSchema, factory: DataTypeFactory): AnyConstructorFunc {
+function _createDynamicUnionConstructor(
+    schema: IStructuredTypeSchema,
+    dataTypeFactory: DataTypeFactory
+): ConstructorFuncWithSchema {
     const possibleFields = schema.fields.map((x: FieldType) => x.name);
 
     // tslint:disable-next-line:max-classes-per-file
     class UNION extends UnionBaseClass {
         public static possibleFields = possibleFields;
         public static schema = schema;
+        static encodingDefaultBinary: ExpandedNodeId;
+        static encodingDefaultXml: ExpandedNodeId;
+        static encodingDefaultJson?: ExpandedNodeId;
 
         constructor(options?: any) {
-            super(options, schema, factory);
+            super(options, schema, dataTypeFactory);
             assert(this.schema === schema);
         }
     }
@@ -739,17 +762,19 @@ function _createDynamicUnionConstructor(schema: IStructuredTypeSchema, factory:
 
     return UNION;
 }
-
+interface IStructuredTypeSchemaEx extends IStructuredTypeSchema {
+    $Constructor: any;
+}
 export function createDynamicObjectConstructor(
     schema: IStructuredTypeSchema,
     dataTypeFactory: DataTypeFactory
-): AnyConstructorFunc {
-    const schemaPriv = schema as any;
+): ConstructorFuncWithSchema {
+    const schemaPriv = schema as IStructuredTypeSchemaEx;
 
     if (schemaPriv.$Constructor) {
         return schemaPriv.$Constructor;
     }
-    const dataTypeNodeId = schemaPriv.id;
+    const dataTypeNodeId = schemaPriv.dataTypeNodeId;
 
     if (schema.baseType === "Union") {
         const UNIONConstructor = _createDynamicUnionConstructor(schema, dataTypeFactory);
@@ -771,22 +796,23 @@ export function createDynamicObjectConstructor(
         schema.baseType !== "Structure"
     ) {
         try {
-            const baseSchema = dataTypeFactory.getStructuredTypeSchema(schema.baseType);
-            schema._baseSchema = baseSchema;
-            if (baseSchema.encodingDefaultBinary?.value === 0) {
+            const baseSchema = schema.getBaseSchema(); // dataTypeFactory.getStructuredTypeSchema(schema.baseType);
+            if (!baseSchema || baseSchema.encodingDefaultBinary?.value === 0) {
                 // is abstract
             } else {
-                BaseClass = getOrCreateConstructor(schema.baseType, dataTypeFactory);
-                if (!BaseClass) {
-                    throw new Error("Cannot find base class : " + schema.baseType);
-                }
-                if ((BaseClass as any).possibleFields) {
-                    possibleFields = (BaseClass as any).possibleFields.concat(possibleFields);
+                if (!baseSchema.isAbstract) {
+                    // to do : check this
+                    BaseClass = getOrCreateConstructor(schema.baseType, dataTypeFactory);
+                    if (!BaseClass) {
+                        throw new Error("Cannot find base class : " + schema.baseType);
+                    }
+                    if ((BaseClass as any).possibleFields) {
+                        possibleFields = (BaseClass as any).possibleFields.concat(possibleFields);
+                    }
                 }
-                schema._baseSchema = BaseClass.schema;
             }
         } catch (err) {
-            // xx console.log("createDynamicObjectConstructor err= ", err.message);
+            console.log("createDynamicObjectConstructor err= ", (err as Error).message);
         }
     }
 
@@ -822,10 +848,9 @@ export function createDynamicObjectConstructor(
 
     // to do : may be remove DataType suffix here ?
     Object.defineProperty(EXTENSION, "name", { value: schema.name });
-
     schemaPriv.$Constructor = EXTENSION;
-    (EXTENSION as any).encodingDefaultBinary = schema.encodingDefaultBinary;
-    dataTypeFactory.registerClassDefinition(dataTypeNodeId, schema.name, EXTENSION as any);
+    EXTENSION.encodingDefaultBinary = schema.encodingDefaultBinary!;
+    dataTypeFactory.registerClassDefinition(dataTypeNodeId, schema.name, EXTENSION as ConstructorFuncWithSchema);
 
-    return EXTENSION;
+    return EXTENSION as ConstructorFuncWithSchema;
 }