node-opcua-factory 2.51.0

package/source/factories_factories.ts

@@ -0,0 +1,58 @@
+/**
+ * @module node-opcua-factory
+ */
+// tslint:disable:no-console
+
+import * as chalk from "chalk";
+
+import { assert } from "node-opcua-assert";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
+
+import { DataTypeFactory } from "./datatype_factory";
+import { ConstructorFuncWithSchema, ConstructorFunc } from "./constructor_type";
+
+import { BaseUAObject } from "./factories_baseobject";
+import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
+
+const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
+
+let globalFactory: DataTypeFactory;
+export function getStandardDataTypeFactory(): DataTypeFactory {
+    if (!globalFactory) {
+        globalFactory = new DataTypeFactory([]);
+        globalFactory.targetNamespace = "http://opcfoundation.org/UA/";
+    }
+    return globalFactory;
+}
+export function getStructureTypeConstructor(typeName: string): ConstructorFuncWithSchema {
+    return getStandardDataTypeFactory().getStructureTypeConstructor(typeName);
+}
+export function hasStructuredType(typeName: string): boolean {
+    return getStandardDataTypeFactory().hasStructuredType(typeName);
+}
+export function getStructuredTypeSchema(typeName: string): StructuredTypeSchema {
+    return getStandardDataTypeFactory().getStructuredTypeSchema(typeName);
+}
+
+export function getConstructor(binaryEncodingNodeId: ExpandedNodeId): ConstructorFunc | null {
+    return getStandardDataTypeFactory().getConstructor(binaryEncodingNodeId);
+}
+export function hasConstructor(binaryEncodingNodeId: ExpandedNodeId): boolean {
+    return getStandardDataTypeFactory().hasConstructor(binaryEncodingNodeId);
+}
+export function constructObject(binaryEncodingNodeId: ExpandedNodeId): BaseUAObject {
+    return getStandardDataTypeFactory().constructObject(binaryEncodingNodeId);
+}
+export function registerClassDefinition(
+    dataTypeNodeId: NodeId,
+    className: string,
+    classConstructor: ConstructorFuncWithSchema
+): void {
+    return getStandardDataTypeFactory().registerClassDefinition(dataTypeNodeId, className, classConstructor);
+}
+/* istanbul ignore next */
+export function dump(): void {
+    getStandardDataTypeFactory().dump();
+}

package/source/factories_id_generator.ts

@@ -0,0 +1,18 @@
+/**
+ * @module node-opcua-factory
+ */
+const _FIRST_INTERNAL_ID = 0xFFFE0000;
+
+let _nextAvailableId = _FIRST_INTERNAL_ID;
+
+export function generate_new_id(): number {
+    _nextAvailableId += 1;
+    return _nextAvailableId;
+}
+
+export function next_available_id(): number  {
+    return -1;
+}
+export function is_internal_id(value: number): boolean  {
+    return value >= _FIRST_INTERNAL_ID;
+}

package/source/factories_schema_helpers.ts

