node-opcua-factory 2.72.1 → 2.74.0

package/source/index.ts

@@ -1,15 +1,18 @@
 /**
  * @module node-opcua-factory
  */
-export * from "./constructor_type";
+export * from "./base_ua_object";
+export * from "./basic_type";
+export * from "./builtin_types_special";
+export * from "./builtin_types";
 export * from "./datatype_factory";
-export * from "./factories_id_generator";
-export * from "./factories_enumerations";
-export * from "./factories_basic_type";
-export * from "./factories_builtin_types";
-export * from "./factories_builtin_types_special";
-export * from "./factories_baseobject";
-export * from "./types";
-export * from "./factories_schema_helpers";
-export * from "./factories_factories";
-export * from "./factories_structuredTypeSchema";
+export * from "./enumerations";
+export * from "./get_standard_data_type_factory";
+export * from "./get_structured_type_schema";
+export * from "./id_generator";
+export * from "./nodeid_type";
+export * from "./parameters";
+export * from "./register_class_definition";
+export * from "./schema_helpers";
+export * from "./structured_type_schema";
+export * from "./types";

package/source/nodeid_type.ts

@@ -0,0 +1,17 @@
+import { registerEnumeration } from "./enumerations";
+
+
+
+export enum NodeIdType {
+    ReferenceType = 0x01,
+    IsForward = 0x02,
+    NodeClass = 0x04,
+    BrowseName = 0x08,
+    DisplayName = 0x10,
+    TypeDefinition = 0x20
+}
+export const schemaNodeIdType = {
+    name: "NodeIdType",
+    enumValues: NodeIdType
+};
+export const _enumerationNodeIdType = registerEnumeration(schemaNodeIdType);

package/source/parameters.ts

@@ -0,0 +1,3 @@
+export const parameters = {
+    debugSchemaHelper: typeof process === "object" && !!process.env.DEBUG_CLASS
+};

package/source/register_class_definition.ts

@@ -0,0 +1,11 @@
+import { NodeId } from "node-opcua-nodeid";
+import { getStandardDataTypeFactory } from "./get_standard_data_type_factory";
+import { ConstructorFuncWithSchema } from "./types";
+
+export function registerClassDefinition(
+    dataTypeNodeId: NodeId,
+    className: string,
+    classConstructor: ConstructorFuncWithSchema
+): void {
+    return getStandardDataTypeFactory().registerClassDefinition(dataTypeNodeId, className, classConstructor);
+}

package/source/{factories_schema_helpers.ts → schema_helpers.ts}

@@ -3,14 +3,13 @@
  */
 import { assert } from "node-opcua-assert";
 import { make_debugLog } from "node-opcua-debug";
-import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
-import { CommonInterface, FieldCategory, FieldType, StructuredTypeField } from "./types";
+import { DataTypeIds } from "node-opcua-constants";
+import { DataTypeFactory } from "./datatype_factory";
+import { BaseUAObject } from "./base_ua_object";
+import { FieldCategory, FieldType, IStructuredTypeSchema, StructuredTypeField } from "./types";
 
 const debugLog = make_debugLog(__filename);
 
-export const parameters = {
-    debugSchemaHelper: (typeof process === "object" && !!process.env.DEBUG_CLASS)
-};
 
 /**
  * ensure correctness of a schema object.
@@ -19,20 +18,27 @@ export const parameters = {
  * @param schema
  *
  */
