@opra/common 0.18.4 → 0.19.0

package/esm/document/data-type/enum-type.js

@@ -1,58 +1,64 @@
 import omit from 'lodash.omit';
+import merge from 'putil-merge';
+import * as vg from 'valgen';
 import { omitUndefined } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
 import { DataType } from './data-type.js';
-/**
- * @class EnumType
- */
-export const EnumType = function (...args) {
-    // Injector
-    if (!this) {
-        const [source, options] = args;
-        const values = Array.isArray(source)
-            ? source.reduce((obj, v) => {
-                obj[v] = v;
-                return obj;
-            }, {})
-            : source;
-        const metadata = {
-            kind: OpraSchema.EnumType.Kind,
-            values
-        };
-        if (options)
-            Object.assign(metadata, omit(options, ['kind', 'values']));
-        Reflect.defineMetadata(METADATA_KEY, metadata, source);
-        return values;
+class EnumTypeClass extends DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = OpraSchema.EnumType.Kind;
+        this.base = init.base;
+        this.ownValues = init.values;
+        this.ownMeanings = init.meanings || {};
+        this.values = { ...this.base?.values, ...this.ownValues };
+        this.meanings = { ...this.base?.meanings, ...this.ownMeanings };
     }
-    // Constructor
-    const [, init] = args;
-    // call super()
-    DataType.apply(this, args);
-    const _this = this;
-    _this.kind = OpraSchema.EnumType.Kind;
-    _this.base = init.base;
-    const own = _this.own;
-    own.values = init.values;
-    own.meanings = init.meanings || {};
-    _this.values = { ..._this.base?.values, ...own.values };
-    _this.meanings = { ..._this.base?.meanings, ...own.meanings };
-};
-const proto = {
     exportSchema() {
         const out = DataType.prototype.exportSchema.call(this);
         Object.assign(out, omitUndefined({
             base: this.base ?
                 (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            values: this.own.values,
-            meanings: this.own.meanings
+            values: this.ownValues,
+            meanings: this.ownMeanings
         }));
         return out;
-    },
-    validate(v) {
-        if (!this.values[v])
-            throw new Error(`'${v}' is not a valid'${this.name ? ' ' + this.name : ''}' value`);
     }
+    _getDecoder() {
+        if (!this._decoder)
+            this._decoder = vg.isEnum(Object.values(this.values), { enumName: this.name });
+        return this._decoder;
+    }
+    _getEncoder() {
+        return this._getDecoder();
+    }
+}
+/**
+ * @class EnumType
+ */
+export const EnumType = function (...args) {
+    if (this) {
+        // Constructor
+        const [document, init] = args;
+        merge(this, new EnumTypeClass(document, init), { descriptor: true });
+        return;
+    }
+    // Injector
+    const [source, options] = args;
+    const values = Array.isArray(source)
+        ? source.reduce((obj, v) => {
+            obj[v] = v;
+            return obj;
+        }, {})
+        : source;
+    const metadata = {
+        kind: OpraSchema.EnumType.Kind,
+        values
+    };
+    if (options)
+        Object.assign(metadata, omit(options, ['kind', 'values']));
+    Reflect.defineMetadata(METADATA_KEY, metadata, source);
+    return values;
 };
-Object.assign(EnumType.prototype, proto);
-Object.setPrototypeOf(EnumType.prototype, DataType.prototype);
+EnumType.prototype = EnumTypeClass.prototype;

package/esm/document/data-type/mapped-type.js

@@ -1,91 +1,135 @@
+import merge from 'putil-merge';
+import * as vg from 'valgen';
 import { applyMixins, inheritPropertyInitializers, omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
 import { DataType } from './data-type.js';
-/**
- * @class MappedType
- */
-export const MappedType = function (...args) {
-    let pickKeys;
-    let omitKeys;
-    const isInheritedPredicate = (propertyName) => {
-        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
-            return false;
-        if (pickKeys)
-            return pickKeys.includes(propertyName.toLowerCase());
-        return true;
-    };
-    // MappedType helper
-    if (!this) {
-        const [source, options] = args;
-        pickKeys = options.pick && options.pick.map(x => String(x).toLowerCase());
-        omitKeys = options.omit && options.omit.map(x => String(x).toLowerCase());
-        class MappedClass {
-            constructor() {
-                inheritPropertyInitializers(this, source, isInheritedPredicate);
-            }
+class MappedTypeClass extends DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = OpraSchema.MappedType.Kind;
+        const own = this.own;
+        own.pick = init.pick;
+        own.omit = init.omit;
+        this.kind = OpraSchema.MappedType.Kind;
+        this.type = init.type;
+        this.pick = own.pick;
+        this.omit = own.omit;
+        this.fields = new ResponsiveMap();
+        this.additionalFields = this.type.additionalFields;
+        const isInheritedPredicate = getIsInheritedPredicateFn(init.pick, init.omit);
+        for (const [elemName, elem] of this.type.fields.entries()) {
+            if (isInheritedPredicate(elemName))
+                this.fields.set(elemName, elem);
         }
-        applyMixins(MappedClass, source);
-        // const mappedTypeMetadata: MappedType.TypeMapping[] = [];
-        const m = Reflect.getOwnMetadata(METADATA_KEY, source);
-        if (!m)
-            throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
-        if (!(m.kind === OpraSchema.ComplexType.Kind))
-            throw new TypeError(`Class "${source}" is not a ${OpraSchema.ComplexType.Kind}`);
-        const metadata = {
-            kind: 'MappedType',
-            type: source
-        };
-        if (options.pick)
-            metadata.pick = options.pick;
-        if (options.omit)
-            metadata.omit = options.omit;
-        Reflect.defineMetadata(METADATA_KEY, metadata, MappedClass);
-        MappedType._applyMixin(MappedClass, source, {
-            ...options,
-            isInheritedPredicate
-        });
-        return MappedClass;
     }
-    // Constructor
-    // call super()
-    DataType.apply(this, args);
-    const [, init] = args;
-    pickKeys = init.pick && init.pick.map(x => String(x).toLowerCase());
-    omitKeys = init.omit && init.omit.map(x => String(x).toLowerCase());
-    const _this = this;
-    const own = _this.own;
-    own.type = init.type;
-    own.pick = init.pick;
-    own.omit = init.omit;
-    _this.kind = OpraSchema.MappedType.Kind;
-    _this.type = own.type;
-    _this.pick = own.pick;
-    _this.omit = own.omit;
-    _this.fields = new ResponsiveMap();
-    _this.additionalFields = _this.type.additionalFields;
-    for (const [elemName, elem] of own.type.fields.entries()) {
-        if (isInheritedPredicate(elemName))
-            _this.fields.set(elemName, elem);
-    }
-};
-MappedType._applyMixin = () => void 0;
-const proto = {
     exportSchema() {
         const out = DataType.prototype.exportSchema.call(this);
         Object.assign(out, omitUndefined({
-            type: this.own.type.name ? this.own.type.name : this.own.type.exportSchema(),
+            type: this.type.name ? this.type.name : this.type.exportSchema(),
             pick: this.own.pick,
             omit: this.own.omit,
         }));
         return out;
     }
+    _getDecoder() {
+        if (this._decoder)
+            return this._decoder;
+        const schema = {};
+        for (const f of this.fields.values()) {
+            let t = f.type.getDecoder();
+            if (f.isArray)
+                t = vg.isArray(t);
+            schema[f.name] = t;
+        }
+        this._decoder = vg.isObject(schema, {
+            additionalFields: this.additionalFields,
+            name: this.name,
+            caseInSensitive: true
+        });
+        return this._decoder;
+    }
+    _getEncoder() {
+        if (this._encoder)
+            return this._encoder;
+        const schema = {};
+        for (const f of this.fields.values()) {
+            let t = f.type.getEncoder();
+            if (f.isArray)
+                t = vg.isArray(t);
+            schema[f.name] = t;
+        }
+        this._encoder = vg.isObject(schema, {
+            additionalFields: this.additionalFields,
+            name: this.name,
+            caseInSensitive: true,
+            detectCircular: true
+        });
+        return this._encoder;
+    }
+}
+/**
+ * @class MappedType
+ */
+export const MappedType = function (...args) {
+    // Constructor
+    if (this) {
+        const [document, init] = args;
+        merge(this, new MappedTypeClass(document, init), { descriptor: true });
+        return;
+    }
+    // MappedType helper
+    const [source, options] = args;
+    const isInheritedPredicate = getIsInheritedPredicateFn(options.pick, options.omit);
+    class MappedClass {
+        constructor() {
+            inheritPropertyInitializers(this, source, isInheritedPredicate);
+        }
+    }
+    applyMixins(MappedClass, source);
+    // const mappedTypeMetadata: MappedType.TypeMapping[] = [];
+    const m = Reflect.getOwnMetadata(METADATA_KEY, source);
+    if (!m)
+        throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
+    if (!(m.kind === OpraSchema.ComplexType.Kind))
+        throw new TypeError(`Class "${source}" is not a ${OpraSchema.ComplexType.Kind}`);
+    const metadata = {
+        kind: 'MappedType',
+        type: source
+    };
+    if (options.pick)
+        metadata.pick = options.pick;
+    if (options.omit)
+        metadata.omit = options.omit;
+    Reflect.defineMetadata(METADATA_KEY, metadata, MappedClass);
+    MappedType._applyMixin(MappedClass, source, {
+        ...options,
+        isInheritedPredicate
+    });
+    return MappedClass;
 };
-Object.assign(MappedType.prototype, proto);
-Object.setPrototypeOf(MappedType.prototype, DataType.prototype);
+MappedType.prototype = MappedTypeClass.prototype;
+MappedType._applyMixin = () => void 0;
+function getIsInheritedPredicateFn(pick, omit) {
+    const pickKeys = pick?.map(x => String(x).toLowerCase());
+    const omitKeys = omit?.map(x => String(x).toLowerCase());
+    return (propertyName) => {
+        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
+            return false;
+        if (pickKeys)
+            return pickKeys.includes(propertyName.toLowerCase());
+        return true;
+    };
+}
+/**
+ *
+ */
 export function PickType(classRef, keys) {
     return MappedType(classRef, { pick: keys });
 }
+/**
+ *
+ */
 export function OmitType(classRef, keys) {
     return MappedType(classRef, { omit: keys });
 }

package/esm/document/data-type/simple-type.js

@@ -1,56 +1,57 @@
 import omit from 'lodash.omit';
-import { omitUndefined } from '../../helpers/index.js';
+import merge from 'putil-merge';
+import * as vg from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY, TYPENAME_PATTERN } from '../constants.js';
 import { DataType } from './data-type.js';
 /**
  * @class SimpleType
  */
-export const SimpleType = function (...args) {
-    // ClassDecorator
-    if (!this) {
-        const [options] = args;
-        return function (target) {
-            let name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-            name = name.charAt(0).toLowerCase() + name.substring(1);
-            const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
-            metadata.kind = OpraSchema.SimpleType.Kind;
-            metadata.name = name;
-            if (options)
-                Object.assign(metadata, omit(options, ['kind', 'name', 'base']));
-            Reflect.defineMetadata(METADATA_KEY, metadata, target);
-        };
+class SimpleTypeClass extends DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = OpraSchema.SimpleType.Kind;
+        this.base = init.base;
+        this._decoder = init.decoder || init.base?._decoder || vg.isAny();
+        this._encoder = init.encoder || init.base?._encoder || vg.isAny();
+    }
+    _getDecoder() {
+        return this._decoder;
+    }
+    _getEncoder() {
+        return this._encoder;
     }
-    // Constructor
-    const [, options] = args;
-    // call super()
-    DataType.apply(this, args);
-    const _this = this;
-    _this.kind = OpraSchema.SimpleType.Kind;
-    _this.base = options?.base;
-    const own = _this.own;
-    own.codec = options?.codec;
-    own.ctor = options?.ctor;
-    if (options?.pattern)
-        own.pattern = (options?.pattern instanceof RegExp ? options.pattern : new RegExp(options.pattern));
-    const ctor = own.ctor || _this.base?.ctor;
-    _this.ctor = ctor || Object;
-    _this.decode = own.codec?.decode || _this.base?.decode || ((v) => v);
-    _this.encode = own.codec?.encode || _this.base?.encode || ((v) => v);
-    _this.coerce = own.codec?.coerce || _this.base?.coerce || ((v) => v);
-    _this.validate = own.codec?.validate || _this.base?.validate || (() => true);
-    _this.pattern = own.pattern || _this.base?.pattern;
-};
-const proto = {
     exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
-            base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            pattern: this.own.pattern
-        }));
+        // noinspection UnnecessaryLocalVariableJS
+        const out = super.exportSchema();
+        // Object.assign(out, omitUndefined({
+        //   base: this.base ?
+        //       (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
+        // }));
         return out;
     }