@@ -0,0 +1,125 @@
+/**
+ * @module node-opcua-factory
+ */
+import { assert } from "node-opcua-assert";
+import { make_debugLog } from "node-opcua-debug";
+import { CommonInterface, FieldCategory, FieldType, StructuredTypeField } from "./types";
+
+const debugLog = make_debugLog(__filename);
+
+export const parameters = {
+    debugSchemaHelper: !!process.env.DEBUG_CLASS
+};
+
+/**
+ * ensure correctness of a schema object.
+ *
+ * @method check_schema_correctness
+ * @param schema
+ *
+ */
+export function check_schema_correctness(schema: any) {
+    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: any): any {
+    const _t = field.schema;
+    if (!(_t !== null && typeof _t === "object")) {
+        throw new Error(
+            "initialize_field: expecting field.schema to be set field.name = '" + field.name + "' type = " + field.fieldType
+        );
+    }
+    if (field.category === FieldCategory.complex) {
+        if (field.fieldTypeConstructor) {
+            return new field.fieldTypeConstructor(value);
+        } else {
+            debugLog("xxxx => missing constructor for field type", field.fieldType);
+        }
+    }
+
+    if (value === undefined || value === null) {
+        const defaultValue = _t.computer_default_value ? _t.computer_default_value(field.defaultValue) : field.defaultValue;
+        if (value === undefined) {
+            if (_t.coerce) {
+                return _t.coerce(defaultValue);
+            }
+            return defaultValue;
+        }
+        if (defaultValue === null) {
+            if (value === null) {
+                return null;
+            }
+        }
+    }
+    if (_t.coerce) {
+        value = _t.coerce(value);
+    }
+    if (field.validate) {
+        if (!field.validate(value)) {
+            throw Error(" invalid value " + value + " for field " + field.name + " of type " + field.fieldType);
+        }
+    }
+    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
+ * @param valueArray
+ * @return
+ */
+export function initialize_field_array(field: FieldType, valueArray: any) {
+    const _t = field.schema;
+
+    let value;
+    let i;
+    assert(field !== null && typeof field === "object");
+    assert(field.isArray);
+
+    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 = [];
+    for (i = 0; i < valueArray.length; i++) {
+        value = initialize_value(valueArray[i], defaultValue, _t);
+        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

@@ -0,0 +1,330 @@
+/**
+ * @module node-opcua-factory
+ */
+import * as chalk from "chalk";
+import { CommonInterface, FieldCategory, FieldInterfaceOptions, FieldType, StructuredTypeOptions, TypeSchemaBase } from "./types";
+
+import { assert } from "node-opcua-assert";
+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";
+
+function figureOutFieldCategory(field: FieldInterfaceOptions): FieldCategory {
+    const fieldType = field.fieldType;
+
+    if (field.category) {
+        return field.category;
+    }
+
+    if (hasEnumeration(fieldType)) {
+        return FieldCategory.enumeration;
+    } else if (hasBuiltInType(fieldType)) {
+        return FieldCategory.basic;
+    } else if (hasStructuredType(fieldType)) {
+        assert(fieldType !== "LocalizedText"); // LocalizedText should be treated as BasicType!!!
+        return FieldCategory.complex;
+    }
+    return FieldCategory.basic;
+}
+
+const regExp = /((ns[0-9]+:)?)(.*)/;
+
+function figureOutSchema(
+    underConstructSchema: StructuredTypeSchema,
+    field: FieldInterfaceOptions,
+    category: FieldCategory
+): CommonInterface {
+    if (field.schema) {
+        return field.schema;
+    }
+
+    if (underConstructSchema.name === field.fieldType) {
+        return underConstructSchema;
+    }
+
+    let returnValue: any = null;
+
+    // may be the field.type  contains a ns<X>: prefix !! like the one found in Beckhoff PLC !
+    const m = field.fieldType.match(regExp);
+    /* istanbul ignore next */
+    if (!m) {
+        throw new Error("malformed fieldType ? : " + field.fieldType);
+    }
+    const fieldTypeWithoutNS = m[3];
+
+    switch (category) {
+        case FieldCategory.complex:
+            if (hasStructuredType(field.fieldType)) {
+                returnValue = getStructuredTypeSchema(fieldTypeWithoutNS);
+            } else {
+                // LocalizedText etc ...
+                returnValue = getBuildInType(fieldTypeWithoutNS);
+            }
+            break;
+        case FieldCategory.basic:
+            returnValue = getBuildInType(fieldTypeWithoutNS);
+            break;
+        case FieldCategory.enumeration:
+            returnValue = getEnumeration(fieldTypeWithoutNS);
+            break;
+    }
+    if (null === returnValue || undefined === returnValue) {
+        returnValue = getEnumeration(fieldTypeWithoutNS);
+        throw new Error(
+            "Cannot find Schema for field with name " +
+                field.name +
+                " fieldTypeWithoutNS= " +
+                fieldTypeWithoutNS +
+                " with type " +
+                field.fieldType +
+                " category = " +
+                category +
+                JSON.stringify(field, null, "\t")
+        );
+    }
+    return returnValue;
+}
+
+function buildField(underConstructSchema: StructuredTypeSchema, fieldLight: FieldInterfaceOptions): FieldType {
+    const category = figureOutFieldCategory(fieldLight);
+    const schema = figureOutSchema(underConstructSchema, fieldLight, category);
+
+    /* istanbul ignore next */
+    if (!schema) {
+        throw new Error(
+            "expecting a valid schema for field with name " +
+                fieldLight.name +
+                " with type " +
+                fieldLight.fieldType +
+                " category" +
+                category
+        );
+    }
+
+    return {
+        name: lowerFirstLetter(fieldLight.name),
+
+        category,
+        defaultValue: fieldLight.defaultValue,
+        isArray: fieldLight.isArray,
+
+        documentation: fieldLight.documentation,
+        fieldType: fieldLight.fieldType,
+
+        switchBit: fieldLight.switchBit,
+
+        switchValue: fieldLight.switchValue,
+
+        schema
+    };
+}
+
+export class StructuredTypeSchema extends TypeSchemaBase {
+    public fields: FieldType[];
+    public id: NodeId;
+    public dataTypeNodeId: NodeId;
+
+    public baseType: string;
+    public _possibleFields: string[];
+    public _baseSchema: StructuredTypeSchema | null;
+
+    public documentation?: string;
+
+    public isValid?: (options: any) => boolean;
+
+    public decodeDebug?: (stream: BinaryStream, options: any) => any;
+    public constructHook?: (options: any) => any;
+
+    public encodingDefaultBinary?: ExpandedNodeId;
+    public encodingDefaultXml?: ExpandedNodeId;
+    public encodingDefaultJson?: ExpandedNodeId;
+
+    public bitFields?: any[];
+
+    constructor(options: StructuredTypeOptions) {
+        super(options);
+
+        this.bitFields = options.bitFields;
+
+        this.baseType = options.baseType;
+        this.category = FieldCategory.complex;
+
+        if (hasBuiltInType(options.name)) {
+            this.category = FieldCategory.basic;
+        }
+        this.fields = options.fields.map(buildField.bind(null, this));
+        this.id = NodeId.nullNodeId;
+        this.dataTypeNodeId = NodeId.nullNodeId;
+
+        this._possibleFields = this.fields.map((field) => field.name);
+        this._baseSchema = null;
+    }
+    public toString() {
+        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);
+        str.push("encodingDefaultBinary  = " + this.encodingDefaultBinary?.toString());
+        str.push("encodingDefaultXml     = " + this.encodingDefaultXml?.toString());
+        str.push("encodingDefaultJson    = " + this.encodingDefaultJson?.toString());
+        for (const f of this.fields) {
+            str.push(
+                "  field   =  " +
+                    f.name.padEnd(30) +
+                    " isArray= " +
+                    (f.isArray ? true : false) +
+                    " " +
+                    f.fieldType.toString().padEnd(30) +
+                    (f.switchBit !== undefined ? " switchBit " + f.switchBit : "") +
+                    (f.switchValue !== undefined ? " switchValue    " + f.switchValue : "")
+            );
+        }
+        return str.join("\n");
+    }
+}
+
+/**
+ *
+ * @method get_base_schema
+ * @param schema
+ * @return {*}
+ *
+ */
+export function get_base_schema(schema: StructuredTypeSchema) {
+    let baseSchema = schema._baseSchema;
+    if (baseSchema) {
+        return baseSchema;
+    }
+
+    if (schema.baseType === "ExtensionObject" || schema.baseType === "DataTypeDefinition") {
+        return null;
+    }
+    if (schema.baseType === "Union") {
+        return null;
+    }
+
+    if (schema.baseType && schema.baseType !== "BaseUAObject" && schema.baseType !== "DataTypeDefinition") {
+        if (!hasStructuredType(schema.baseType)) {
+            return null;
+        }
+        const baseType = getStructureTypeConstructor(schema.baseType);
+
+        // istanbul ignore next
+        if (!baseType) {
+            throw new Error(" cannot find factory for " + schema.baseType);
+        }
+        if (baseType.prototype.schema) {
+            baseSchema = baseType.prototype.schema;
+        }
+    }
+    // put in  cache for speedup
+    schema._baseSchema = baseSchema;
+    return baseSchema;
+}
+
+/**
+ * extract a list of all possible fields for a schema
+ * (by walking up the inheritance chain)
+ * @method extract_all_fields
+ *
+ */
+export function extract_all_fields(schema: StructuredTypeSchema) {
+    // 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);
+
+    // istanbul ignore next
+    if (baseSchema) {
+        const fields = extract_all_fields(baseSchema);
+        possibleFields = fields.concat(possibleFields);
+    }
+
+    // put in cache to speed up
+    schema._possibleFields = possibleFields;
+    return possibleFields;
+}
+
+/**
+ * check correctness of option fields against scheme
+ *
+ * @method  check_options_correctness_against_schema
+ *
+ */
+export function check_options_correctness_against_schema(obj: any, schema: StructuredTypeSchema, options: any): boolean {
+    if (!parameters.debugSchemaHelper) {
+        return true; // ignoring set
+    }
+
+    options = options || {};
+
+    // istanbul ignore next
+    if (!(options !== null && typeof options === "object") && !(typeof options === "object")) {
+        let message = chalk.red(" Invalid options specified while trying to construct a ") + " " + chalk.yellow(schema.name);
+        message += "\n";
+        message += chalk.red(" expecting a ") + chalk.yellow(" Object ");
+        message += "\n";
+        message += chalk.red(" and got a ") + chalk.yellow(typeof options) + chalk.red(" instead ");
+        // console.log(" Schema  = ", schema);
+        // console.log(" options = ", options);
+        throw new Error(message);
+    }
+
+    // istanbul ignore next
+    if (options instanceof obj.constructor) {
+        return true;
+    }
+
+    // extract the possible fields from the schema.
+    const possibleFields: string[] = obj.constructor.possibleFields || schema._possibleFields;
+
+    // extracts the fields exposed by the option object
+    const currentFields = Object.keys(options);
+
+    // get a list of field that are in the 'options' object but not in schema
+    // https://github.com/you-dont-need/You-Dont-Need-Lodash-Underscore
+    function difference<T>(a1: T[], a2: T[]) {
+        return [a1, a2].reduce((a, b) => a.filter((value) => !b.includes(value)));
+    }
+    const invalidOptionsFields = difference(currentFields, possibleFields);
+
+    /* istanbul ignore next */
+    if (invalidOptionsFields.length > 0) {
+        // tslint:disable:no-console
+        console.log("expected schema", schema.name);
+        console.log(chalk.yellow("possible fields= "), possibleFields.sort().join(" "));
+        console.log(chalk.red("current fields= "), currentFields.sort().join(" "));
+        console.log(chalk.cyan("invalid_options_fields= "), invalidOptionsFields.sort().join(" "));
+        console.log("options = ", options);
+    }
+    /* istanbul ignore next */
+    if (invalidOptionsFields.length !== 0) {
+        // tslint:disable:no-console
+        console.log(chalk.yellow("possible fields= "), possibleFields.sort().join(" "));
+        console.log(chalk.red("current fields= "), currentFields.sort().join(" "));
+        throw new Error(" invalid field found in option :" + JSON.stringify(invalidOptionsFields));
+    }
+    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/index.ts

@@ -0,0 +1,15 @@
+/**
+ * @module node-opcua-factory
+ */
+export * from "./constructor_type";
+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";