@opra/common 0.33.13 → 1.0.0-alpha.1

package/esm/document/common/document-node.js

@@ -0,0 +1,120 @@
+import { OpraSchema } from '../../schema/index.js';
+import { DATATYPE_METADATA, kDataTypeMap, kTypeNSMap } from '../constants.js';
+/**
+ * @class DocumentNode
+ */
+export class DocumentNode {
+    constructor(element, parent) {
+        this.element = element;
+        this.parent = parent;
+    }
+    getDocument() {
+        if (this._document)
+            return this._document;
+        if (this.element[kTypeNSMap])
+            return this.element;
+        if (this.parent)
+            return (this._document = this.parent.getDocument());
+        // istanbul ignore next
+        throw new Error('ApiDocument not found in document tree');
+    }
+    hasDataType(nameOrCtor) {
+        const result = this[kDataTypeMap]?.has(nameOrCtor);
+        if (result)
+            return result;
+        return this.parent ? this.parent.hasDataType(nameOrCtor) : false;
+    }
+    findDataType(nameOrCtor) {
+        const result = this[kDataTypeMap]?.get(nameOrCtor);
+        if (result)
+            return result;
+        return this.parent ? this.parent.findDataType(nameOrCtor) : undefined;
+    }
+    /**
+     * Returns DataType instance by name or Constructor. Returns undefined if not found
+     * @param nameOrCtor
+     */
+    getDataType(nameOrCtor) {
+        const dt = this.findDataType(nameOrCtor);
+        if (dt)
+            return dt;
+        let name = '';
+        if (typeof nameOrCtor === 'function') {
+            const metadata = Reflect.getMetadata(DATATYPE_METADATA, nameOrCtor);
+            name = metadata.name;
+        }
+        else if (typeof nameOrCtor === 'object') {
+            const metadata = nameOrCtor[DATATYPE_METADATA];
+            name = metadata?.name;
+        }
+        if (typeof nameOrCtor === 'string')
+            name = nameOrCtor;
+        throw new TypeError(`Unknown data type` + (name ? ' (' + name + ')' : ''));
+    }
+    getDataTypeNameWithNs(dataType) {
+        if (!dataType.name)
+            return;
+        const ns = this.getDocument().getDataTypeNs(dataType);
+        return ns ? ns + ':' + dataType.name : dataType.name;
+    }
+    /**
+     * Returns ComplexType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a ComplexType
+     * @param nameOrCtor
+     */
+    getComplexType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.ComplexType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name}" is not a ComplexType`);
+    }
+    /**
+     * Returns SimpleType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a SimpleType
+     * @param nameOrCtor
+     */
+    getSimpleType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.SimpleType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a SimpleType`);
+    }
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a EnumType
+     * @param nameOrCtor
+     */
+    getEnumType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.EnumType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a EnumType`);
+    }
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a MappedType
+     * @param nameOrCtor
+     */
+    getMappedType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.MappedType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a MappedType`);
+    }
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a MixinType
+     * @param nameOrCtor
+     */
+    getMixinType(nameOrCtor) {
+        const t = this.getDataType(nameOrCtor);
+        if (t.kind === OpraSchema.MixinType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a MixinType`);
+    }
+}

package/esm/document/common/opra-document-error.js

@@ -0,0 +1,11 @@
+import { OpraException } from '../../exception/opra-exception.js';
+export class OpraDocumentError extends OpraException {
+    constructor() {
+        super('');
+        this.details = [];
+    }
+    add(detail) {
+        this.details.push(detail);
+        return this;
+    }
+}

package/esm/document/common/value.js

@@ -0,0 +1,30 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from './document-element.js';
+export const Value = function (owner, initArgs) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    DocumentElement.call(this, owner);
+    // if (args.name && !PARAMETER_NAME_PATTERN.test(args.name))
+    //   throw new TypeError(`"${args.name}" is not a valid parameter name`);
+    const _this = asMutable(this);
+    _this.description = initArgs.description;
+    _this.type = initArgs.type;
+    _this.examples = initArgs.examples;
+    _this.isArray = initArgs.isArray;
+};
+/**
+ * @class Value
+ */
+class ValueClass extends DocumentElement {
+    toJSON() {
+        const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : undefined;
+        return omitUndefined({
+            type: this.type ? (typeName ? typeName : this.type.toJSON()) : 'any',
+            description: this.description,
+            isArray: this.isArray,
+            examples: this.examples,
+        });
+    }
+}
+Value.prototype = ValueClass.prototype;