-export function check_schema_correctness(schema: StructuredTypeSchema): void {
+export function check_schema_correctness(schema: IStructuredTypeSchema): void {
     assert(typeof schema.name === "string", " expecting schema to have a name");
     assert(schema.fields instanceof Array, " expecting schema to provide a set of fields " + schema.name);
     assert(schema.baseType === undefined || typeof schema.baseType === "string");
 }
 
+
 /**
  * @method initialize_value
  * @param value
  * @param defaultValue
  * @return {*}
  */
-export function initialize_field(field: StructuredTypeField, value: unknown): any {
+export function initialize_field(field: StructuredTypeField, value: unknown, factory?: DataTypeFactory): any {
     const _t = field.schema;
+
+    if (field.allowSubType && field.category === "complex") {
+        if (value instanceof BaseUAObject) {
+            value = { dataType: DataTypeIds.Structure, value };
+        }
+    }
     if (!(_t !== null && typeof _t === "object")) {
         throw new Error(
             "initialize_field: expecting field.schema to be set field.name = '" + field.name + "' type = " + field.fieldType
@@ -71,21 +77,6 @@ export function initialize_field(field: StructuredTypeField, value: unknown): an
     return value;
 }
 
-function initialize_value(value: any, defaultValue: any, _t: CommonInterface) {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    if (defaultValue === null) {
-        if (value === null) {
-            return null;
-        }
-    }
-    if (_t.coerce) {
-        value = _t.coerce(value);
-        return value;
-    }
-    return value;
-}
 /**
  * @method initialize_field_array
  * @param field
@@ -93,7 +84,7 @@ function initialize_value(value: any, defaultValue: any, _t: CommonInterface) {
  * @return
  */
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export function initialize_field_array(field: FieldType, valueArray: any): any {
+export function initialize_field_array(field: FieldType, valueArray: any, factory?: DataTypeFactory): any {
     const _t = field.schema;
 
     let value;
@@ -104,24 +95,11 @@ export function initialize_field_array(field: FieldType, valueArray: any): any {
     if (!valueArray && field.defaultValue === null) {
         return null;
     }
-
     valueArray = valueArray || [];
-
-    let defaultValue: any;
-    if (_t.computer_default_value) {
-        defaultValue = _t.computer_default_value(field.defaultValue);
-    }
     const arr: unknown[] = [];
     for (i = 0; i < valueArray.length; i++) {
-        value = initialize_value(valueArray[i], defaultValue, _t);
+        value = initialize_field(field, valueArray[i], factory);
         arr.push(value);
     }
-    if (field.validate) {
-        for (i = 0; i < arr.length; i++) {
-            if (!field.validate(arr[i])) {
-                throw Error(" invalid value " + arr[i] + " for field " + field.name + " of type " + field.fieldType);
-            }
-        }
-    }
     return arr;
 }

package/source/{factories_structuredTypeSchema.ts → structured_type_schema.ts}

@@ -8,13 +8,19 @@ import { BinaryStream } from "node-opcua-binary-stream";
 import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
 import { lowerFirstLetter } from "node-opcua-utils";
 
-import { getBuildInType, hasBuiltInType } from "./factories_builtin_types";
-import { getEnumeration, hasEnumeration } from "./factories_enumerations";
-import { getStructuredTypeSchema, getStructureTypeConstructor, hasStructuredType } from "./factories_factories";
-import { parameters } from "./factories_schema_helpers";
-import { DataTypeFactory } from "./datatype_factory";
-import { CommonInterface, FieldCategory, FieldInterfaceOptions, FieldType, StructuredTypeOptions, TypeSchemaBase } from "./types";
-import { BaseUAObject } from "./factories_baseobject";
+import { getBuiltInType, hasBuiltInType, TypeSchemaBase } from "./builtin_types";
+import { getBuiltInEnumeration, hasBuiltInEnumeration } from "./enumerations";
+import { parameters } from "./parameters";
+import { getStructureTypeConstructor, hasStructuredType } from "./get_standard_data_type_factory";
+import { getStructuredTypeSchema } from "./get_structured_type_schema";
+import {
+    CommonInterface,
+    FieldCategory,
+    FieldInterfaceOptions,
+    FieldType,
+    IStructuredTypeSchema,
+    StructuredTypeOptions
+} from "./types";
 
 function figureOutFieldCategory(field: FieldInterfaceOptions): FieldCategory {
     const fieldType = field.fieldType;
@@ -23,7 +29,7 @@ function figureOutFieldCategory(field: FieldInterfaceOptions): FieldCategory {
         return field.category;
     }
 
-    if (hasEnumeration(fieldType)) {
+    if (hasBuiltInEnumeration(fieldType)) {
         return FieldCategory.enumeration;
     } else if (hasBuiltInType(fieldType)) {
         return FieldCategory.basic;
@@ -65,12 +71,12 @@ function figureOutSchema(
                 returnValue = getStructuredTypeSchema(fieldTypeWithoutNS);
             } else {
                 // LocalizedText etc ...
-                returnValue = getBuildInType(fieldTypeWithoutNS);
+                returnValue = getBuiltInType(fieldTypeWithoutNS);
             }
             break;
         case FieldCategory.basic:
-            returnValue = getBuildInType(fieldTypeWithoutNS);
-            if(!returnValue) {
+            returnValue = getBuiltInType(fieldTypeWithoutNS);
+            if (!returnValue) {
                 returnValue = getStructuredTypeSchema(fieldTypeWithoutNS);
                 if (returnValue) {
                     console.log("Why ?");
@@ -78,14 +84,13 @@ function figureOutSchema(
             }
             break;
         case FieldCategory.enumeration:
-            returnValue = getEnumeration(fieldTypeWithoutNS);
+            returnValue = getBuiltInEnumeration(fieldTypeWithoutNS);
             break;
     }
     if (null === returnValue || undefined === returnValue) {
         try {
-            returnValue = getEnumeration(fieldTypeWithoutNS);
-        }
-        catch(err){
+            returnValue = getBuiltInEnumeration(fieldTypeWithoutNS);
+        } catch (err) {
             console.log(err);
         }
         throw new Error(
@@ -119,32 +124,32 @@ function buildField(underConstructSchema: StructuredTypeSchema, fieldLight: Fiel
         );
     }
 
+    const { defaultValue, isArray, documentation, fieldType, switchBit, switchValue, allowSubType, dataType, basicDataType } =
+        fieldLight;
     return {
         name: lowerFirstLetter(fieldLight.name),
-
+        originalName: fieldLight.name,
         category,
-        defaultValue: fieldLight.defaultValue,
-        isArray: fieldLight.isArray,
-
-        documentation: fieldLight.documentation,
-        fieldType: fieldLight.fieldType,
-
-        switchBit: fieldLight.switchBit,
-
-        switchValue: fieldLight.switchValue,
-
+        defaultValue,
+        isArray,
+        documentation,
+        fieldType,
+        switchBit,
+        switchValue,
+        allowSubType,
+        dataType,
+        basicDataType,
         schema
     };
 }
-
-export class StructuredTypeSchema extends TypeSchemaBase {
+export class StructuredTypeSchema extends TypeSchemaBase implements IStructuredTypeSchema {
     public fields: FieldType[];
     public id: NodeId;
     public dataTypeNodeId: NodeId;
 
     public baseType: string;
     public _possibleFields: string[];
-    public _baseSchema: StructuredTypeSchema | null;
+    public _baseSchema: IStructuredTypeSchema | null;
 
     public documentation?: string;
 
@@ -211,7 +216,7 @@ export class StructuredTypeSchema extends TypeSchemaBase {
  * @return {*}
  *
  */
-export function get_base_schema(schema: StructuredTypeSchema): StructuredTypeSchema | null {
+export function get_base_schema(schema: IStructuredTypeSchema): IStructuredTypeSchema | null {
     let baseSchema = schema._baseSchema;
     if (baseSchema) {
         return baseSchema;
@@ -248,7 +253,7 @@ export function get_base_schema(schema: StructuredTypeSchema): StructuredTypeSch
  * (by walking up the inheritance chain)
  *
  */
-export function extract_all_fields(schema: StructuredTypeSchema): string[] {
+export function extract_all_fields(schema: IStructuredTypeSchema): string[] {
     // returns cached result if any
     // istanbul ignore next
     if (schema._possibleFields) {
@@ -276,7 +281,7 @@ export function extract_all_fields(schema: StructuredTypeSchema): string[] {
  * @method  check_options_correctness_against_schema
  *
  */
-export function check_options_correctness_against_schema(obj: any, schema: StructuredTypeSchema, options: any): boolean {
+export function check_options_correctness_against_schema(obj: any, schema: IStructuredTypeSchema, options: any): boolean {
     if (!parameters.debugSchemaHelper) {
         return true; // ignoring set
     }
@@ -330,10 +335,6 @@ export function check_options_correctness_against_schema(obj: any, schema: Struc
     return true;
 }
 
-export function buildStructuredType2(dataTypeFactory: DataTypeFactory, schemaLight: StructuredTypeOptions): StructuredTypeSchema {
-    return new StructuredTypeSchema(schemaLight);
-}
-
 export function buildStructuredType(schemaLight: StructuredTypeOptions): StructuredTypeSchema {
     return new StructuredTypeSchema(schemaLight);
 }

package/source/types.ts

@@ -1,11 +1,15 @@
 /**
  * @module node-opcua-factory
  */
-import { assert } from "node-opcua-assert";
 import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
-import { Enum, EnumItem } from "node-opcua-enum";
-import { NodeId } from "node-opcua-nodeid";
-import { ConstructorFunc } from "./constructor_type";
+import { Enum } from "node-opcua-enum";
+import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
+
+export enum FieldCategory {
+    enumeration = "enumeration",
+    complex = "complex",
+    basic = "basic"
+}
 
 // ------------------
 //  @brief CommonInterface
@@ -15,44 +19,93 @@ import { ConstructorFunc } from "./constructor_type";
 //
 export interface CommonInterface {
     name: string;
+    defaultValue?: any;
 
     encode?: (value: any, stream: OutputBinaryStream) => void;
     decode?: (stream: BinaryStream) => any;
-
     coerce?: (value: any) => any;
+
     toJSON?: (value: any) => any;
+    category: FieldCategory;
+
     random?: () => any;
     validate?: (value: any) => void;
+    computer_default_value(defaultValue: any): any;
+    subType: string;
+    isAbstract: boolean;
 
-    defaultValue?: any;
+    isSubTypeOf(type: CommonInterface): boolean;
+}
 
-    computer_default_value(defaultValue: any): any;
+export interface FieldInterfaceOptions {
+    name: string;
+    defaultValue?: any | DefaultValueFunc;
+
+    fieldType: string;
+    isArray?: boolean;
+    documentation?: string;
+    category?: FieldCategory;
+    schema?: CommonInterface;
+    switchBit?: number; // the bit number
+    switchValue?: number;
+    allowSubType?: boolean;
+    dataType?: NodeId;
+    basicDataType?: number;
 }
 
-export enum FieldCategory {
-    enumeration = "enumeration",
-    complex = "complex",
-    basic = "basic"
+export type Func1<T> = (value: any, field: StructuredTypeField, data: T, args?: any) => void;
+export interface DecodeDebugOptions {
+    tracer: any;
+    name: string;
+}
+
+export interface IBaseUAObject {
+    schema: IStructuredTypeSchema;
+    encode(stream: OutputBinaryStream): void;
+    decode(stream: BinaryStream): void;
+    binaryStoreSize(): number;
+    toString(...args: any[]): string;
+    isValid(): boolean;
+    explore(): string;
+    applyOnAllFields<T>(func: Func1<T>, data: T): void;
+    toJSON(): any;
+    decodeDebug(stream: BinaryStream, options: DecodeDebugOptions): void;
+    clone(): IBaseUAObject;
+}
+type BaseUAObjectConstructable = new (options?: any) => IBaseUAObject;
+export type ConstructorFunc = BaseUAObjectConstructable;
+// new (...args: any[]) => BaseUAObjectConstructable;
+
+export interface ConstructorFuncWithSchema extends ConstructorFunc {
+    schema: IStructuredTypeSchema;
+    possibleFields: string[];
+    encodingDefaultBinary: ExpandedNodeId;
+    encodingDefaultXml: ExpandedNodeId;
+    encodingDefaultJson?: ExpandedNodeId;
 }
 
 export interface StructuredTypeField {
-    name: string;
+    
+    name: string;               // the name that may have been lowercased
+    originalName: string;       // the orignal name from the raw OPCUA description
 
     fieldType: string;
-
     isArray?: boolean;
     documentation?: string;
     category: FieldCategory;
+    defaultValue?: any | DefaultValueFunc;
     schema: CommonInterface;
+    switchBit?: number; // the bit number
+    switchValue?: number;
+    allowSubType?: boolean;
+    dataType?: NodeId;
+    basicDataType?: number; // DataType
 
     fieldTypeConstructor?: ConstructorFunc;
+
     subType?: string;
-    defaultValue?: any;
     validate?: (value: any) => boolean;
     decode?: (stream: BinaryStream) => any;
-
-    switchBit?: number; // the bit number
-    switchValue?: number;
 }
 
 // tslint:disable:no-empty-interface
@@ -72,18 +125,6 @@ export type FieldType = FieldEnumeration | FieldComplex | FieldBasic;
 
 export type DefaultValueFunc = () => any;
 
-export interface FieldInterfaceOptions {
-    name: string;
-    fieldType: string;
-    isArray?: boolean;
-    documentation?: string;
-    category?: FieldCategory;
-    defaultValue?: any | DefaultValueFunc;
-    schema?: any;
-    switchBit?: number; // the bit number
-    switchValue?: number;
-}
-
 export interface StructuredTypeOptions {
     name: string;
     id?: number | NodeId;
@@ -97,6 +138,8 @@ export interface StructuredTypeOptions {
 
 export interface TypeSchemaConstructorOptions {
     name: string;
+    subType?: string;
+    isAbstract?: boolean;
     category?: FieldCategory;
     defaultValue?: any;
     encode?: (value: any, stream: OutputBinaryStream) => void;
@@ -104,13 +147,20 @@ export interface TypeSchemaConstructorOptions {
     coerce?: (value: any) => any;
 }
 
-export interface BasicTypeDefinitionOptions extends TypeSchemaConstructorOptions {
-    subType: string;
+export interface BasicTypeDefinitionOptionsB extends TypeSchemaConstructorOptions {
     toJSON?: (value: any) => any;
     random?: () => any;
     validate?: (value: any) => void;
 }
 
+export interface BasicTypeDefinitionOptionsBase extends BasicTypeDefinitionOptionsB {
+    /** */
+}
+
+export interface BasicTypeDefinitionOptions extends BasicTypeDefinitionOptionsB {
+    subType: string;
+}
+
 export interface BasicTypeDefinition extends CommonInterface {
     subType: string;
 }
@@ -118,57 +168,32 @@ export interface BasicTypeDefinition extends CommonInterface {
 export interface BuiltInTypeDefinition extends BasicTypeDefinition {}
 
 export interface EnumerationDefinition extends CommonInterface {
-  //  enumValues: any;
+    //  enumValues: any;
     typedEnum: Enum;
     documentation?: string;
 }
 
-export type TypeDefinition = BuiltInTypeDefinition | EnumerationDefinition | BasicTypeDefinition | TypeSchemaBase;
+export type TypeDefinition = BuiltInTypeDefinition | EnumerationDefinition | BasicTypeDefinition | CommonInterface;
 
-/**
- * @class TypeSchemaBase
- * @param options {Object}
- * @constructor
- * create a new type Schema
- */
-export class TypeSchemaBase implements CommonInterface {
-    public name: string;
-    public defaultValue: any;
-    public encode?: (value: any, stream: OutputBinaryStream) => void;
-    public decode?: (stream: BinaryStream) => any;
-    public coerce?: (value: any) => any;
-    public toJSON?: () => string;
-    public category: FieldCategory;
-
-    constructor(options: TypeSchemaConstructorOptions) {
-        assert(options.category !== null);
-        this.encode = options.encode || undefined;
-        this.decode = options.decode || undefined;
-        this.coerce = options.coerce;
-        this.category = options.category || FieldCategory.basic;
-        this.name = options.name;
-
-        for (const prop in options) {
-            if (Object.prototype.hasOwnProperty.call(options, prop)) {
-                (this as any)[prop] = (options as any)[prop];
-            }
-        }
-    }
-
-    /**
-     * @method  computer_default_value
-     * @param defaultValue {*} the default value
-     * @return {*}
-     */
-    public computer_default_value(defaultValue: unknown): any {
-        if (defaultValue === undefined) {
-            defaultValue = this.defaultValue;
-        }
-        if (typeof defaultValue === "function") {
-            // be careful not to cache this value , it must be call each time to make sure
-            // we do not end up with the same value/instance twice.
-            defaultValue = defaultValue();
-        }
-        return defaultValue;
-    }
+export interface IStructuredTypeSchema extends CommonInterface {
+    fields: FieldType[];
+    id: NodeId;
+    dataTypeNodeId: NodeId;
+
+    baseType: string;
+    _possibleFields: string[];
+    _baseSchema: IStructuredTypeSchema | null;
+
+    documentation?: string;
+
+    isValid?: (options: any) => boolean;
+
+    decodeDebug?: (stream: BinaryStream, options: any) => any;
+    constructHook?: (options: any) => any;
+
+    encodingDefaultBinary?: ExpandedNodeId;
+    encodingDefaultXml?: ExpandedNodeId;
+    encodingDefaultJson?: ExpandedNodeId;
+
+    bitFields?: any[];
 }

package/source/constructor_type.ts

@@ -1,18 +0,0 @@
-/**
- * @module node-opcua-factory
- */
-import { ExpandedNodeId } from "node-opcua-nodeid";
-
-import { BaseUAObject } from "./factories_baseobject";
-import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
-
-type BaseUAObjectConstructable = new (options?: any) => BaseUAObject;
-export type ConstructorFunc = BaseUAObjectConstructable;
-// new (...args: any[]) => BaseUAObjectConstructable;
-
-export interface ConstructorFuncWithSchema extends ConstructorFunc {
-    schema: StructuredTypeSchema;
-    possibleFields: string[];
-    encodingDefaultBinary: ExpandedNodeId;
-    encodingDefaultXml: ExpandedNodeId;
-}