node-opcua-factory 2.51.0

package/dist/types.d.ts

@@ -0,0 +1,111 @@
+import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import { Enum } from "node-opcua-enum";
+import { NodeId } from "node-opcua-nodeid";
+import { ConstructorFunc } from "./constructor_type";
+export interface CommonInterface {
+    name: string;
+    encode?: (value: any, stream: OutputBinaryStream) => void;
+    decode?: (stream: BinaryStream) => any;
+    coerce?: (value: any) => any;
+    toJSON?: (value: any) => any;
+    random?: () => any;
+    validate?: (value: any) => void;
+    defaultValue?: any;
+    computer_default_value(defaultValue: any): any;
+}
+export declare enum FieldCategory {
+    enumeration = "enumeration",
+    complex = "complex",
+    basic = "basic"
+}
+export interface StructuredTypeField {
+    name: string;
+    fieldType: string;
+    isArray?: boolean;
+    documentation?: string;
+    category: FieldCategory;
+    schema: CommonInterface;
+    fieldTypeConstructor?: ConstructorFunc;
+    subType?: string;
+    defaultValue?: any;
+    validate?: (value: any) => boolean;
+    decode?: (stream: BinaryStream) => any;
+    switchBit?: number;
+    switchValue?: number;
+}
+export interface FieldEnumeration extends StructuredTypeField {
+}
+export interface FieldComplex extends StructuredTypeField {
+}
+export interface FieldBasic extends StructuredTypeField {
+}
+export declare type FieldType = FieldEnumeration | FieldComplex | FieldBasic;
+export declare type DefaultValueFunc = () => any;
+export interface FieldInterfaceOptions {
+    name: string;
+    fieldType: string;
+    isArray?: boolean;
+    documentation?: string;
+    category?: FieldCategory;
+    defaultValue?: any | DefaultValueFunc;
+    schema?: any;
+    switchBit?: number;
+    switchValue?: number;
+}
+export interface StructuredTypeOptions {
+    name: string;
+    id?: number | NodeId;
+    fields: FieldInterfaceOptions[];
+    documentation?: string;
+    baseType: string;
+    _resolved?: boolean;
+    bitFields?: any[];
+    base?: StructuredTypeOptions;
+}
+export interface TypeSchemaConstructorOptions {
+    name: string;
+    category?: FieldCategory;
+    defaultValue?: any;
+    encode?: (value: any, stream: OutputBinaryStream) => void;
+    decode?: (stream: BinaryStream) => any;
+    coerce?: (value: any) => any;
+}
+export interface BasicTypeDefinitionOptions extends TypeSchemaConstructorOptions {
+    subType: string;
+    toJSON?: (value: any) => any;
+    random?: () => any;
+    validate?: (value: any) => void;
+}
+export interface BasicTypeDefinition extends CommonInterface {
+    subType: string;
+}
+export interface BuiltInTypeDefinition extends BasicTypeDefinition {
+}
+export interface EnumerationDefinition extends CommonInterface {
+    enumValues: any;
+    typedEnum: Enum;
+    documentation?: string;
+}
+export declare type TypeDefinition = BuiltInTypeDefinition | EnumerationDefinition | BasicTypeDefinition | TypeSchemaBase;
+/**
+ * @class TypeSchemaBase
+ * @param options {Object}
+ * @constructor
+ * create a new type Schema
+ */
+export declare class TypeSchemaBase implements CommonInterface {
+    name: string;
+    defaultValue: any;
+    encode?: (value: any, stream: OutputBinaryStream) => void;
+    decode?: (stream: BinaryStream) => any;
+    coerce?: (value: any) => any;
+    toJSON?: () => string;
+    category: FieldCategory;
+    constructor(options: TypeSchemaConstructorOptions);
+    /**
+     * @method  computer_default_value
+     * @param defaultValue {*} the default value
+     * @return {*}
+     */
+    computer_default_value(defaultValue: any): any;
+}