+}
+/**
+ * @class SimpleType
+ */
+export const SimpleType = function (...args) {
+    // Constructor
+    if (this) {
+        const [document, init] = args;
+        merge(this, new SimpleTypeClass(document, init), { descriptor: true });
+        return;
+    }
+    // ClassDecorator
+    const [options] = args;
+    return function (target) {
+        let name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
+        name = name.charAt(0).toLowerCase() + name.substring(1);
+        const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
+        metadata.kind = OpraSchema.SimpleType.Kind;
+        metadata.name = name;
+        if (options)
+            Object.assign(metadata, omit(options, ['kind', 'name']));
+        Reflect.defineMetadata(METADATA_KEY, metadata, target);
+    };
 };
-Object.assign(SimpleType.prototype, proto);
-Object.setPrototypeOf(SimpleType.prototype, DataType.prototype);
+SimpleType.prototype = SimpleTypeClass.prototype;

package/esm/document/data-type/union-type.js

@@ -1,53 +1,83 @@
+import merge from 'putil-merge';
+import * as vg from 'valgen';
 import { applyMixins, inheritPropertyInitializers, omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
 import { ComplexType } from './complex-type.js';
 import { DataType } from './data-type.js';
 import { MappedType } from './mapped-type.js';
-/**
- * @class UnionType
- */
-export const UnionType = function (...args) {
-    // UnionType helper
-    if (!this) {
-        return mapToUnionType(...args);
-    }
-    // Constructor
-    // call super()
-    DataType.apply(this, args);
-    const [, init] = args;
-    const _this = this;
-    _this.fields = new ResponsiveMap();
-    const own = _this.own;
-    own.types = [];
-    for (const base of init.types) {
-        if (!(base instanceof ComplexType || base instanceof UnionType || base instanceof MappedType))
-            throw new TypeError(`${OpraSchema.UnionType.Kind} shall contain ${OpraSchema.ComplexType.Kind}, ` +
-                `${OpraSchema.UnionType.Kind} of ${OpraSchema.MappedType.Kind} types.`);
-        own.types.push(base);
-        if (base.additionalFields)
-            _this.additionalFields = true;
-        _this.fields.setAll(base.fields);
+class UnionTypeClass extends DataType {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = OpraSchema.UnionType.Kind;
+        this.fields = new ResponsiveMap();
+        const own = this.own;
+        own.types = [];
+        for (const base of init.types) {
+            if (!(base instanceof ComplexType || base instanceof UnionType || base instanceof MappedType))
+                throw new TypeError(`${OpraSchema.UnionType.Kind} shall contain ${OpraSchema.ComplexType.Kind}, ` +
+                    `${OpraSchema.UnionType.Kind} of ${OpraSchema.MappedType.Kind} types.`);
+            own.types.push(base);
+            if (base.additionalFields)
+                this.additionalFields = true;
+            this.fields.setAll(base.fields);
+        }
+        this.types = [...own.types];
     }
-    _this.kind = 'UnionType';
-    _this.types = [...own.types];
-};
-UnionType._applyMixin = () => void 0;
-const proto = {
     exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
+        const out = super.exportSchema();
         Object.assign(out, omitUndefined({
             types: this.own.types.map(t => t.name ? t.name : t.exportSchema())
         }));
         return out;
     }
-};
-Object.assign(UnionType.prototype, proto);
-Object.setPrototypeOf(UnionType.prototype, DataType.prototype);
+    _getDecoder() {
+        if (this._decoder)
+            return this._decoder;
+        const schema = {};
+        for (const f of this.fields.values()) {
+            let t = f.type.getDecoder();
+            if (f.isArray)
+                t = vg.isArray(t);
+            schema[f.name] = t;
+        }
+        this._decoder = vg.isObject(schema, {
+            additionalFields: this.additionalFields,
+            name: this.name,
+            caseInSensitive: true
+        });
+        return this._decoder;
+    }
+    _getEncoder() {
+        if (this._encoder)
+            return this._encoder;
+        const schema = {};
+        for (const f of this.fields.values()) {
+            let t = f.type.getEncoder();
+            if (f.isArray)
+                t = vg.isArray(t);
+            schema[f.name] = t;
+        }
+        this._encoder = vg.isObject(schema, {
+            additionalFields: this.additionalFields,
+            name: this.name,
+            caseInSensitive: true,
+            detectCircular: true
+        });
+        return this._encoder;
+    }
+}
 /**
- *
+ * @class UnionType
  */
