node-opcua-factory 2.71.0 → 2.73.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-opcua-factory",
-    "version": "2.71.0",
+    "version": "2.73.1",
     "description": "pure nodejs OPCUA SDK - module -factory",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -9,18 +9,19 @@
         "lint": "eslint source",
         "format": "prettier --write source",
         "clean": "npx rimraf dist *.tsbuildinfo",
-        "test": "echo no test"
+        "test": "mocha"
     },
     "dependencies": {
         "chalk": "4.1.2",
         "node-opcua-assert": "2.66.0",
-        "node-opcua-basic-types": "2.71.0",
-        "node-opcua-binary-stream": "2.71.0",
+        "node-opcua-basic-types": "2.73.0",
+        "node-opcua-binary-stream": "2.73.0",
+        "node-opcua-constants": "2.70.0",
         "node-opcua-debug": "2.71.0",
         "node-opcua-enum": "2.71.0",
         "node-opcua-guid": "2.66.0",
         "node-opcua-nodeid": "2.71.0",
-        "node-opcua-status-code": "2.71.0",
+        "node-opcua-status-code": "2.73.0",
         "node-opcua-utils": "2.71.0"
     },
     "author": "Etienne Rossignon",
@@ -38,5 +39,5 @@
         "internet of things"
     ],
     "homepage": "http://node-opcua.github.io/",
-    "gitHead": "10f7cc1e1cd30dfef75adad9cb709a78401fabf3"
+    "gitHead": "684a796e88e1732f418f2ada6aca2808e0115de8"
 }

package/source/{factories_baseobject.ts → base_ua_object.ts}

@@ -8,16 +8,28 @@ import * as chalk from "chalk";
 import { assert } from "node-opcua-assert";
 import { AttributeIds } from "node-opcua-basic-types";
 import { BinaryStream, BinaryStreamSizeCalculator, OutputBinaryStream } from "node-opcua-binary-stream";
-import { hexDump } from "node-opcua-debug";
+import { hexDump, make_errorLog } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
 import * as utils from "node-opcua-utils";
 
