@opra/common 0.13.0 → 0.15.0

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

@@ -1,15 +0,0 @@
-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;
-    getHandlerNames(): string[];
-    getSchema(jsonOnly?: boolean): OpraSchema.SingletonResource;
-}

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

@@ -1,40 +0,0 @@
-import { singletonMethods } from '../../constants.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { ResourceInfo } from './resource-info.js';
-export class SingletonResourceInfo extends ResourceInfo {
-    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;
-    }
-    getHandlerNames() {
-        const out = [];
-        singletonMethods.forEach(m => {
-            if (this.metadata[m])
-                out.push(m);
-        });
-        return out;
-    }
-    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

@@ -1,3 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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';
-const optionalsSymbol = Symbol.for('opra.optional-lib.sqb-connect');
-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;
-            }
-            const SqbConnect = globalThis[optionalsSymbol]?.SqbConnect;
-            let sqbField;
-            if (SqbConnect) {
-                const { EntityMetadata, isAssociationField } = 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 = 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;
-}

package/esm/schema/interfaces/child-field-query.interface.d.ts

@@ -1,4 +0,0 @@
-import type { FieldGetQueryOptions } from '../implementation/query/index.js';
-export interface IChildFieldQuery {
-    child?: FieldGetQueryOptions;
-}

package/esm/schema/interfaces/data-type.metadata.d.ts

@@ -1,18 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../opra-schema.definition.js';
-import { TypeThunkAsync } from '../types.js';
-export type SimpleTypeMetadata = OpraSchema.SimpleType & {
-    name: string;
-};
-export type ComplexTypeMetadata = StrictOmit<OpraSchema.ComplexType, 'fields' | 'extends'> & {
-    name: string;
-    extends?: ComplexTypeExtendingMetadata[];
-    fields?: Record<string, FieldMetadata>;
-};
-export type FieldMetadata = StrictOmit<OpraSchema.Field, 'type'> & {
-    type?: string | TypeThunkAsync | (string | TypeThunkAsync)[];
-};
-type ComplexTypeExtendingMetadata = StrictOmit<OpraSchema.ComplexTypeExtendingInfo, 'type'> & {
-    type: string | Type;
-};
-export {};

package/esm/schema/interfaces/resource-container.interface.d.ts

@@ -1,8 +0,0 @@
-import { CollectionResourceInfo } from '../implementation/resource/collection-resource-info.js';
-import { ResourceInfo } from '../implementation/resource/resource-info.js';
-import { SingletonResourceInfo } from '../implementation/resource/singleton-resource-info.js';
-export interface IResourceContainer {
-    getResource<T extends ResourceInfo>(name: string): T;
-    getCollectionResource(name: string): CollectionResourceInfo;
-    getSingletonResource(name: string): SingletonResourceInfo;
-}

package/esm/schema/interfaces/resource.metadata.d.ts

@@ -1,18 +0,0 @@
-import { PartialSome, StrictOmit } from 'ts-gems';
-import { OpraSchema } from '../opra-schema.definition.js';
-import { TypeThunkAsync } from '../types.js';
-export type CollectionResourceMetadata = PartialSome<StrictOmit<OpraSchema.CollectionResource, 'type'>, 'keyFields'> & {
-    type: TypeThunkAsync | string;
-    name: string;
-};
-export type SingletonResourceMetadata = StrictOmit<OpraSchema.SingletonResource, 'type'> & {
-    type: TypeThunkAsync | string;
-    name: string;
-};
-export type ICreateResolverMetadata = StrictOmit<OpraSchema.CreateMethodResolver, 'handler'>;
-export type IDeleteResolverMetadata = StrictOmit<OpraSchema.DeleteMethodResolver, 'handler'>;
-export type IDeleteManyResolverMetadata = StrictOmit<OpraSchema.DeleteManyMethodResolver, 'handler'>;
-export type IGetResolverMetadata = StrictOmit<OpraSchema.GetMethodResolver, 'handler'>;
-export type IUpdateResolverMetadata = StrictOmit<OpraSchema.UpdateMethodResolver, 'handler'>;
-export type IUpdateManyResolverMetadata = StrictOmit<OpraSchema.UpdateManyMethodResolver, 'handler'>;
-export type ISearchResolverMetadata = StrictOmit<OpraSchema.SearchMethodResolver, 'handler'>;

package/esm/schema/opra-schema.definition.d.ts

