@opra/common 0.4.0 → 0.6.0

package/esm/schema/implementation/query/collection-update-many-query.js

@@ -0,0 +1,17 @@
+import { parseFilter } from '../../../filter/index.js';
+export class CollectionUpdateManyQuery {
+    resource;
+    data;
+    kind = 'CollectionUpdateManyQuery';
+    method = 'updateMany';
+    operation = 'update';
+    filter;
+    constructor(resource, data, options) {
+        this.resource = resource;
+        this.data = data;
+        this.filter = typeof options?.filter === 'string' ? parseFilter(options.filter) : options?.filter;
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+}

package/esm/schema/implementation/query/collection-update-query.d.ts

@@ -0,0 +1,19 @@
+import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+export declare type CollectionUpdateQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+};
+export declare class CollectionUpdateQuery {
+    readonly resource: CollectionResourceInfo;
+    data: any;
+    readonly kind = "CollectionUpdateQuery";
+    readonly method = "update";
+    readonly operation = "update";
+    keyValue: any;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    constructor(resource: CollectionResourceInfo, keyValue: any, data: any, options?: CollectionUpdateQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/esm/schema/implementation/query/collection-update-query.js

@@ -0,0 +1,35 @@
+import { normalizeFieldArray } from '../../utils/normalize-field-array.util.js';
+export class CollectionUpdateQuery {
+    resource;
+    data;
+    kind = 'CollectionUpdateQuery';
+    method = 'update';
+    operation = 'update';
+    keyValue;
+    pick;
+    omit;
+    include;
+    constructor(resource, keyValue, data, options) {
+        this.resource = resource;
+        this.data = data;
+        if (resource.keyFields.length > 1) {
+            if (typeof keyValue !== 'object')
+                throw new Error(`You must provide an key/value object for all key fields (${resource.keyFields})`);
+            resource.keyFields.reduce((o, k) => {
+                o[k] = keyValue[k];
+                return o;
+            }, {});
+        }
+        else
+            this.keyValue = resource.dataType.getFieldType(resource.keyFields[0]).parse(keyValue);
+        if (options?.pick)
+            this.pick = normalizeFieldArray(resource.document, resource.dataType, options.pick);
+        if (options?.omit)
+            this.omit = normalizeFieldArray(resource.document, resource.dataType, options.omit);
+        if (options?.include)
+            this.include = normalizeFieldArray(resource.document, resource.dataType, options.include);
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+}

package/esm/schema/implementation/query/field-get-query.d.ts

@@ -0,0 +1,30 @@
+import type { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import { ComplexType, Field } from '../data-type/complex-type.js';
+import type { DataType } from '../data-type/data-type.js';
+import type { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+import type { SingletonResourceInfo } from '../resource/singleton-resource-info.js';
+import type { CollectionGetQuery } from './collection-get-query.js';
+import type { SingletonGetQuery } from './singleton-get-query.js';
+export declare type FieldGetQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    castingType?: ComplexType;
+};
+export declare class FieldGetQuery implements IChildFieldQuery {
+    readonly parent: CollectionGetQuery | SingletonGetQuery | FieldGetQuery;
+    readonly resource: CollectionResourceInfo | SingletonResourceInfo;
+    readonly kind = "FieldGetQuery";
+    readonly method = "get";
+    readonly operation = "read";
+    readonly fieldName: string;
+    readonly field?: Field;
+    readonly path: string;
+    readonly dataType: DataType;
+    readonly parentType: ComplexType;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    child?: FieldGetQuery;
+    constructor(parent: CollectionGetQuery | SingletonGetQuery | FieldGetQuery, fieldName: string, options?: FieldGetQueryOptions);
+}

package/esm/schema/implementation/query/field-get-query.js

@@ -0,0 +1,41 @@
+import { normalizeFieldArray } from '../../utils/normalize-field-array.util.js';
+import { ComplexType } from '../data-type/complex-type.js';
+export class FieldGetQuery {
+    parent;
+    resource;
+    kind = 'FieldGetQuery';
+    method = 'get';
+    operation = 'read';
+    fieldName;
+    field;
+    path;
+    dataType;
+    parentType;
+    pick;
+    omit;
+    include;
+    child;
+    constructor(parent, fieldName, options) {
+        this.parent = parent;
+        this.resource = parent.resource;
+        const parentType = options?.castingType || parent.dataType;
+        if (!parentType || !(parentType instanceof ComplexType))
+            throw new TypeError(`Data type of parent query is not a ComplexType`);
+        this.parentType = parentType;
+        this.field = parentType.additionalFields
+            ? parentType.fields.get(fieldName)
+            : parentType.getField(fieldName);
+        this.fieldName = this.field ? this.field.name : fieldName;
+        this.dataType = this.resource.document.getDataType(this.field ? (this.field.type || 'string') : 'object');
+        this.path = (parent instanceof FieldGetQuery
+            ? parent.path + '.' : '') + this.fieldName;
+        if (this.dataType instanceof ComplexType) {
+            if (options?.pick)
+                this.pick = normalizeFieldArray(this.resource.document, this.dataType, options.pick, this.path);
+            if (options?.omit)
+                this.omit = normalizeFieldArray(this.resource.document, this.dataType, options.omit, this.path);
+            if (options?.include)
+                this.include = normalizeFieldArray(this.resource.document, this.dataType, options.include, this.path);
+        }
+    }
+}

package/esm/schema/implementation/query/index.d.ts

@@ -0,0 +1,27 @@
+import { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import { CollectionCountQuery } from './collection-count-query.js';
+import { CollectionCreateQuery } from './collection-create-query.js';
+import { CollectionDeleteManyQuery } from './collection-delete-many-query.js';
+import { CollectionDeleteQuery } from './collection-delete-query.js';
+import { CollectionGetQuery } from './collection-get-query.js';
+import { CollectionSearchQuery } from './collection-search-query.js';
+import { CollectionUpdateManyQuery } from './collection-update-many-query.js';
+import { CollectionUpdateQuery } from './collection-update-query.js';
+import { FieldGetQuery } from './field-get-query.js';
+import { SingletonGetQuery } from './singleton-get-query.js';
+export * from './collection-create-query.js';
+export * from './collection-count-query.js';
+export * from './collection-delete-many-query.js';
+export * from './collection-delete-query.js';
+export * from './collection-delete-many-query.js';
+export * from './collection-get-query.js';
+export * from './field-get-query.js';
+export * from './singleton-get-query.js';
+export * from './collection-search-query.js';
+export * from './collection-update-many-query.js';
+export * from './collection-update-query.js';
+export declare type CollectionQuery = CollectionCountQuery | CollectionCreateQuery | CollectionDeleteManyQuery | CollectionDeleteQuery | CollectionGetQuery | CollectionSearchQuery | CollectionUpdateManyQuery | CollectionUpdateQuery;
+export declare type FieldQuery = FieldGetQuery;
+export declare type SingletonQuery = SingletonGetQuery;
+export declare type OpraQuery = CollectionQuery | SingletonQuery | FieldQuery;
+export declare function isChildFieldQuery(query: any): query is IChildFieldQuery;

package/esm/schema/implementation/query/index.js

@@ -0,0 +1,17 @@
+export * from './collection-create-query.js';
+export * from './collection-count-query.js';
+export * from './collection-delete-many-query.js';
+export * from './collection-delete-query.js';
+export * from './collection-delete-many-query.js';
+export * from './collection-get-query.js';
+export * from './field-get-query.js';
+export * from './singleton-get-query.js';
+export * from './collection-search-query.js';
+export * from './collection-update-many-query.js';
+export * from './collection-update-query.js';
+export function isChildFieldQuery(query) {
+    return query &&
+        (query.kind === 'SingletonGetQuery' ||
+            query.kind === 'CollectionGetQuery' ||
+            query.kind === 'FieldGetQuery');
+}

package/esm/schema/implementation/query/singleton-get-query.d.ts

@@ -0,0 +1,20 @@
+import type { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import type { SingletonResourceInfo } from '../resource/singleton-resource-info.js';
+import type { FieldGetQuery } from './field-get-query.js';
+export declare type SingletonGetQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+};
+export declare class SingletonGetQuery implements IChildFieldQuery {
+    readonly resource: SingletonResourceInfo;
+    readonly kind = "SingletonGetQuery";
+    readonly method = "get";
+    readonly operation = "read";
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    child?: FieldGetQuery;
+    constructor(resource: SingletonResourceInfo, options?: SingletonGetQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/esm/schema/implementation/query/singleton-get-query.js

@@ -0,0 +1,23 @@
+import { normalizeFieldArray } from '../../utils/normalize-field-array.util.js';
+export class SingletonGetQuery {
+    resource;
+    kind = 'SingletonGetQuery';
+    method = 'get';
+    operation = 'read';
+    pick;
+    omit;
+    include;
+    child;
+    constructor(resource, options) {
+        this.resource = resource;
+        if (options?.pick)
+            this.pick = normalizeFieldArray(resource.document, resource.dataType, options.pick);
+        if (options?.omit)
+            this.omit = normalizeFieldArray(resource.document, resource.dataType, options.omit);
+        if (options?.include)
+            this.include = normalizeFieldArray(resource.document, resource.dataType, options.include);
+    }
+    get dataType() {
+        return this.resource.dataType;
+    }
+}

package/esm/schema/implementation/resource/collection-resource-info.d.ts

@@ -0,0 +1,19 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import type { OpraDocument } from '../opra-document';
+import { ResourceInfo } from './resource-info.js';
+export declare class CollectionResourceInfo extends ResourceInfo {
+    readonly metadata: OpraSchema.CollectionResource;
+    readonly dataType: ComplexType;
+    constructor(document: OpraDocument, name: string, dataType: ComplexType, metadata: OpraSchema.CollectionResource);
+    get keyFields(): string[];
+    get create(): OpraSchema.CreateMethodResolver | undefined;
+    get count(): OpraSchema.MethodResolver | undefined;
+    get delete(): OpraSchema.MethodResolver | undefined;
+    get deleteMany(): OpraSchema.DeleteManyMethodResolver | undefined;
+    get get(): OpraSchema.GetMethodResolver | undefined;
+    get update(): OpraSchema.UpdateMethodResolver | undefined;
+    get updateMany(): OpraSchema.UpdateManyMethodResolver | undefined;
+    get search(): OpraSchema.SearchMethodResolver | undefined;
+    getSchema(jsonOnly?: boolean): OpraSchema.CollectionResource;
+}

package/esm/schema/implementation/resource/collection-resource-info.js

@@ -0,0 +1,54 @@
+import { collectionMethods } from '../../constants.js';
+import { normalizeFieldArray } from '../../utils/normalize-field-array.util.js';
+import { ResourceInfo } from './resource-info.js';
+export class CollectionResourceInfo extends ResourceInfo {
+    dataType;
+    constructor(document, name, dataType, metadata) {
+        if (!metadata.keyFields)
+            throw new TypeError(`You should provide key fields for ${name}`);
+        super(document, name, metadata);
+        metadata.keyFields = Array.isArray(metadata.keyFields) ? metadata.keyFields : [metadata.keyFields];
+        metadata.keyFields.forEach(f => dataType.getField(f));
+        this.dataType = dataType;
+        if (metadata.search && metadata.search.sortFields) {
+            metadata.search.sortFields = normalizeFieldArray(document, dataType, metadata.search.sortFields);
+        }
+    }
+    get keyFields() {
+        return this.metadata.keyFields;
+    }
+    get create() {
+        return this.metadata.create;
+    }
+    get count() {
+        return this.metadata.count;
+    }
+    get delete() {
+        return this.metadata.delete;
+    }
+    get deleteMany() {
+        return this.metadata.deleteMany;
+    }
+    get get() {
+        return this.metadata.get;
+    }
+    get update() {
+        return this.metadata.update;
+    }
+    get updateMany() {
+        return this.metadata.updateMany;
+    }
+    get search() {
+        return this.metadata.search;
+    }
+    getSchema(jsonOnly) {
+        const out = super.getSchema(jsonOnly);
+        if (out.keyFields.length < 2)
+            out.keyFields = out.keyFields[0];
+        for (const k of collectionMethods) {
+            if (typeof out[k] === 'object' && !Object.keys(out[k]).length)
+                out[k] = true;
+        }
+        return out;
+    }
+}

package/esm/schema/implementation/resource/container-resource-info.d.ts

@@ -0,0 +1,13 @@
+import { IResourceContainer } from '../../interfaces/resource-container.interface.js';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import type { OpraDocument } from '../opra-document.js';
+import { CollectionResourceInfo } from './collection-resource-info.js';
+import { ResourceInfo } from './resource-info.js';
+import { SingletonResourceInfo } from './singleton-resource-info.js';
+export declare class ContainerResourceInfo extends ResourceInfo implements IResourceContainer {
+    readonly metadata: OpraSchema.ContainerResource;
+    constructor(service: OpraDocument, name: string, metadata: OpraSchema.ContainerResource);
+    getResource<T extends ResourceInfo>(name: string): T;
+    getCollectionResource(name: string): CollectionResourceInfo;
+    getSingletonResource(name: string): SingletonResourceInfo;
+}

package/esm/schema/implementation/resource/container-resource-info.js

@@ -0,0 +1,26 @@
+import { CollectionResourceInfo } from './collection-resource-info.js';
+import { ResourceInfo } from './resource-info.js';
+import { SingletonResourceInfo } from './singleton-resource-info.js';
+export class ContainerResourceInfo extends ResourceInfo {
+    constructor(service, name, metadata) {
+        super(service, name, metadata);
+    }
+    getResource(name) {
+        const t = this.metadata.resources[name];
+        if (!t)
+            throw new Error(`Resource "${name}" does not exists`);
+        return t;
+    }
+    getCollectionResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof CollectionResourceInfo))
+            throw new Error(`"${name}" is not a Collection Resource`);
+        return t;
+    }
+    getSingletonResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof SingletonResourceInfo))
+            throw new Error(`"${name}" is not a SingletonResource`);
+        return t;
+    }
+}

package/esm/schema/implementation/resource/resource-info.d.ts

@@ -0,0 +1,17 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { nodeInspectCustom } from '../../utils/inspect.util.js';
+import type { OpraDocument } from '../opra-document.js';
+export declare abstract class ResourceInfo {
+    readonly metadata: OpraSchema.Resource;
+    readonly document: OpraDocument;
+    readonly name: string;
+    protected path: string;
+    protected constructor(document: OpraDocument, name: string, metadata: OpraSchema.Resource);
+    get instance(): {} | undefined;
+    get kind(): OpraSchema.ResourceKind;
+    get description(): string | undefined;
+    toString(): string;
+    validateQueryOptions(): any;
+    getSchema(jsonOnly?: boolean): OpraSchema.Resource;
+    [nodeInspectCustom](): string;
+}

package/esm/schema/implementation/resource/resource-info.js

@@ -0,0 +1,35 @@
+import { cloneObject } from '../../utils/clone-object.util.js';
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/inspect.util.js';
+export class ResourceInfo {
+    metadata;
+    document;
+    name;
+    path;
+    constructor(document, name, metadata) {
+        this.document = document;
+        this.name = name;
+        this.metadata = metadata;
+    }
+    get instance() {
+        return this.metadata.instance;
+    }
+    get kind() {
+        return this.metadata.kind;
+    }
+    get description() {
+        return this.metadata.description;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    validateQueryOptions() {
+        //
+    }
+    getSchema(jsonOnly) {
+        return cloneObject(this.metadata, jsonOnly);
+    }
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
+            ` ${colorFgMagenta + this.name + colorReset}]`;
+    }
+}

package/esm/schema/implementation/resource/singleton-resource-info.d.ts

@@ -0,0 +1,14 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import type { OpraDocument } from '../opra-document.js';
+import { ResourceInfo } from './resource-info.js';
+export declare class SingletonResourceInfo extends ResourceInfo {
+    readonly metadata: OpraSchema.SingletonResource;
+    readonly dataType: ComplexType;
+    constructor(document: OpraDocument, name: string, dataType: ComplexType, metadata: OpraSchema.SingletonResource);
+    get create(): OpraSchema.CreateMethodResolver | undefined;
+    get delete(): OpraSchema.MethodResolver | undefined;
+    get get(): OpraSchema.GetMethodResolver | undefined;
+    get update(): OpraSchema.UpdateMethodResolver | undefined;
+    getSchema(jsonOnly?: boolean): OpraSchema.SingletonResource;
+}

package/esm/schema/implementation/resource/singleton-resource-info.js

@@ -0,0 +1,33 @@
+import { singletonMethods } from '../../constants.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import { ResourceInfo } from './resource-info.js';
+export class SingletonResourceInfo extends ResourceInfo {
+    dataType;
+    constructor(document, name, dataType, metadata) {
+        // noinspection SuspiciousTypeOfGuard
+        if (!(dataType instanceof ComplexType))
+            throw new TypeError(`You should provide a ComplexType as "dataType" argument`);
+        super(document, name, metadata);
+        this.dataType = dataType;
+    }
+    get create() {
+        return this.metadata.create;
+    }
+    get delete() {
+        return this.metadata.delete;
+    }
+    get get() {
+        return this.metadata.get;
+    }
+    get update() {
+        return this.metadata.update;
+    }
+    getSchema(jsonOnly) {
+        const out = super.getSchema(jsonOnly);
+        for (const k of singletonMethods) {
+            if (typeof out[k] === 'object' && !Object.keys(out[k]).length)
+                out[k] = true;
+        }
+        return out;
+    }
+}

package/esm/schema/implementation/schema-builder/extract-resource-metadata.util.d.ts

@@ -0,0 +1,3 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { Named } from '../../types.js';
+export declare function extractResourceSchema(instance: object): Promise<Named<OpraSchema.Resource>>;

package/esm/schema/implementation/schema-builder/extract-resource-metadata.util.js

@@ -0,0 +1,80 @@
+import { collectionMethods, IGNORE_RESOLVER_METHOD, RESOLVER_METADATA, RESOURCE_METADATA, singletonMethods } from '../../constants.js';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { cloneObject } from '../../utils/clone-object.util.js';
+export async function extractResourceSchema(instance) {
+    const proto = Object.getPrototypeOf(instance);
+    const ctor = proto.constructor;
+    const metadata = Reflect.getMetadata(RESOURCE_METADATA, ctor);
+    if (!metadata)
+        throw new TypeError(`Class "${ctor.name}" doesn't have "Resource" metadata information`);
+    const schema = cloneObject(metadata);
+    schema.instance = instance;
+    schema.name = metadata.name || ctor.name.replace(/(Resource|Controller)$/, '');
+    if (OpraSchema.isCollectionResource(metadata))
+        return await processCollectionResource(schema);
+    if (OpraSchema.isSingletonResource(metadata))
+        return await processSingletonResource(schema);
+    throw new TypeError(`Invalid Resource metadata`);
+}
+async function processCollectionResource(schema) {
+    const instance = schema.instance;
+    const proto = Object.getPrototypeOf(schema.instance);
+    let methodMetadata;
+    let fn;
+    const locateFn = (inst, methodName) => {
+        fn = inst[methodName];
+        methodMetadata = Reflect.getMetadata(RESOLVER_METADATA, inst, methodName);
+        if (fn == null) {
+            if (methodMetadata) {
+                inst = Object.getPrototypeOf(inst);
+                fn = inst[methodName];
+            }
+        }
+    };
+    for (const methodName of collectionMethods) {
+        locateFn(instance, methodName);
+        if (typeof fn !== 'function')
+            continue;
+        const info = schema[methodName] = {
+            ...methodMetadata
+        };
+        if (!Reflect.hasMetadata(IGNORE_RESOLVER_METHOD, proto.constructor, methodName)) {
+            info.handler = fn.bind(instance);
+            fn = instance['pre_' + methodName];
+            if (typeof fn === 'function')
+                schema['pre_' + methodName] = fn.bind(instance);
+        }
+    }
+    return schema;
+}
+async function processSingletonResource(schema) {
+    const instance = schema.instance;
+    const proto = Object.getPrototypeOf(schema.instance);
+    let methodMetadata;
+    let fn;
+    const locateFn = (inst, methodName) => {
+        fn = inst[methodName];
+        methodMetadata = Reflect.getMetadata(RESOLVER_METADATA, inst, methodName);
+        if (fn == null) {
+            if (methodMetadata) {
+                inst = Object.getPrototypeOf(inst);
+                fn = inst[methodName];
+            }
+        }
+    };
+    for (const methodName of singletonMethods) {
+        locateFn(instance, methodName);
+        if (typeof fn !== 'function')
+            continue;
+        const info = schema[methodName] = {
+            ...methodMetadata
+        };
+        if (!Reflect.hasMetadata(IGNORE_RESOLVER_METHOD, proto.constructor, methodName)) {
+            info.handler = fn.bind(instance);
+            fn = instance['pre_' + methodName];
+            if (typeof fn === 'function')
+                schema['pre_' + methodName] = fn.bind(instance);
+        }
+    }
+    return schema;
+}

package/esm/schema/implementation/schema-builder/extract-type-metadata.util.d.ts

@@ -0,0 +1,4 @@
+import { Type } from 'ts-gems';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { Named } from '../../types.js';
+export declare function extractDataTypeSchema(ctor: Type | Function): Promise<Named<OpraSchema.DataType>>;

package/esm/schema/implementation/schema-builder/extract-type-metadata.util.js

@@ -0,0 +1,89 @@
+import * as Optionals from '@opra/optionals';
+import { COMPLEXTYPE_FIELDS, DATATYPE_METADATA, MAPPED_TYPE_METADATA } from '../../constants.js';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { cloneObject } from '../../utils/clone-object.util.js';
+import { primitiveClasses } from '../data-type/builtin-data-types.js';
+export async function extractDataTypeSchema(ctor) {
+    const metadata = Reflect.getMetadata(DATATYPE_METADATA, ctor);
+    if (!metadata)
+        throw new TypeError(`Class "${ctor}" doesn't have "DataType" metadata information`);
+    if (OpraSchema.isComplexType(metadata))
+        return await extractComplexTypeSchema(ctor, metadata);
+    if (OpraSchema.isSimpleType(metadata))
+        return await extractSimpleTypeSchema(ctor, metadata);
+    throw new TypeError(`Invalid DataType metadata`);
+}
+async function extractSimpleTypeSchema(ctor, metadata) {
+    const out = cloneObject(metadata);
+    out.ctor = ctor;
+    return out;
+}
+async function extractComplexTypeSchema(ctor, metadata) {
+    const out = cloneObject(metadata);
+    out.ctor = ctor;
+    const mappedTypeMetadata = Reflect.getMetadata(MAPPED_TYPE_METADATA, ctor);
+    if (mappedTypeMetadata) {
+        out.extends = [...mappedTypeMetadata.map(x => cloneObject(x))];
+    }
+    const fields = Reflect.getMetadata(COMPLEXTYPE_FIELDS, ctor);
+    if (fields) {
+        out.fields = cloneObject(fields);
+        for (const [fieldName, field] of Object.entries(out.fields)) {
+            if (typeof field.type === 'function') {
+                const type = primitiveClasses.get(field.type);
+                if (type)
+                    field.type = type;
+            }
+            let sqbField;
+            if (Optionals.SqbConnect) {
+                const { EntityMetadata, isAssociationField } = Optionals.SqbConnect;
+                const meta = EntityMetadata.get(ctor);
+                sqbField = meta && EntityMetadata.getField(meta, fieldName);
+                if (sqbField) {
+                    if (field.type === Function || field.type === 'object' ||
+                        field.type === Object || field.type === 'any') {
+                        field.type = 'any';
+                        if (isAssociationField(sqbField)) {
+                            if (!sqbField.association.returnsMany())
+                                delete field.isArray;
+                            const trg = await sqbField.association.resolveTarget();
+                            if (trg) {
+                                field.type = trg.ctor;
+                            }
+                        }
+                    }
+                    if (sqbField.exclusive && field.exclusive === undefined)
+                        field.exclusive = sqbField.exclusive;
+                }
+            }
+            if (sqbField && sqbField.kind === 'column') {
+                const DataType = Optionals.SqbConnect.DataType;
+                if (field.type === 'number' || field.type === Number) {
+                    switch (sqbField.dataType) {
+                        case DataType.INTEGER:
+                        case DataType.SMALLINT:
+                            field.type = 'integer';
+                            break;
+                        case DataType.BIGINT:
+                            field.type = 'bigint';
+                            break;
+                    }
+                }
+                else if (field.type === 'string' || field.type === String) {
+                    switch (sqbField.dataType) {
+                        case DataType.GUID:
+                            field.type = 'guid';
+                            break;
+                    }
+                }
+                if (sqbField.notNull && field.required === undefined)
+                    field.required = sqbField.notNull;
+                if (sqbField.exclusive && field.exclusive === undefined)
+                    field.exclusive = sqbField.exclusive;
+                if (sqbField.default !== undefined && field.default === undefined)
+                    field.default = sqbField.default;
+            }
+        }
+    }
+    return out;
+}