package/esm/document/constants.js

@@ -1,6 +1,12 @@
-export const DATATYPE_METADATA = Symbol('DATATYPE_METADATA');
-export const RESOURCE_METADATA = Symbol('RESOURCE_METADATA');
-export const DECORATOR = Symbol('DECORATOR');
-export const NAMESPACE_PATTERN = /([a-z$_]\w+)(?::.+)?/i;
-export const TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
-export const SORT_FIELD_PATTERN = /^([+-])?([a-z$_][\w.]+)$/;
+export const DATATYPE_METADATA = Symbol.for('opra.type.metadata');
+export const HTTP_CONTROLLER_METADATA = Symbol('opra.http-controller.metadata');
+export const DECODER = Symbol.for('opra.type.decoder');
+export const ENCODER = Symbol('opra.type.encoder');
+export const DECORATOR = Symbol.for('DECORATOR');
+export const BUILTIN = Symbol.for('BUILTIN');
+export const NAMESPACE_PATTERN = /([a-z$_]\w+)(:.+)/i;
+export const CLASS_NAME_PATTERN = /^[a-z][\w_]*$/i;
+export const EXTRACT_TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
+export const kDataTypeMap = Symbol.for('kDataTypeMap');
+export const kCtorMap = Symbol.for('kCtorMap');
+export const kTypeNSMap = Symbol.for('kTypeNSMap');

package/esm/document/data-type/api-field.js

@@ -0,0 +1,61 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DECORATOR } from '../constants.js';
+import { ApiFieldDecorator } from '../decorators/api-field-decorator.js';
+import { ComplexTypeBase } from './complex-type-base.js';
+/**
+ * @constructor ApiField
+ * @decorator ApiField
+ */
+export const ApiField = function (...args) {
+    // Decorator
+    if (!this) {
+        const [options] = args;
+        return ApiField[DECORATOR](options);
+    }
+    // Constructor
+    const [owner, initArgs] = args;
+    DocumentElement.call(this, owner);
+    const _this = asMutable(this);
+    _this.name = initArgs.name;
+    const origin = initArgs.origin || owner;
+    /* istanbul ignore next */
+    if (!(origin instanceof ComplexTypeBase))
+        throw new Error('Field origin should be one of ComplexType, MappedType or MixinType');
+    _this.origin = origin;
+    _this.type = initArgs.type || owner.node.getDataType('any');
+    _this.description = initArgs.description;
+    _this.isArray = initArgs.isArray;
+    _this.default = initArgs.default;
+    _this.fixed = initArgs.fixed;
+    _this.required = initArgs.required;
+    _this.exclusive = initArgs.exclusive;
+    _this.translatable = initArgs.translatable;
+    _this.deprecated = initArgs.deprecated;
+    _this.examples = initArgs.examples;
+};
+/**
+ *
+ * @class ApiField
+ */
+class ApiFieldClass extends DocumentElement {
+    toJSON() {
+        const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : undefined;
+        return omitUndefined({
+            type: this.type ? (typeName ? typeName : this.type?.toJSON()) : undefined,
+            description: this.description,
+            isArray: this.isArray,
+            default: this.default,
+            fixed: this.fixed,
+            required: this.required,
+            exclusive: this.exclusive,
+            translatable: this.translatable,
+            deprecated: this.deprecated,
+            examples: this.examples,
+        });
+    }
+}
+ApiField.prototype = ApiFieldClass.prototype;
+Object.assign(ApiField, ApiFieldDecorator);
+ApiField[DECORATOR] = ApiFieldDecorator;

package/esm/document/data-type/complex-type-base.js