@@ -1,178 +0,0 @@
-import { Type } from 'ts-gems';
-import { ComparisonOperator } from '../filter/index.js';
-export declare namespace OpraSchema {
-    /**
-     * *** === Constants === ***
-     */
-    export const Version = "1.0";
-    /**
-     * *** === Type definitions === ***
-     */
-    export type Extensible<T = any> = {
-        [key: `$${string}`]: T;
-    };
-    export type ResourceKind = 'ContainerResource' | 'CollectionResource' | 'SingletonResource';
-    export type DataTypeKind = 'SimpleType' | 'ComplexType' | 'UnionType';
-    export type SingletonMethod = 'get' | 'create' | 'update' | 'delete';
-    export type CollectionMethod = SingletonMethod | 'search' | 'count' | 'updateMany' | 'deleteMany';
-    /**
-     * *** === Document related === ***
-     */
-    export interface Document {
-        version: string;
-        info: DocumentInfo;
-        references?: Record<string, Reference>;
-        types?: Record<string, DataType>;
-        resources?: Record<string, Resource>;
-        servers?: ServerInfo[];
-    }
-    export type ServerInfo = Extensible & {
-        url: string;
-        description?: string;
-    };
-    export type Reference = Extensible & {
-        url?: string;
-        document?: Document;
-    };
-    export type DocumentInfo = Extensible & {
-        title: string;
-        version: string;
-        description?: string;
-        termsOfService?: string;
-        contact?: ContactPerson[];
-        license?: LicenseInfo;
-    };
-    export type ContactPerson = Extensible & {
-        name?: string;
-        email?: string;
-        url?: string;
-    };
-    export type LicenseInfo = Extensible & {
-        name: string;
-        url?: string;
-        content?: string;
-    };
-    /**
-     * *** === Data Type related === ***
-     */
-    export type DataType = ComplexType | SimpleType | UnionType;
-    export type BaseDataType = {
-        kind: DataTypeKind;
-        description?: string;
-        ctor?: Type;
-        parse?: (v: any) => any;
-        serialize?: (v: any) => any;
-    };
-    export interface SimpleType extends BaseDataType {
-        kind: 'SimpleType';
-    }
-    export interface UnionType extends BaseDataType {
-        kind: 'UnionType';
-        types: DataType[];
-    }
-    export interface ComplexType extends BaseDataType {
-        kind: 'ComplexType';
-        description?: string;
-        abstract?: boolean;
-        extends?: ComplexTypeExtendingInfo[];
-        fields?: Record<string, Field>;
-        additionalFields?: boolean | string | Pick<Field, 'type' | 'format' | 'isArray' | 'enum'>;
-    }
-    export interface ComplexTypeExtendingInfo {
-        type: string;
-        pick?: string[];
-        omit?: string[];
-    }
-    export type Field = Extensible & {
-        type: string;
-        description?: string;
-        required?: boolean;
-        isArray?: boolean;
-        format?: string;
-        default?: any;
-        fixed?: string | number;
-        enum?: string | string[] | Record<string, string>;
-        enumName?: string;
-        examples?: any[] | Record<string, any>;
-        deprecated?: boolean | string;
-        /**
-         * If true, this property will not be included in results by default.
-         * The client side should include the property name in the "include" query parameter.
-         */
-        exclusive?: boolean;
-    };
-    /**
-     * *** === Resource related === ***
-     */
-    export type Resource = ContainerResource | CollectionResource | SingletonResource;
-    export interface BaseResource {
-        kind: ResourceKind;
-        description?: string;
-        instance?: {};
-    }
-    export interface CollectionResource extends BaseResource {
-        kind: 'CollectionResource';
-        type: string;
-        keyFields: string | string[];
-        create?: CreateMethodResolver;
-        count?: CountMethodResolver;
-        delete?: DeleteMethodResolver;
-        deleteMany?: DeleteManyMethodResolver;
-        get?: GetMethodResolver;
-        update?: UpdateMethodResolver;
-        updateMany?: UpdateManyMethodResolver;
-        search?: SearchMethodResolver;
-    }
-    export interface SingletonResource extends BaseResource {
-        kind: 'SingletonResource';
-        type: string;
-        create?: CreateMethodResolver;
-        get?: GetMethodResolver;
-        update?: UpdateMethodResolver;
-        delete?: DeleteMethodResolver;
-    }
-    export interface ContainerResource extends BaseResource {
-        kind: 'ContainerResource';
-        resources: Resource[];
-    }
-    export type MethodResolver = {
-        handler?: Function;
-    };
-    type MethodResolverInputOptions = {
-        inputPick?: string[];
-        inputOmit?: string[];
-    };
-    type MethodResolverOutputOptions = {
-        outputPick?: string[];
-        outputOmit?: string[];
-    };
-    type MethodResolverFilterOptions = {
-        filters?: {
-            field: string;
-            operators?: ComparisonOperator[];
-        }[];
-    };
-    export type CreateMethodResolver = MethodResolver & MethodResolverInputOptions & MethodResolverOutputOptions;
-    export type CountMethodResolver = MethodResolver & {};
-    export type DeleteMethodResolver = MethodResolver & {};
-    export type DeleteManyMethodResolver = MethodResolver & MethodResolverFilterOptions;
-    export type GetMethodResolver = MethodResolver & MethodResolverOutputOptions;
-    export type UpdateMethodResolver = MethodResolver & MethodResolverInputOptions & MethodResolverOutputOptions;
-    export type UpdateManyMethodResolver = MethodResolver & MethodResolverFilterOptions;
-    export type SearchMethodResolver = MethodResolver & MethodResolverOutputOptions & {
-        sortFields?: string[];
-        defaultSort?: string[];
-    } & MethodResolverFilterOptions;
-    /**
-     * *** === Type Guards === ***
-     */
-    export function isDataType(obj: any): obj is DataType;
-    export function isComplexType(obj: any): obj is ComplexType;
-    export function isSimpleType(obj: any): obj is SimpleType;
-    export function isUnionTypee(obj: any): obj is UnionType;
-    export function isResource(obj: any): obj is Resource;
-    export function isCollectionResource(obj: any): obj is CollectionResource;
-    export function isSingletonResource(obj: any): obj is SingletonResource;
-    export function isContainerResource(obj: any): obj is ContainerResource;
-    export {};
-}