package/dist/types.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSchemaBase = exports.FieldCategory = void 0;
+/**
+ * @module node-opcua-factory
+ */
+const node_opcua_assert_1 = require("node-opcua-assert");
+var FieldCategory;
+(function (FieldCategory) {
+    FieldCategory["enumeration"] = "enumeration";
+    FieldCategory["complex"] = "complex";
+    FieldCategory["basic"] = "basic";
+})(FieldCategory = exports.FieldCategory || (exports.FieldCategory = {}));
+// tslint:disable-next-line:no-empty
+function defaultEncode(value, stream) { }
+// tslint:disable-next-line:no-empty
+function defaultDecode(stream) { }
+/**
+ * @class TypeSchemaBase
+ * @param options {Object}
+ * @constructor
+ * create a new type Schema
+ */
+class TypeSchemaBase {
+    constructor(options) {
+        (0, node_opcua_assert_1.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[prop] = options[prop];
+            }
+        }
+    }
+    /**
+     * @method  computer_default_value
+     * @param defaultValue {*} the default value
+     * @return {*}
+     */
+    computer_default_value(defaultValue) {
+        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;
+    }
+}
+exports.TypeSchemaBase = TypeSchemaBase;
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../source/types.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,yDAA2C;AA4B3C,IAAY,aAIX;AAJD,WAAY,aAAa;IACrB,4CAA2B,CAAA;IAC3B,oCAAmB,CAAA;IACnB,gCAAe,CAAA;AACnB,CAAC,EAJW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAIxB;AA4FD,oCAAoC;AACpC,SAAS,aAAa,CAAC,KAAU,EAAE,MAAoB,IAAS,CAAC;AAEjE,oCAAoC;AACpC,SAAS,aAAa,CAAC,MAAoB,IAAS,CAAC;AAErD;;;;;GAKG;AACH,MAAa,cAAc;IASvB,YAAY,OAAqC;QAC7C,IAAA,0BAAM,EAAC,OAAO,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,SAAS,CAAC;QAC1C,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,SAAS,CAAC;QAC1C,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,aAAa,CAAC,KAAK,CAAC;QACxD,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QAEzB,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE;YACxB,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAC,IAAI,CAAC,EAAE;gBACnD,IAAY,CAAC,IAAI,CAAC,GAAI,OAAe,CAAC,IAAI,CAAC,CAAC;aAChD;SACJ;IACL,CAAC;IAED;;;;OAIG;IACI,sBAAsB,CAAC,YAAiB;QAC3C,IAAI,YAAY,KAAK,SAAS,EAAE;YAC5B,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;SACpC;QACD,IAAI,OAAO,YAAY,KAAK,UAAU,EAAE;YACpC,8EAA8E;YAC9E,uDAAuD;YACvD,YAAY,GAAG,YAAY,EAAE,CAAC;SACjC;QACD,OAAO,YAAY,CAAC;IACxB,CAAC;CACJ;AAxCD,wCAwCC"}

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "node-opcua-factory",
+    "version": "2.51.0",
+    "description": "pure nodejs OPCUA SDK - module -factory",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": "tsc -b",
+        "lint": "tslint source/**/*.ts",
+        "clean": "node -e \"require('rimraf').sync('dist');\"",
+        "test": "echo no test"
+    },
+    "dependencies": {
+        "chalk": "4.1.2",
+        "node-opcua-assert": "2.51.0",
+        "node-opcua-basic-types": "2.51.0",
+        "node-opcua-binary-stream": "2.51.0",
+        "node-opcua-debug": "2.51.0",
+        "node-opcua-enum": "2.51.0",
+        "node-opcua-guid": "2.51.0",
+        "node-opcua-nodeid": "2.51.0",
+        "node-opcua-status-code": "2.51.0",
+        "node-opcua-utils": "2.51.0"
+    },
+    "author": "Etienne Rossignon",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/node-opcua/node-opcua.git"
+    },
+    "keywords": [
+        "OPCUA",
+        "opcua",
+        "m2m",
+        "iot",
+        "opc ua",
+        "internet of things"
+    ],
+    "homepage": "http://node-opcua.github.io/",
+    "gitHead": "75feb111daf7ec65fa0111e4fa5beb8987fd4945"
+}

package/source/constructor_type.ts