-function mapToUnionType(...args) {
+export const UnionType = function (...args) {
+    // Constructor
+    if (this) {
+        const [document, init] = args;
+        merge(this, new UnionTypeClass(document, init), { descriptor: true });
+        return;
+    }
+    // UnionType helper
     // Filter undefined items
     const clasRefs = [...args].filter(x => !!x);
     if (!clasRefs.length)
@@ -75,4 +105,6 @@ function mapToUnionType(...args) {
     }
     UnionType._applyMixin(UnionClass, ...clasRefs);
     return UnionClass;
-}
+};
+UnionType.prototype = UnionTypeClass.prototype;
+UnionType._applyMixin = () => void 0;

package/esm/document/factory/create-document.js

@@ -1,5 +1,5 @@
 import { OpraSchema } from '../../schema/index.js';
-import { AnyType, Base64Type, BigIntType, BooleanType, DateType, GuidType, IntegerType, NumberType, ObjectType, StringType } from '../data-type/builtin/index.js';
+import { AnyType, Base64Type, BigintType, BooleanType, DateType, IntegerType, NumberType, ObjectType, StringType, TimestampType, TimeType, UuidType } from '../data-type/builtin/index.js';
 export async function createDocument(init, options) {
     // const {document, typeQueue, curPath, resourceQueue} = this;
     this.document.url = init.url;
@@ -8,6 +8,8 @@ export async function createDocument(init, options) {
     if (!options?.noBuiltinTypes) {
         const builtinDocument = await this.createBuiltinTypeDocument();
         this.document.references.set('Opra', builtinDocument);
+        for (const [c, s] of Object.getPrototypeOf(this).constructor.designTypeMap.entries())
+            this.document._designTypeMap.set(c, s);
     }
     if (init.references)
         await this.addReferences(init.references);
@@ -64,9 +66,9 @@ export async function createBuiltinTypeDocument() {
                 name: 'MIT'
             }
         },
-        types: [AnyType, Base64Type, BigIntType, BooleanType,
-            DateType, GuidType, IntegerType, NumberType,
-            ObjectType, StringType
+        types: [AnyType, Base64Type, BigintType, BooleanType,
+            DateType, UuidType, IntegerType, NumberType,
+            ObjectType, StringType, TimeType, TimestampType
         ]
     };
     const factoryClass = Object.getPrototypeOf(this).constructor;

package/esm/document/factory/factory.js

@@ -1,3 +1,4 @@
+var _a;
 import { ResponsiveMap } from '../../helpers/index.js';
 import { ApiDocument } from '../api-document.js';
 import { addReferences } from './add-references.js';
@@ -34,25 +35,27 @@ export class DocumentFactory {
         return factory.createDocumentFromUrl(url);
     }
 }