@@ -0,0 +1,180 @@
+import { asMutable } from 'ts-gems';
+import { validator, vg } from 'valgen';
+import { parseFieldsProjection, ResponsiveMap } from '../../helpers/index.js';
+import { translate } from '../../i18n/index.js';
+import { DataType } from './data-type.js';
+export const FIELD_PATH_PATTERN = /^([+-])?([a-z$_][\w.]*)$/i;
+/**
+ *
+ * @constructor
+ */
+export const ComplexTypeBase = function (...args) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    // Constructor
+    const [owner, initArgs, context] = args;
+    DataType.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.fields = new ResponsiveMap();
+};
+/**
+ *
+ */
+class ComplexTypeBaseClass extends DataType {
+    /**
+     *
+     */
+    findField(nameOrPath) {
+        if (nameOrPath.includes('.')) {
+            const fieldPath = this.parseFieldPath(nameOrPath);
+            const lastItem = fieldPath.pop();
+            return lastItem?.field;
+        }
+        return this.fields.get(nameOrPath);
+    }
+    /**
+     *
+     */
+    getField(nameOrPath) {
+        const field = this.findField(nameOrPath);
+        if (!field)
+            throw new Error(translate('error:UNKNOWN_FIELD', { field: nameOrPath }));
+        return field;
+    }
+    /**
+     *
+     */
+    parseFieldPath(fieldPath, options) {
+        let dataType = this;
+        let field;
+        const arr = fieldPath.split('.');
+        const len = arr.length;
+        const out = [];
+        const objectType = this.owner.node.getDataType('object');
+        const allowSigns = options?.allowSigns;
+        const getStrPath = () => out.map(x => x.fieldName).join('.');
+        for (let i = 0; i < len; i++) {
+            const item = {
+                fieldName: arr[i],
+                dataType: objectType,
+            };
+            out.push(item);
+            const m = FIELD_PATH_PATTERN.exec(arr[i]);
+            if (!m)
+                throw new TypeError(`Invalid field name (${getStrPath()})`);
+            if (m[1]) {
+                if ((i === 0 && allowSigns === 'first') || allowSigns === 'each')
+                    item.sign = m[1];
+                item.fieldName = m[2];
+            }
+            if (dataType) {
+                if (dataType instanceof ComplexTypeBase) {
+                    field = dataType.fields.get(item.fieldName);
+                    if (field) {
+                        item.fieldName = field.name;
+                        item.field = field;
+                        item.dataType = field.type;
+                        dataType = field.type;
+                        continue;
+                    }
+                    if (dataType.additionalFields?.[0] === true) {
+                        item.additionalField = true;
+                        item.dataType = objectType;
+                        dataType = undefined;
+                        continue;
+                    }
+                    if (dataType.additionalFields?.[0] === 'type' && dataType.additionalFields?.[1] instanceof DataType) {
+                        item.additionalField = true;
+                        item.dataType = dataType.additionalFields[1];
+                        dataType = dataType.additionalFields[1];
+                        continue;
+                    }
+                    throw new Error(`Unknown field (${out.map(x => x.fieldName).join('.')})`);
+                }
+                throw new TypeError(`"${out.map(x => x.fieldName).join('.')}" field is not a complex type and has no child fields`);
+            }
+            item.additionalField = true;
+            item.dataType = objectType;
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    normalizeFieldPath(fieldPath, options) {
+        return this.parseFieldPath(fieldPath, options)
+            .map(x => (x.sign || '') + x.fieldName)
+            .join('.');
+    }
+    /**
+     *
+     */
+    generateCodec(codec, options) {
+        const projection = Array.isArray(options?.projection)
+            ? parseFieldsProjection(options.projection)
+            : options?.projection;
+        const schema = this._generateSchema(codec, { ...options, projection, currentPath: '' });
+        let additionalFields;
+        if (this.additionalFields instanceof DataType)
+            additionalFields = this.additionalFields.generateCodec(codec, options);
+        else if (typeof this.additionalFields === 'boolean')
+            additionalFields = this.additionalFields;
+        else if (Array.isArray(this.additionalFields)) {
+            if (this.additionalFields.length < 2)
+                additionalFields = 'error';
+            else {
+                const message = additionalFields[1];
+                additionalFields = validator((input, context, _this) => context.fail(_this, message, input));
+            }
+        }
+        return vg.isObject(schema, {
+            ctor: this.ctor,
+            additionalFields,
+            name: this.name,
+            coerce: true,
+            caseInSensitive: options?.caseInSensitive,
+            onFail: options?.onFail,
+        });
+    }
+    _generateSchema(codec, context) {
+        const schema = {};
+        const { currentPath, projection } = context;
+        const pickList = !!(projection && Object.values(projection).find(p => !p.sign));
+        // Process fields
+        let fieldName;
+        for (const field of this.fields.values()) {
+            fieldName = field.name;
+            let p;
+            if (projection !== '*') {
+                p = projection?.[fieldName.toLowerCase()];
+                if (
+                /** Ignore if field is omitted */
+                p?.sign === '-' ||
+                    /** Ignore if default fields ignored and field is not in projection */
+                    (pickList && !p) ||
+                    /** Ignore if default fields enabled and fields is exclusive */
+                    (!pickList && field.exclusive && !p)) {
+                    schema[field.name] = vg.isUndefined({ coerce: true });
+                    continue;
+                }
+            }
+            const fn = this._generateFieldCodec(codec, field, {
+                ...context,
+                partial: context.partial === 'deep' ? context.partial : undefined,
+                projection: projection !== '*' ? projection : p?.projection,
+                currentPath: currentPath + (currentPath ? '.' : '') + fieldName,
+            });
+            schema[fieldName] = context.partial || !field.required ? vg.optional(fn) : vg.required(fn);
+        }
+        return schema;
+    }
+    _generateFieldCodec(codec, field, context) {
+        let fn = field.type.generateCodec(codec, context);
+        if (field.fixed)
+            fn = vg.isEnum([field.fixed]);
+        if (field.isArray)
+            fn = vg.isArray(fn);
+        return fn;
+    }
+}
+ComplexTypeBase.prototype = ComplexTypeBaseClass.prototype;

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

@@ -1,22 +1,99 @@
 import 'reflect-metadata';
-import merge from 'putil-merge';
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
 import { DECORATOR } from '../constants.js';
-import { ComplexTypeDecorator } from './complex-type.decorator.js';
-import { ComplexTypeClass } from './complex-type-class.js';
+import { ComplexTypeDecorator } from '../decorators/complex-type.decorator.js';
+import { ApiField } from './api-field.js';
+import { ComplexTypeBase } from './complex-type-base.js';
+import { DataType } from './data-type.js';
 /**
- * @class ComplexType
- * @decorator ComplexType
+ * ComplexType constructor
  */
 export const ComplexType = function (...args) {
     // Decorator
-    if (!this) {
-        const [options] = args;
-        return ComplexType[DECORATOR](options);
-    }
+    if (!this)
+        return ComplexType[DECORATOR].apply(undefined, args);
     // Constructor
-    const [document, init] = args;
-    merge(this, new ComplexTypeClass(document, init), { descriptor: true });
+    const [owner, initArgs] = args;
+    const context = args[2] || new DocumentInitContext({ maxErrors: 0 });
+    ComplexTypeBase.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.ComplexType.Kind;
+    _this.additionalFields = initArgs.additionalFields;
+    _this.keyField = initArgs.keyField;
+    if (initArgs.base) {
+        context.enter('.base', () => {
+            // noinspection SuspiciousTypeOfGuard
+            if (!(initArgs.base instanceof ComplexTypeBase))
+                throw new TypeError(`"${initArgs.base.kind}" can't be set as base for a "${this.kind}"`);
+            _this.base = initArgs.base;
+            if (_this.additionalFields == null && _this.base.additionalFields)
+                _this.additionalFields = _this.base.additionalFields;
+            /** Copy fields from base */
+            for (const v of _this.base.fields.values()) {
+                this.fields.set(v.name, new ApiField(this, v));
+            }
+        });
+    }
+    _this.ctor = initArgs.ctor || _this.base?.ctor;
+    /** Add own fields */
+    if (initArgs.fields) {
+        context.enter('.fields', () => {
+            for (const [k, v] of Object.entries(initArgs.fields)) {
+                const field = new ApiField(this, {
+                    ...v,
+                    name: k,
+                });
+                this.fields.set(field.name, field);
+            }
+        });
+    }
 };
+/**
+ *
+ * @class ComplexType
+ */
+class ComplexTypeClass extends ComplexTypeBase {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof ComplexTypeBase))
+            return false;
+        if (baseType === this)
+            return true;
+        return !!this.base?.extendsFrom(baseType);
+    }
+    toJSON() {
+        const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
+        const out = omitUndefined({
+            ...ComplexTypeBase.prototype.toJSON.call(this),
+            kind: this.kind,
+            base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
+        });
+        if (this.additionalFields) {
+            if (this.additionalFields instanceof DataType) {
+                out.additionalFields = this.additionalFields[1].name
+                    ? this.additionalFields[1].name
+                    : this.additionalFields[1].toJSON();
+            }
+            else
+                out.additionalFields = this.additionalFields;
+        }
+        if (this.fields.size) {
+            const fields = {};
+            let i = 0;
+            for (const field of this.fields.values()) {
+                if (field.origin === this) {
+                    fields[field.name] = field.toJSON();
+                    i++;
+                }
+            }
+            if (i)
+                out.fields = fields;
+        }
+        return omitUndefined(out);
+    }
+}
 ComplexType.prototype = ComplexTypeClass.prototype;
 Object.assign(ComplexType, ComplexTypeDecorator);
 ComplexType[DECORATOR] = ComplexTypeDecorator;

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