@@ -0,0 +1,18 @@
+/**
+ * @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;
+}

package/source/datatype_factory.ts

@@ -0,0 +1,368 @@
+/**
+ * @module node-opcua-factory
+ */
+// tslint:disable:no-console
+import * as chalk from "chalk";
+import * as util from "util";
+
+import { assert } from "node-opcua-assert";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { ExpandedNodeId, NodeId } from "node-opcua-nodeid";
+
+import { ConstructorFunc, ConstructorFuncWithSchema } from "./constructor_type";
+import { BaseUAObject } from "./factories_baseobject";
+import { getBuildInType, hasBuiltInType } from "./factories_builtin_types";
+import { EnumerationDefinitionSchema, getEnumeration, hasEnumeration } from "./factories_enumerations";
+import { StructuredTypeSchema } from "./factories_structuredTypeSchema";
+import { BasicTypeDefinition } from "./types";
+
+const debugLog = make_debugLog(__filename);
+const doDebug = checkDebugFlag(__filename);
+
+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 _enumerations: Map<string, EnumerationDefinitionSchema> = new Map();
+    private _simpleTypes: Map<string, { nodeId: NodeId; definition: BasicTypeDefinition }> = new Map();
+
+    private baseDataFactories: DataTypeFactory[];
+
+    public constructor(baseDataFactories: DataTypeFactory[]) {
+        this.defaultByteOrder = "LittleEndian";
+        this.targetNamespace = "";
+        this.baseDataFactories = baseDataFactories;
+    }
+
+    public repairBaseDataFactories(baseDataFactories: DataTypeFactory[]): void {
+        this.baseDataFactories = baseDataFactories;
+    }
+    // -----------------------------
+    public registerSimpleType(name: string, dataTypeNodeId: NodeId, def: BasicTypeDefinition) {
+        // istanbul ignore next
+        if (this._simpleTypes.has(name)) {
+            throw new Error("registerSimpleType " + name + " already register");
+        }
+        this._simpleTypes.set(name, { nodeId: dataTypeNodeId, definition: def });
+    }
+
+    public hasSimpleType(name: string): boolean {
+        if (this._simpleTypes.has(name)) {
+            return true;
+        }
+        for (const factory of this.baseDataFactories) {
+            if (factory.hasSimpleType(name)) {
+                return true;
+            }
+        }
+        const hasSimpleT = hasBuiltInType(name);
+        if (hasSimpleT) {
+            return hasSimpleT;
+        }
+        return hasBuiltInType(name);
+    }
+    public getSimpleType(name: string): BasicTypeDefinition {
+        if (this._simpleTypes.has(name)) {
+            return this._simpleTypes.get(name)!.definition;
+        }
+        for (const factory of this.baseDataFactories) {
+            if (factory.hasSimpleType(name)) {
+                return factory.getSimpleType(name);
+            }
+        }
+        return getBuildInType(name);
+    }
+    // -----------------------------
+    // EnumerationDefinitionSchema
+    public registerEnumeration(enumeration: EnumerationDefinitionSchema): void {
+        debugLog("Registering Enumeration ", enumeration.name);
+        assert(!this._enumerations.has(enumeration.name));
+        this._enumerations.set(enumeration.name, enumeration);
+    }
+
+    public hasEnumeration(enumName: string): boolean {
+        if (this._enumerations.has(enumName)) {
+            return true;
+        }
+        for (const factory of this.baseDataFactories) {
+            const e = factory.hasEnumeration(enumName);
+            if (e) {
+                return true;
+            }
+        }
+        if (hasEnumeration(enumName)) {
+            return true;
+        }
+        return false;
+    }
+    public getEnumeration(enumName: string): EnumerationDefinitionSchema | null {
+        if (this._enumerations.has(enumName)) {
+            return this._enumerations.get(enumName) || null;
+        }
+        for (const factory of this.baseDataFactories) {
+            const hasEnum = factory.hasEnumeration(enumName);
+            if (hasEnum) {
+                const e = factory.getEnumeration(enumName);
+                return e;
+            }
+        }
+        const ee = getEnumeration(enumName);
+        return ee;
+    }
+    //  ----------------------------
+
+    public findConstructorForDataType(dataTypeNodeId: NodeId): ConstructorFuncWithSchema {
+        const constructor = this.getConstructorForDataType(dataTypeNodeId);
+        if (constructor) {
+            return constructor;
+        }
+        this.getConstructorForDataType(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;
+        }
+        for (const factory of this.baseDataFactories) {
+            const constructor2 = factory.getConstructorForDataType(dataTypeNodeId);
+            if (constructor2) {
+                return constructor2;
+            }
+        }
+        return null;
+    }
+    // ----------------------------------------------------------------------------------------------------
+    // Access by typeName
+    // ----------------------------------------------------------------------------------------------------
+    public structuredTypesNames(): IterableIterator<string> {
+        return this._structureTypeConstructorByNameMap.keys();
+    }
+
+    public getStructureTypeConstructor(typeName: string): ConstructorFuncWithSchema {
+        const constructor = this._structureTypeConstructorByNameMap.get(typeName);
+        if (constructor) {
+            return constructor;
+        }
+        for (const factory of this.baseDataFactories) {
+            if (!factory.hasStructuredType(typeName)) {
+                continue;
+            }
+            const constructor2 = factory.getStructureTypeConstructor(typeName);
+            if (constructor2) {
+                return constructor2;
+            }
+        }
+        // istanbul ignore next
+        if (doDebug) {
+            console.log([...this.structuredTypesNames()].join(" "));
+        }
+        // istanbul ignore next
+        throw new Error(
+            "Cannot find StructureType constructor for " + typeName + " - it may be abstract, or it could be a basic type"
+        );
+    }
+
+    public hasStructuredType(typeName: string): boolean {
+        if (this._structureTypeConstructorByNameMap.has(typeName)) {
+            return true;
+        }
+        for (const factory of this.baseDataFactories) {
+            if (factory.hasStructuredType(typeName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public getStructuredTypeSchema(typeName: string): StructuredTypeSchema {
+        const constructor = this.getStructureTypeConstructor(typeName);
+        return constructor.schema;
+    }
+
+    // istanbul ignore next
+    public dump(): void {
+        console.log(" dumping registered factories");
+        console.log(
+            " Factory ",
+            [...this.structuredTypesNames()].sort().forEach((e) => e)
+        );
+        console.log(" done");
+    }
+
+    public registerClassDefinition(dataTypeNodeId: NodeId, className: string, classConstructor: ConstructorFuncWithSchema): void {
+        this._registerFactory(dataTypeNodeId, className, classConstructor);
+        if (classConstructor.encodingDefaultBinary && classConstructor.encodingDefaultBinary.value !== 0) {
+            this.associateWithBinaryEncoding(className, classConstructor.encodingDefaultBinary);
+        } else {
+            // for instance in DI FetchResultDataType should be abstract but is not
+            debugLog("warning ", dataTypeNodeId.toString(), "name=", className, " do not have binary encoding");
+        }
+    }
+
+    // ----------------------------------------------------------------------------------------------------
+    // Access by binaryEncodingNodeId
+    // ----------------------------------------------------------------------------------------------------
+    public getConstructor(binaryEncodingNodeId: NodeId): ConstructorFunc | null {
+        const expandedNodeIdKey = makeExpandedNodeIdKey(binaryEncodingNodeId);
+        const constructor = this._structureTypeConstructorByEncodingNodeIdMap.get(expandedNodeIdKey);
+        if (constructor) {
+            return constructor;
+        }
+        for (const factory of this.baseDataFactories) {
+            const constructor2 = factory.getConstructor(binaryEncodingNodeId);
+            if (constructor2) {
+                return constructor2;
+            }
+        }
+        debugLog(chalk.red("#getConstructor : cannot find constructor for expandedId "), binaryEncodingNodeId.toString());
+        return null;
+    }
+
+    public hasConstructor(binaryEncodingNodeId: NodeId): boolean {
+        if (!binaryEncodingNodeId) {
+            return false;
+        }
+        /* istanbul ignore next */
+        if (!verifyExpandedNodeId(binaryEncodingNodeId)) {
+            console.log("Invalid expandedNodeId");
+            return false;
+        }
+        const expandedNodeIdKey = makeExpandedNodeIdKey(binaryEncodingNodeId);
+        const constructor = this._structureTypeConstructorByEncodingNodeIdMap.get(expandedNodeIdKey);
+        if (constructor) {
+            return true;
+        }
+        for (const factory of this.baseDataFactories) {
+            const constructor2 = factory.getConstructor(binaryEncodingNodeId);
+            if (constructor2) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public constructObject(binaryEncodingNodeId: NodeId): BaseUAObject {
+        if (!verifyExpandedNodeId(binaryEncodingNodeId)) {
+            throw new Error(" constructObject : invalid expandedNodeId provided " + binaryEncodingNodeId.toString());
+        }
+        const constructor = this.getConstructor(binaryEncodingNodeId);
+
+        if (!constructor) {
+            debugLog("Cannot find constructor for " + binaryEncodingNodeId.toString());
+            return new BaseUAObject();
+            // throw new Error("Cannot find constructor for " + expandedNodeId.toString());
+        }
+        return callConstructor(constructor);
+    }
+
+    public associateWithBinaryEncoding(className: string, expandedNodeId: ExpandedNodeId) {
+        const classConstructor = this.getStructureTypeConstructor(className);
+        if (doDebug) {
+            debugLog(" associateWithBinaryEncoding ", className, expandedNodeId.toString());
+        }
+
+        /* istanbul ignore next */
+        if (!verifyExpandedNodeId(expandedNodeId)) {
+            throw new Error("Invalid expandedNodeId " + expandedNodeId.toString() + " className = " + className);
+        }
+        const expandedNodeIdKey = makeExpandedNodeIdKey(expandedNodeId);
+
+        /* istanbul ignore next */
+        if (this._structureTypeConstructorByEncodingNodeIdMap.has(expandedNodeIdKey)) {
+            throw new Error(
+                " Class " +
+                    className +
+                    " with ID " +
+                    expandedNodeId +
+                    "  already in constructorMap for  " +
+                    this._structureTypeConstructorByEncodingNodeIdMap.get(expandedNodeIdKey).name
+            );
+        }
+
+        this._structureTypeConstructorByEncodingNodeIdMap.set(expandedNodeIdKey, classConstructor);
+    }
+
+    public toString(): string {
+        const l: string[] = [];
+        function write(...args: [any, ...any[]]) {
+            l.push(util.format.apply(util.format, args));
+        }
+        dumpDataFactory(this, write);
+        return l.join("\n");
+    }
+
+    private _registerFactory(dataTypeNodeId: NodeId, typeName: string, constructor: ConstructorFuncWithSchema): void {
+        /* istanbul ignore next */
+        if (this.hasStructuredType(typeName)) {
+            console.log(this.getStructureTypeConstructor(typeName));
+            console.log("target namespace =", this.targetNamespace);
+            throw new Error(" registerFactory  : " + typeName + " already registered");
+        }
+        debugLog("registering typeName ", typeName, dataTypeNodeId.toString());
+        this._structureTypeConstructorByNameMap.set(typeName, constructor);
+        if (dataTypeNodeId.value !== 0) {
+            this._structureTypeConstructorByDataTypeMap.set(dataTypeNodeId.toString(), constructor);
+        }
+        Object.defineProperty(constructor.schema, "$$factory", {
+            enumerable: false,
+            value: this,
+            writable: false
+        });
+    }
+}
+
+function dumpSchema(schema: StructuredTypeSchema, write: any) {
+    write("name           ", schema.name);
+    write("dataType       ", schema.dataTypeNodeId.toString());
+    write("binaryEncoding ", schema.encodingDefaultBinary!.toString());
+    for (const f of schema.fields) {
+        write("          ", f.name.padEnd(30, " "), f.isArray ? true : false, f.fieldType);
+    }
+}
+function dumpDataFactory(dataFactory: DataTypeFactory, write: any) {
+    for (const structureTypeName of dataFactory.structuredTypesNames()) {
+        const schema = dataFactory.getStructuredTypeSchema(structureTypeName);
+
+        write("structureTypeName =", structureTypeName);
+
+        if (!dataFactory.getConstructorForDataType(schema.dataTypeNodeId)) {
+            write("  ( No constructor for " + schema.name + "  " + schema.dataTypeNodeId.toString());
+        }
+        if (!schema.encodingDefaultBinary) {
+            write(" (Schema has no encoding defaultBinary )");
+        } else {
+            if (dataFactory.hasConstructor(schema.encodingDefaultBinary)) {
+                console.log("schema", schema.name);
+                console.log("schema", schema.dataTypeNodeId.toString());
+                console.log("schema", schema.encodingDefaultBinary ? schema.encodingDefaultBinary.toString() : " ");
+                console.log("schema", schema.encodingDefaultXml ? schema.encodingDefaultXml.toString() : " ");
+                // return;
+                // throw new Error("Not  in Binary Encoding Map!!!!!  " + schema.encodingDefaultBinary);
+            }
+        }
+        dumpSchema(schema, write);
+    }
+}
+
+function verifyExpandedNodeId(expandedNodeId: NodeId): boolean {
+    /* istanbul ignore next */
+    if (expandedNodeId.value instanceof Buffer) {
+        throw new Error("getConstructor not implemented for opaque nodeid");
+    }
+    return true;
+}
+
+function makeExpandedNodeIdKey(expandedNodeId: NodeId): string {
+    return expandedNodeId.toString();
+}
+
+export function callConstructor(constructor: ConstructorFunc): BaseUAObject {
+    assert(typeof constructor === "function");
+    const constructorFunc: any = constructor.bind.apply(constructor, arguments as any);
+    return new constructorFunc();
+}