+_a = DocumentFactory;
+DocumentFactory.designTypeMap = new Map();
 (() => {
-    DocumentFactory.prototype.createDocument = createDocument;
-    DocumentFactory.prototype.createDocumentFromUrl = createDocumentFromUrl;
-    DocumentFactory.prototype.createBuiltinTypeDocument = createBuiltinTypeDocument;
-    DocumentFactory.prototype.addReferences = addReferences;
-    DocumentFactory.prototype.importTypeClass = importTypeClass;
-    DocumentFactory.prototype.extractSimpleTypeSchema = extractSimpleTypeSchema;
-    DocumentFactory.prototype.extractComplexTypeSchema = extractComplexTypeSchema;
-    DocumentFactory.prototype.extractMappedTypeSchema = extractMappedTypeSchema;
-    DocumentFactory.prototype.extractUnionTypeSchema = extractUnionTypeSchema;
-    DocumentFactory.prototype.extractEnumTypeSchema = extractEnumTypeSchema;
-    DocumentFactory.prototype.extractFieldSchema = extractFieldSchema;
-    DocumentFactory.prototype.processTypes = processTypes;
-    DocumentFactory.prototype.createDataTypeInstance = createDataTypeInstance;
-    DocumentFactory.prototype.addDataType = addDataType;
-    DocumentFactory.prototype.importResourceClass = importResourceClass;
-    DocumentFactory.prototype.extractSingletonSchema = extractSingletonSchema;
-    DocumentFactory.prototype.extractCollectionSchema = extractCollectionSchema;
-    DocumentFactory.prototype.processResourceQueue = processResourceQueue;
-    DocumentFactory.prototype.createCollection = createCollection;
-    DocumentFactory.prototype.createSingleton = createSingleton;
+    _a.prototype.createDocument = createDocument;
+    _a.prototype.createDocumentFromUrl = createDocumentFromUrl;
+    _a.prototype.createBuiltinTypeDocument = createBuiltinTypeDocument;
+    _a.prototype.addReferences = addReferences;
+    _a.prototype.importTypeClass = importTypeClass;
+    _a.prototype.extractSimpleTypeSchema = extractSimpleTypeSchema;
+    _a.prototype.extractComplexTypeSchema = extractComplexTypeSchema;
+    _a.prototype.extractMappedTypeSchema = extractMappedTypeSchema;
+    _a.prototype.extractUnionTypeSchema = extractUnionTypeSchema;
+    _a.prototype.extractEnumTypeSchema = extractEnumTypeSchema;
+    _a.prototype.extractFieldSchema = extractFieldSchema;
+    _a.prototype.processTypes = processTypes;
+    _a.prototype.createDataTypeInstance = createDataTypeInstance;
+    _a.prototype.addDataType = addDataType;
+    _a.prototype.importResourceClass = importResourceClass;
+    _a.prototype.extractSingletonSchema = extractSingletonSchema;
+    _a.prototype.extractCollectionSchema = extractCollectionSchema;
+    _a.prototype.processResourceQueue = processResourceQueue;
+    _a.prototype.createCollection = createCollection;
+    _a.prototype.createSingleton = createSingleton;
 })();