@@ -1,40 +1,48 @@
+import { asMutable } from 'ts-gems';
 import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { CLASS_NAME_PATTERN } from '../constants.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
 /**
+ * DataType constructor
+ */
+export const DataType = function (owner, initArgs, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+context) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    if (initArgs?.name && !CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`"${initArgs.name}" is not a valid DataType name`);
+    DocumentElement.call(this, owner);
+    const _this = asMutable(this);
+    _this.kind = initArgs.kind;
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.abstract = initArgs.abstract;
+    _this.examples = initArgs.examples;
+};
+/**
+ *
  * @class DataType
- * @abstract
  */
-export class DataType {
-    constructor(document, init) {
-        this.document = document;
-        this.name = init?.name;
-        this.own = {};
-        this.description = init?.description;
-        if (!this.name)
-            this.isEmbedded = true;
+class DataTypeClass extends DocumentElement {
+    get embedded() {
+        return !this.name;
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    exportSchema(options) {
+    toJSON() {
         return omitUndefined({
             kind: this.kind,
-            description: this.description
+            description: this.description,
+            abstract: this.abstract,
+            examples: this.examples,
         });
     }
-    extendsFrom(type) {
-        const dataType = type instanceof DataType ? type : this.document.getDataType(type);
-        let t = this;
-        while (t) {
-            if (t === dataType)
-                return true;
-            t = t.base;
-        }
-        return false;
-    }
     toString() {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || '#Embedded'}]`;
     }
     [nodeInspectCustom]() {
-        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
-            ` ${colorFgMagenta + this.name + colorReset}]`;
+        return (`[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
+            ` ${colorFgMagenta + this.name + colorReset}]`);
     }
 }
+DataType.prototype = DataTypeClass.prototype;

package/esm/document/data-type/decorators/api-field-decorator.js

@@ -0,0 +1,22 @@
+import { omitUndefined } from '../../../helpers/index.js';
+import { OpraSchema } from '../../../schema/index.js';
+import { DATATYPE_METADATA } from '../../constants.js';
+export function ApiFieldDecorator(options) {
+    return function (target, propertyKey) {
+        if (typeof propertyKey !== 'string')
+            throw new TypeError(`Symbol properties can't be used as a field`);
+        const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
+        metadata.kind = OpraSchema.ComplexType.Kind;
+        metadata.fields = metadata.fields || {};
+        const designType = Reflect.getMetadata('design:type', target, propertyKey);
+        const elemMeta = (metadata.fields[propertyKey] = {
+            ...options,
+        });
+        if (designType === Array) {
+            elemMeta.isArray = true;
+        }
+        else
+            elemMeta.type = elemMeta.type || designType;
+        Reflect.defineMetadata(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
+    };
+}

package/esm/document/data-type/decorators/complex-type.decorator.js

@@ -0,0 +1,28 @@
+import omit from 'lodash.omit';
+import { OpraSchema } from '../../../schema/index.js';
+import { CLASS_NAME_PATTERN, DATATYPE_METADATA, EXTRACT_TYPENAME_PATTERN } from '../../constants.js';
+export function ComplexTypeDecorator(options) {
+    return function (target) {
+        let name;
+        if (!options?.embedded) {
+            if (options?.name) {
+                if (!CLASS_NAME_PATTERN.test(options.name))
+                    throw new TypeError(`"${options.name}" is not a valid type name`);
+                name = options.name;
+            }
+            else {
+                name = target.name.match(EXTRACT_TYPENAME_PATTERN)?.[1] || target.name;
+            }
+        }
+        let metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target);
+        if (!metadata) {
+            metadata = {};
+            Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
+        }
+        metadata.kind = OpraSchema.ComplexType.Kind;
+        metadata.name = name;
+        // Merge options
+        if (options)
+            Object.assign(metadata, omit(options, ['kind', 'name', 'base', 'fields']));
+    };
+}