package/esm/schema/opra-schema.definition.js

@@ -1,46 +0,0 @@
-export var OpraSchema;
-(function (OpraSchema) {
-    /**
-     * *** === Constants === ***
-     */
-    OpraSchema.Version = '1.0';
-    /**
-     * *** === Type Guards === ***
-     */
-    function isDataType(obj) {
-        return obj && typeof obj === 'object' &&
-            (obj.kind === 'ComplexType' || obj.kind === 'SimpleType' || obj.kind === 'UnionType');
-    }
-    OpraSchema.isDataType = isDataType;
-    function isComplexType(obj) {
-        return obj && typeof obj === 'object' && obj.kind === 'ComplexType';
-    }
-    OpraSchema.isComplexType = isComplexType;
-    function isSimpleType(obj) {
-        return obj && typeof obj === 'object' && obj.kind === 'SimpleType';
-    }
-    OpraSchema.isSimpleType = isSimpleType;
-    function isUnionTypee(obj) {
-        return obj && typeof obj === 'object' && obj.kind === 'UnionType';
-    }
-    OpraSchema.isUnionTypee = isUnionTypee;
-    function isResource(obj) {
-        return obj && typeof obj === 'object' &&
-            obj.kind === 'ContainerResource' ||
-            obj.kind === 'CollectionResource' ||
-            obj.kind === 'SingletonResource';
-    }
-    OpraSchema.isResource = isResource;
-    function isCollectionResource(obj) {
-        return obj && typeof obj === 'object' && obj.kind === 'CollectionResource';
-    }
-    OpraSchema.isCollectionResource = isCollectionResource;
-    function isSingletonResource(obj) {
-        return obj && typeof obj === 'object' && obj.kind === 'SingletonResource';
-    }
-    OpraSchema.isSingletonResource = isSingletonResource;
-    function isContainerResource(obj) {
-        return obj && typeof obj === 'object' && obj.kind === 'ContainerResource';
-    }
-    OpraSchema.isContainerResource = isContainerResource;
-})(OpraSchema || (OpraSchema = {}));

package/esm/schema/type-helpers/extend-type.helper.d.ts

@@ -1,3 +0,0 @@
-import { Class } from 'ts-gems';
-export declare function PickType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Pick<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;
-export declare function OmitType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Omit<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;

package/esm/schema/type-helpers/extend-type.helper.js