package/esm/document/factory/import-type-class.js

@@ -1,3 +1,4 @@
+import { validator } from 'valgen';
 import { cloneObject, isConstructor, resolveThunk } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { METADATA_KEY } from '../constants.js';
@@ -63,13 +64,16 @@ metadata) {
     const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
     if (Reflect.hasMetadata(METADATA_KEY, baseClass))
         target.base = await this.importTypeClass(baseClass);
-    target.codec = Object.create(ctor.prototype);
+    if (typeof ctor.prototype.decode === 'function')
+        target.decoder = validator(metadata.name, ctor.prototype.decode);
+    if (typeof ctor.prototype.encode === 'function')
+        target.encoder = validator(metadata.name, ctor.prototype.encode);
 }
 export async function extractComplexTypeSchema(target, ctor, metadata) {
     const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
     if (Reflect.hasMetadata(METADATA_KEY, baseClass))
         target.base = await this.importTypeClass(baseClass);
-    target.ctor = ctor;
+    target.ctor = target.ctor || ctor;
     // Fields
     if (metadata.fields) {
         const fields = target.fields = {};
@@ -85,8 +89,13 @@ export async function extractComplexTypeSchema(target, ctor, metadata) {
                 };
                 if (elemMeta.enum)
                     elemSchema.type = await this.importTypeClass(elemMeta.enum);
-                if (!elemSchema.type && elemMeta.designType)
-                    elemSchema.type = await this.importTypeClass(elemMeta.designType);
+                if (!elemSchema.type && elemMeta.designType) {
+                    const mappingType = this.document.getDataType(elemMeta.designType, true);
+                    if (mappingType)
+                        elemSchema.type = mappingType.name;
+                    else
+                        elemSchema.type = await this.importTypeClass(elemMeta.designType);
+                }
                 await this.extractFieldSchema(elemSchema, ctor, elemMeta, elemName);
                 // Check enum again. External packages may modify enum value
                 if (elemMeta.enum)