-import { getBuildInType } from "./factories_builtin_types";
-import { getEnumeration, hasEnumeration } from "./factories_enumerations";
-import { DataTypeFactory } from "./datatype_factory";
-import { getStructureTypeConstructor } from "./factories_factories";
-import { get_base_schema, StructuredTypeSchema } from "./factories_structuredTypeSchema";
-import { EnumerationDefinition, FieldCategory, StructuredTypeField, BuiltInTypeDefinition, FieldType } from "./types";
+import { getBuiltInEnumeration, hasBuiltInEnumeration } from "./enumerations";
+import { DataTypeFactory, _findFieldSchema } from "./datatype_factory";
+import { getStructureTypeConstructor } from "./get_standard_data_type_factory";
+import { get_base_schema } from "./structured_type_schema";
+import {
+    EnumerationDefinition,
+    FieldCategory,
+    StructuredTypeField,
+    BuiltInTypeDefinition,
+    FieldType,
+    CommonInterface,
+    Func1,
+    IStructuredTypeSchema,
+    IBaseUAObject,
+    DecodeDebugOptions
+} from "./types";
+
+const errorLog = make_errorLog(__filename);
 
 function r(str: string, length = 30) {
     return (str + "                                ").substring(0, length);
@@ -60,12 +72,10 @@ function _decode_member_(value: any, field: StructuredTypeField, stream: BinaryS
     return value;
 }
 
-type Func1 = (a: any, field: StructuredTypeField, data: ExploreParams, args: any) => void;
-
-function applyOnAllSchemaFields(self: BaseUAObject, schema: StructuredTypeSchema, data: ExploreParams, functor: Func1, args: any) {
+function _applyOnAllSchemaFields<T>(self: BaseUAObject, schema: IStructuredTypeSchema, data: T, functor: Func1<T>, args?: any) {
     const baseSchema = get_base_schema(schema);
     if (baseSchema) {
-        applyOnAllSchemaFields(self, baseSchema, data, functor, args);
+        _applyOnAllSchemaFields(self, baseSchema, data, functor, args);
     }
 
     for (const field of schema.fields) {
@@ -131,7 +141,6 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
     if (!self) {
         return;
     }
-    assert(self);
 
     const fieldType = field.fieldType;
 
@@ -153,9 +162,10 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
     if (field.switchValue !== undefined) {
         opt = " !" + field.switchValue + " ";
     }
-
+    const allowSubTypeSymbol = field.allowSubType ? "~" : " ";
+    const arraySymbol = field.isArray ? "[]" : "  ";
     const fieldNameF = chalk.yellow(r(padding + fieldName, 30));
-    const fieldTypeF = chalk.cyan("/* " + r(fieldType + opt, 17) + (field.isArray ? "[]" : "  ") + " */");
+    const fieldTypeF = chalk.cyan(`/* ${allowSubTypeSymbol}${r(fieldType + opt, 38)}${arraySymbol}  */`);
 
     // detected when optional field is not specified in value
     if (field.switchBit !== undefined && value === undefined) {
@@ -297,19 +307,12 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
             _dump_simple_value(self, field, data, value, fieldType);
         } else {
             const typeDictionary = (self.schema as any).$$factory as DataTypeFactory;
+
             // istanbul ignore next
             if (!typeDictionary) {
-                // tslint:disable-next-line: no-console
-                console.log(" No typeDictionary for ", self.schema);
+                errorLog("Internal Error: No typeDictionary for ", self.schema);
                 return;
             }
-            field.fieldTypeConstructor = field.fieldTypeConstructor || typeDictionary.getStructureTypeConstructor(fieldType);
-            const fieldTypeConstructor = field.fieldTypeConstructor;
-
-            const _newFieldSchema =
-                (field.schema as StructuredTypeSchema) ||
-                fieldTypeConstructor.prototype.schema ||
-                (fieldTypeConstructor as any).schema;
 
             if (field.isArray) {
                 if (value === null) {
@@ -322,13 +325,16 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
 
                     for (let i = 0; i < m; i++) {
                         const element = value[i];
-                        data.lines.push(padding + chalk.cyan("  { " + ("/*" + i + "*/")));
+
+                        const _newFieldSchema = _findFieldSchema(typeDictionary, field, element);
+
+                        data.lines.push(padding + `  { ` + chalk.cyan(`/* ${i} - ${_newFieldSchema?.name}*/`));
 
                         const data1 = {
                             lines: [] as string[],
                             padding: padding + "    "
                         };
-                        applyOnAllSchemaFields(element, _newFieldSchema, data1, _exploreObject, args);
+                        _applyOnAllSchemaFields(element, _newFieldSchema, data1, _exploreObject, args);
 
                         data.lines = data.lines.concat(data1.lines);
 
@@ -340,9 +346,10 @@ function _exploreObject(self: BaseUAObject, field: StructuredTypeField, data: Ex
                     data.lines.push(padding + "]");
                 }
             } else {
+                const _newFieldSchema = _findFieldSchema(typeDictionary, field, value);
                 data.lines.push(fieldNameF + " " + fieldTypeF + ": {");
                 const data1 = { padding: padding + "  ", lines: [] as string[] };
-                applyOnAllSchemaFields(value, _newFieldSchema, data1, _exploreObject, args);
+                _applyOnAllSchemaFields(value, _newFieldSchema, data1, _exploreObject, args);
                 data.lines = data.lines.concat(data1.lines);
 
                 data.lines.push(padding + "}");
@@ -383,7 +390,7 @@ function json_ify(t: BuiltInTypeDefinition, value: any, fieldType: FieldType) {
     }
 }
 
-function _JSONify(self: BaseUAObject, schema: StructuredTypeSchema, pojo: any) {
+function _JSONify(self: BaseUAObject, schema: IStructuredTypeSchema, pojo: any) {
     /* jshint validthis: true */
     for (const field of schema.fields) {
         const fieldValue = (self as any)[field.name];
@@ -391,8 +398,8 @@ function _JSONify(self: BaseUAObject, schema: StructuredTypeSchema, pojo: any) {
             continue;
         }
 
-        if (hasEnumeration(field.fieldType)) {
-            const enumeration = getEnumeration(field.fieldType);
+        if (hasBuiltInEnumeration(field.fieldType)) {
+            const enumeration = getBuiltInEnumeration(field.fieldType);
             assert(enumeration !== null);
             if (field.isArray) {
                 pojo[field.name] = fieldValue.map((value: any) => enumeration.enumValues[value.toString()]);
@@ -401,7 +408,7 @@ function _JSONify(self: BaseUAObject, schema: StructuredTypeSchema, pojo: any) {
             }
             continue;
         }
-        const t = getBuildInType(field.fieldType);
+        const t = field.schema as BuiltInTypeDefinition; // getBuiltInType(field.fieldType);
 
         if (field.isArray) {
             pojo[field.name] = fieldValue.map((value: any) => json_ify(t, value, field));
@@ -411,15 +418,8 @@ function _JSONify(self: BaseUAObject, schema: StructuredTypeSchema, pojo: any) {
     }
 }
 
-export interface DecodeDebugOptions {
-    tracer: any;
-    name: string;
-}
-
-/* tslint:disable:no-empty*/
-
-export interface BaseUAObject {
-    schema: StructuredTypeSchema;
+export interface BaseUAObject extends IBaseUAObject {
+    schema: IStructuredTypeSchema;
 }
 
 /**
@@ -458,7 +458,7 @@ export class BaseUAObject {
      */
     public binaryStoreSize(): number {
         const stream = new BinaryStreamSizeCalculator();
-        this.encode(stream as OutputBinaryStream);
+        this.encode(stream);
         return stream.length;
     }
 
@@ -548,12 +548,16 @@ export class BaseUAObject {
 
         data.lines.push("{" + chalk.cyan(" /*" + (this.schema ? this.schema.name : "") + "*/"));
         if (this.schema) {
-            applyOnAllSchemaFields(this, this.schema, data, _exploreObject, arguments);
+            this.applyOnAllFields(_exploreObject, data);
         }
         data.lines.push("};");
         return data.lines.join("\n");
     }
 
+    public applyOnAllFields<T>(func: Func1<T>, data: T): void {
+        _applyOnAllSchemaFields(this, this.schema, data, func, null);
+    }
+
     public toJSON(): any {
         assert(this.schema);
         if (this.schema.toJSON) {
@@ -579,7 +583,7 @@ export class BaseUAObject {
                     continue;
                 }
                 if (field.isArray) {
-                    options[field.name] = self[field.name];
+                    options[field.name] = [...self[field.name]];
                 } else {
                     options[field.name] = self[field.name];
                 }
@@ -594,9 +598,9 @@ export class BaseUAObject {
 
 function _visitSchemaChain(
     self: BaseUAObject,
-    schema: StructuredTypeSchema,
+    schema: IStructuredTypeSchema,
     pojo: any,
-    func: (self: BaseUAObject, schema: StructuredTypeSchema, pojo: any) => void,
+    func: (self: BaseUAObject, schema: IStructuredTypeSchema, pojo: any) => void,
     extraData: any
 ) {
     assert(typeof func === "function");

package/source/{factories_basic_type.ts → basic_type.ts}

@@ -4,10 +4,10 @@
 import { assert } from "node-opcua-assert";
 import { decodeLocaleId, encodeLocaleId, validateLocaleId } from "node-opcua-basic-types";
 import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import { make_errorLog } from "node-opcua-debug";
+import { getBuiltInType, hasBuiltInType, registerType } from "./builtin_types";
 
-import { findSimpleType, hasBuiltInType, registerType } from "./factories_builtin_types";
-import { BasicTypeDefinition, BasicTypeDefinitionOptions } from "./types";
-
+const errorLog = make_errorLog("Factory");
 export interface BasicTypeOptions {
     name: string;
     subType: string;
@@ -51,14 +51,13 @@ export function registerBasicType(schema: BasicTypeOptions): void {
 
     /* istanbul ignore next */
     if (exists) {
-        // tslint:disable-next-line: no-console
-        console.log("registerBasicType:", schema);
+        errorLog("registerBasicType:", schema);
         throw new Error(`Basic Type ${schema.name} already registered`);
     }
 
     const name = schema.name;
 
-    const t: BasicTypeDefinition = findSimpleType(schema.subType);
+    const t = getBuiltInType(schema.subType);
 
     /* istanbul ignore next */
     if (!t) {
@@ -86,8 +85,8 @@ export function registerBasicType(schema: BasicTypeOptions): void {
         subType: schema.subType,
 
         coerce: coerceFunc,
-        decode: decodeFunc,
-        encode: encodeFunc,
+        decode: decodeFunc!,
+        encode: encodeFunc!,
 
         random,
 
@@ -105,15 +104,7 @@ export function registerBasicType(schema: BasicTypeOptions): void {
 registerBasicType({ name: "Counter", subType: "UInt32" });
 // OPC Unified Architecture, part 3.0 $8.13 page 65
 registerBasicType({ name: "Duration", subType: "Double" });
-registerBasicType({ name: "UAString", subType: "String" });
-registerBasicType({ name: "UABoolean", subType: "Boolean" });
 registerBasicType({ name: "UtcTime", subType: "DateTime" });
-// already ? registerBasicType({name: "Int8",     subType: "SByte"});
-// already ? registerBasicType({name: "UInt8",    subType: "Byte"});
-registerBasicType({ name: "Char", subType: "Byte" });
-// xx registerBasicType({name:"XmlElement" ,subType:"String"  });
-// xx registerBasicType({ name: "Time", subType: "String" });
-// string in the form "en-US" or "de-DE" or "fr" etc...
 
 registerBasicType({
     name: "LocaleId",
@@ -128,8 +119,6 @@ registerBasicType({
 
 registerBasicType({ name: "ContinuationPoint", subType: "ByteString" });
 registerBasicType({ name: "Image", subType: "ByteString" });
-registerBasicType({ name: "NodeIdType", subType: "NodeId" });
-
 registerBasicType({ name: "ImageBMP", subType: "Image" });
 registerBasicType({ name: "ImageGIF", subType: "Image" });
 registerBasicType({ name: "ImageJPG", subType: "Image" });
@@ -156,13 +145,3 @@ registerBasicType({ name: "Index", subType: "UInt32" });
 registerBasicType({ name: "VersionTime", subType: "UInt32" });
 registerBasicType({ name: "ApplicationInstanceCertificate", subType: "ByteString" });
 registerBasicType({ name: "AttributeWriteMask", subType: "UInt32" });
-registerBasicType({ name: "Date", subType: "DateTime" });
-
-// registerBasicType({ name: "Counter", subType: "UInt32" });
-// registerBasicType({ name: "IntegerId", subType: "UInt32" });
-// registerBasicType({ name: "UtcTime", subType: "DateTime" });
-// registerBasicType({ name: "Duration", subType: "Double" });
-// registerBasicType({ name: "LocaleId", subType: "String" });
-// registerBasicType({ name: "NumericRange", subType: "String" });
-// registerBasicType({ name: "Time", subType: "String" });
-// registerBasicType({ name: "SessionAuthenticationToken", subType: "NodeId" });

package/source/{factories_builtin_types.ts → builtin_types.ts}

@@ -13,13 +13,11 @@ import {
     coerceInt16,
     coerceInt32,
     coerceInt64,
-    coerceInt8,
     coerceNodeId,
     coerceSByte,
     coerceUInt16,
     coerceUInt32,
     coerceUInt64,
-    coerceUInt8,
     decodeBoolean,
     decodeByte,
     decodeByteString,
@@ -31,14 +29,12 @@ import {
     decodeInt16,
     decodeInt32,
     decodeInt64,
-    decodeInt8,
     decodeNodeId,
     decodeSByte,
     decodeString,
     decodeUInt16,
     decodeUInt32,
     decodeUInt64,
-    decodeUInt8,
     encodeBoolean,
     encodeByte,
     encodeByteString,
@@ -50,70 +46,106 @@ import {
     encodeInt16,
     encodeInt32,
     encodeInt64,
-    encodeInt8,
     encodeNodeId,
     encodeSByte,
     encodeString,
     encodeUInt16,
     encodeUInt32,
     encodeUInt64,
-    encodeUInt8
+    minDate
 } from "node-opcua-basic-types";
 import { BinaryStream, OutputBinaryStream } from "node-opcua-binary-stream";
+import { DataTypeIds } from "node-opcua-constants";
+
 import { emptyGuid } from "node-opcua-guid";
 import { makeExpandedNodeId, makeNodeId } from "node-opcua-nodeid";
 import { coerceStatusCode, decodeStatusCode, encodeStatusCode, StatusCodes } from "node-opcua-status-code";
-import { BasicTypeDefinition, BasicTypeDefinitionOptions, FieldCategory, TypeSchemaBase } from "./types";
+import { defaultEncode, defaultDecode, decodeNull, encodeNull, decodeAny, encodeAny, toJSONGuid } from "./encode_decode";
+import { BasicTypeDefinition, BasicTypeDefinitionOptions, BasicTypeDefinitionOptionsBase, CommonInterface, FieldCategory, TypeSchemaConstructorOptions } from "./types";
+
 
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-function defaultEncode(value: any, stream: OutputBinaryStream): void {}
+/**
+ * @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;
+    public subType: string;
+    public isAbstract: boolean;
+
+    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];
+            }
+        }
+        this.subType = options.subType || "";
+        this.isAbstract = options.isAbstract || false;
+    }
 
-function defaultDecode(stream: BinaryStream): any {
-    return null;
+    /**
+     * @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;
+    }
+
+    public getBaseType(): CommonInterface | null {
+        if (!this.subType) return null;
+        return getBuiltInType(this.subType) as CommonInterface;
+    }
+
+    public isSubTypeOf(type: CommonInterface): boolean {
+        if (this.name === type.name) {
+            return true;
+        }
+        const baseType = this.getBaseType();
+        if (!baseType) {
+            return false;
+        }
+        return baseType.isSubTypeOf(type);
+    }
 }
 
 export class BasicTypeSchema extends TypeSchemaBase implements BasicTypeDefinition {
     public subType: string;
-
+    public isAbstract: boolean;
     public encode: (value: any, stream: OutputBinaryStream) => void;
     public decode: (stream: BinaryStream) => any;
 
     constructor(options: BasicTypeDefinitionOptions) {
         super(options);
         this.subType = options.subType;
+        this.isAbstract = options.isAbstract || false;
         this.encode = options.encode || defaultEncode;
         this.decode = options.decode || defaultDecode;
     }
 }
 
-export const minDate = new Date(Date.UTC(1601, 0, 1, 0, 0, 0));
-
-function defaultGuidValue(): any {
-    return Buffer.alloc(0);
-}
-
-function toJSONGuid(value: any): any {
-    if (typeof value === "string") {
-        return value;
-    }
-    assert(value instanceof Buffer);
-    return value.toString("base64");
-}
-
-function encodeAny(value: any, stream: OutputBinaryStream) {
-    assert(false, "type 'Any' cannot be encoded");
-}
-
-function decodeAny(stream: BinaryStream) {
-    assert(false, "type 'Any' cannot be decoded");
-}
-
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-function encodeNull(value: any, stream: OutputBinaryStream): void {}
-
-function decodeNull(stream: BinaryStream): any {
-    return null;
-}
 
 // there are 4 types of DataTypes in opcua:
 //   Built-In DataType
@@ -132,8 +164,9 @@ interface T {
     defaultValue?: any;
     toJSON?: any;
 }
+
 // Built-In Type
-const _defaultType: any[] = [
+const _defaultType: BasicTypeDefinitionOptionsBase[] = [
     // Built-in DataTypes ( see OPCUA Part III v1.02 - $5.8.2 )
     {
         name: "Null",
@@ -144,8 +177,8 @@ const _defaultType: any[] = [
         defaultValue: null
     },
     {
+        // special case
         name: "Any",
-
         decode: decodeAny,
         encode: encodeAny
     },
@@ -158,17 +191,19 @@ const _defaultType: any[] = [
         coerce: coerceBoolean,
         defaultValue: false
     },
-    { name: "Int8", encode: encodeInt8, decode: decodeInt8, defaultValue: 0, coerce: coerceInt8 },
-    { name: "UInt8", encode: encodeUInt8, decode: decodeUInt8, defaultValue: 0, coerce: coerceUInt8 },
-    { name: "SByte", encode: encodeSByte, decode: decodeSByte, defaultValue: 0, coerce: coerceSByte },
-    { name: "Byte", encode: encodeByte, decode: decodeByte, defaultValue: 0, coerce: coerceByte },
-    { name: "Int16", encode: encodeInt16, decode: decodeInt16, defaultValue: 0, coerce: coerceInt16 },
-    { name: "UInt16", encode: encodeUInt16, decode: decodeUInt16, defaultValue: 0, coerce: coerceUInt16 },
-    { name: "Int32", encode: encodeInt32, decode: decodeInt32, defaultValue: 0, coerce: coerceInt32 },
-    { name: "UInt32", encode: encodeUInt32, decode: decodeUInt32, defaultValue: 0, coerce: coerceUInt32 },
+
+    { name: "Number", isAbstract: true },
+    { name: "Integer", subType: "Number", isAbstract: true },
+    { name: "UInteger", subType: "Number", isAbstract: true },
+    { name: "SByte", subType: "Integer", encode: encodeSByte, decode: decodeSByte, defaultValue: 0, coerce: coerceSByte },
+    { name: "Byte", subType: "UInteger", encode: encodeByte, decode: decodeByte, defaultValue: 0, coerce: coerceByte },
+    { name: "Int16", subType: "Integer", encode: encodeInt16, decode: decodeInt16, defaultValue: 0, coerce: coerceInt16 },
+    { name: "UInt16", subType: "UInteger", encode: encodeUInt16, decode: decodeUInt16, defaultValue: 0, coerce: coerceUInt16 },
+    { name: "Int32", subType: "Integer", encode: encodeInt32, decode: decodeInt32, defaultValue: 0, coerce: coerceInt32 },
+    { name: "UInt32", subType: "UInteger", encode: encodeUInt32, decode: decodeUInt32, defaultValue: 0, coerce: coerceUInt32 },
     {
         name: "Int64",
-
+        subType: "Integer",
         decode: decodeInt64,
         encode: encodeInt64,
 
@@ -177,7 +212,7 @@ const _defaultType: any[] = [
     },
     {
         name: "UInt64",
-
+        subType: "UInteger",
         decode: decodeUInt64,
         encode: encodeUInt64,
 
@@ -186,6 +221,7 @@ const _defaultType: any[] = [
     },
     {
         name: "Float",
+        subType: "Number",
 
         decode: decodeFloat,
         encode: encodeFloat,
@@ -195,6 +231,7 @@ const _defaultType: any[] = [
     },
     {
         name: "Double",
+        subType: "Number",
 
         decode: decodeDouble,
         encode: encodeDouble,
@@ -218,7 +255,7 @@ const _defaultType: any[] = [
         encode: encodeDateTime,
 
         coerce: coerceDateTime,
-        defaultValue: exports.minDate
+        defaultValue: ()=> minDate
     },
     {
         name: "Guid",
@@ -315,18 +352,20 @@ _defaultType.forEach(registerType);
  * @method registerType
  * @param schema {TypeSchemaBase}
  */
-export function registerType(schema: BasicTypeDefinitionOptions): void {
-    assert(typeof schema.name === "string");
-    if (typeof schema.encode !== "function") {
-        throw new Error("schema " + schema.name + " has no encode function");
-    }
-    if (typeof schema.decode !== "function") {
-        throw new Error("schema " + schema.name + " has no decode function");
+export function registerType(schema: BasicTypeDefinitionOptionsBase): void {
+    if (!schema.isAbstract) {
+        assert(schema.encode);
+        assert(schema.decode);
     }
-
     schema.category = FieldCategory.basic;
-
-    const definition = new BasicTypeSchema(schema);
+    schema.subType = schema.subType || "";
+    if (schema.name !== "Null" && schema.name !== "Any" && schema.name !== "Variant" && schema.name !== "ExtensionObject") {
+        const dataType = DataTypeIds[schema.name as keyof typeof DataTypeIds];
+        if (!dataType) {
+            throw new Error("registerType : dataType " + schema.name + " is not defined");
+        }
+    }
+    const definition = new BasicTypeSchema(schema as BasicTypeDefinitionOptions);
     _defaultTypeMap.set(schema.name, definition);
 }
 
@@ -336,46 +375,29 @@ export function unregisterType(typeName: string): void {
     _defaultTypeMap.delete(typeName);
 }
 
-/**
- * @method findSimpleType
- * @param name
- * @return {TypeSchemaBase|null}
- */
-export function findSimpleType(name: string): BasicTypeDefinition {
+export function getBuiltInType(name: string): TypeSchemaBase {
     const typeSchema = _defaultTypeMap.get(name);
     if (!typeSchema) {
         throw new Error("Cannot find schema for simple type " + name);
     }
-    assert(typeSchema instanceof TypeSchemaBase);
-    return typeSchema as BasicTypeDefinition;
+    return typeSchema;
 }
 
 export function hasBuiltInType(name: string): boolean {
     return _defaultTypeMap.has(name);
 }
 
-export function getBuildInType(name: string): BasicTypeDefinition {
-    return _defaultTypeMap.get(name) as BasicTypeDefinition;
-}
-
-/**
- * @method findBuiltInType
- * find the Builtin Type that this
- * @param dataTypeName
- * @return {*}
- */
+/** */
 export function findBuiltInType(dataTypeName: string): BasicTypeDefinition {
     assert(typeof dataTypeName === "string", "findBuiltInType : expecting a string " + dataTypeName);
-    const t = _defaultTypeMap.get(dataTypeName) as BasicTypeDefinition;
-    if (!t) {
-        throw new Error("datatype " + dataTypeName + " must be registered");
-    }
+    const t = getBuiltInType(dataTypeName);
     if (t.subType && t.subType !== t.name /* avoid infinite recursion */) {
-        return findBuiltInType(t.subType);
+        const st = getBuiltInType(t.subType);
+        if (!st.isAbstract) {
+            return findBuiltInType(t.subType);
+        }
     }
     return t;
 }
 
-export function getTypeMap(): Map<string, BasicTypeSchema> {
-    return _defaultTypeMap;
-}
+