@@ -1,60 +0,0 @@
-import { DATATYPE_METADATA, MAPPED_TYPE_METADATA } from '../constants.js';
-import { applyMixins, inheritPropertyInitializers } from './mixin.utils.js';
-const optionalsSymbol = Symbol.for('opra.optional-lib.sqb-connect');
-export function PickType(classRef, keys) {
-    return ExtendType(classRef, classRef, { pickKeys: keys });
-}
-export function OmitType(classRef, keys) {
-    return ExtendType(classRef, classRef, { omitKeys: keys });
-}
-function ExtendType(classRef, orgClassRef, options) {
-    const pickKeys = options.pickKeys && options.pickKeys.map(x => String(x).toLowerCase());
-    const omitKeys = options.omitKeys && options.omitKeys.map(x => String(x).toLowerCase());
-    const isInheritedPredicate = (propertyName) => {
-        if (omitKeys && omitKeys.includes(propertyName.toLowerCase()))
-            return false;
-        if (pickKeys)
-            return pickKeys.includes(propertyName.toLowerCase());
-        return true;
-    };
-    // const isRequiredPredicate = (propertyName: string): boolean | undefined => {
-    //   if (options.requiredKeys && options.requiredKeys.includes(propertyName as RequiredKey))
-    //     return true;
-    //   if (options.partialKeys && options.partialKeys.includes(propertyName as PartialKey))
-    //     return false;
-    //   return;
-    // };
-    class MappedClass {
-        constructor() {
-            inheritPropertyInitializers(this, classRef, isInheritedPredicate);
-        }
-    }
-    applyMixins(MappedClass, classRef);
-    const mappedTypeMetadata = [];
-    const m = Reflect.getOwnMetadata(DATATYPE_METADATA, classRef);
-    if (m) {
-        if (!(m.kind === 'ComplexType'))
-            throw new TypeError(`Class "${classRef}" is not a ComplexType`);
-        const meta = {
-            type: classRef
-        };
-        if (options.pickKeys)
-            meta.pick = options.pickKeys;
-        if (options.omitKeys)
-            meta.omit = options.omitKeys;
-        mappedTypeMetadata.push(meta);
-    }
-    else
-        throw new TypeError(`Class "${classRef}" doesn't have datatype metadata information`);
-    const SqbConnect = globalThis[optionalsSymbol]?.SqbConnect;
-    if (SqbConnect) {
-        const { Entity, EntityMetadata } = SqbConnect;
-        const srcMeta = Entity.getMetadata(classRef);
-        if (srcMeta) {
-            const trgMeta = EntityMetadata.define(MappedClass);
-            EntityMetadata.mixin(trgMeta, srcMeta, k => isInheritedPredicate(k));
-        }
-    }
-    Reflect.defineMetadata(MAPPED_TYPE_METADATA, mappedTypeMetadata, MappedClass);
-    return MappedClass;
-}

package/esm/schema/type-helpers/mixin-type.helper.d.ts

@@ -1,2 +0,0 @@
-import { Class } from 'ts-gems';
-export declare function MixinType<A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, c4?: Class<A4, I4, S4>): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;

package/esm/schema/type-helpers/mixin-type.helper.js

@@ -1,42 +0,0 @@
-import { DATATYPE_METADATA, MAPPED_TYPE_METADATA } from '../constants.js';
-import { applyMixins, inheritPropertyInitializers } from './mixin.utils.js';
-const optionalsSymbol = Symbol.for('opra.optional-lib.sqb-connect');
-export function MixinType(c1, c2, c3, c4) {
-    const clasRefs = [...arguments].filter(x => !!x);
-    if (!clasRefs.length)
-        throw new TypeError('You must provide base classeses');
-    if (clasRefs.length === 1)
-        return clasRefs[0];
-    class MappedClass {
-        constructor() {
-            for (const c of clasRefs)
-                inheritPropertyInitializers(this, c);
-        }
-    }
-    const mappedTypeMetadata = [];
-    for (const c of clasRefs) {
-        const m = Reflect.getOwnMetadata(DATATYPE_METADATA, c);
-        if (m) {
-            if (!(m.kind === 'ComplexType'))
-                throw new TypeError(`Class "${c}" is not a ComplexType`);
-            mappedTypeMetadata.push({
-                type: c
-            });
-        }
-        else if (Reflect.hasMetadata(MAPPED_TYPE_METADATA, c)) {
-            const mtm = Reflect.getMetadata(MAPPED_TYPE_METADATA, c);
-            if (mtm)
-                mappedTypeMetadata.push(...mtm);
-        }
-        else
-            throw new TypeError(`Class "${c}" doesn't have datatype metadata information`);
-        applyMixins(MappedClass, c);
-    }
-    const SqbConnect = globalThis[optionalsSymbol]?.SqbConnect;
-    if (SqbConnect) {
-        const { Entity } = SqbConnect;
-        Entity.mixin(MappedClass, ...clasRefs);
-    }
-    Reflect.defineMetadata(MAPPED_TYPE_METADATA, mappedTypeMetadata, MappedClass);
-    return MappedClass;
-}

package/esm/schema/utils/class.utils.d.ts

@@ -1,2 +0,0 @@
-import { Type } from 'ts-gems';
-export declare function isConstructor(obj: any): obj is Type;

package/esm/schema/utils/class.utils.js

@@ -1,4 +0,0 @@
-export function isConstructor(obj) {
-    return typeof obj === 'function' &&
-        !!(obj.prototype && obj.prototype.constructor);
-}

package/esm/schema/utils/normalize-field-array.util.d.ts

@@ -1,3 +0,0 @@
-import { ComplexType } from '../implementation/data-type/complex-type.js';
-import type { OpraDocument } from '../implementation/opra-document.js';
-export declare function normalizeFieldArray(document: OpraDocument, dataType: ComplexType | undefined, fields: string[], parentPath?: string): string[];