@goatlab/fluent 0.7.31 → 0.7.32

package/dist/core/Nestjs/types/reflection.utils.d.ts

@@ -1,15 +0,0 @@
-import { GqlTypeReference, ReturnTypeFunc } from './interfaces/return-type-func.interface';
-import { TypeOptions } from './interfaces/type-options.interface';
-export interface ReflectTypeOptions {
-    metadataKey: 'design:type' | 'design:returntype' | 'design:paramtypes';
-    prototype?: Object;
-    propertyKey: string;
-    explicitTypeFn?: ReturnTypeFunc;
-    typeOptions?: TypeOptions;
-    index?: number;
-}
-export interface TypeMetadata {
-    typeFn: (type?: any) => GqlTypeReference;
-    options: TypeOptions;
-}
-export declare function reflectTypeFromMetadata(reflectOptions: ReflectTypeOptions): TypeMetadata;

package/dist/core/Nestjs/types/reflection.utils.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.reflectTypeFromMetadata = void 0;
-const undefined_type_error_1 = require("./errors/undefined-type.error");
-const get = (obj, path, defaultValue = undefined) => {
-    const travel = regexp => String.prototype.split
-        .call(path, regexp)
-        .filter(Boolean)
-        .reduce((res, key) => (res !== null && res !== undefined ? res[key] : res), obj);
-    const result = travel(/[,[\]]+?/) || travel(/[,[\].]+?/);
-    return result === undefined || result === obj ? defaultValue : result;
-};
-const NOT_ALLOWED_TYPES = [Promise, Array, Object, Function];
-function reflectTypeFromMetadata(reflectOptions) {
-    const { metadataKey, prototype, propertyKey, explicitTypeFn, typeOptions = {}, index } = reflectOptions;
-    const options = { ...typeOptions };
-    const reflectedType = Reflect.getMetadata(metadataKey, prototype, propertyKey);
-    const implicitType = extractTypeIfArray(metadataKey, reflectedType, index);
-    const isNotAllowed = implicitType && NOT_ALLOWED_TYPES.includes(implicitType);
-    if ((!explicitTypeFn && (!implicitType || isNotAllowed)) ||
-        (!implicitType && !explicitTypeFn)) {
-        throw new undefined_type_error_1.UndefinedTypeError(get(prototype, 'constructor.name'), propertyKey, index);
-    }
-    if (explicitTypeFn) {
-        return {
-            typeFn: createWrappedExplicitTypeFn(explicitTypeFn, options),
-            options
-        };
-    }
-    return {
-        typeFn: () => implicitType,
-        options: implicitType === Array
-            ? {
-                ...options,
-                isArray: true,
-                arrayDepth: 1
-            }
-            : options
-    };
-}
-exports.reflectTypeFromMetadata = reflectTypeFromMetadata;
-function extractTypeIfArray(metadataKey, reflectedType, index) {
-    if (metadataKey === 'design:paramtypes') {
-        return reflectedType[index];
-    }
-    return reflectedType;
-}
-function getTypeReferenceAndArrayDepth([typeOrArray], depth = 1) {
-    if (!Array.isArray(typeOrArray)) {
-        return { depth, typeRef: typeOrArray };
-    }
-    return getTypeReferenceAndArrayDepth(typeOrArray, depth + 1);
-}
-function createWrappedExplicitTypeFn(explicitTypeFn, options) {
-    return () => {
-        const explicitTypeRef = explicitTypeFn();
-        if (Array.isArray(explicitTypeRef)) {
-            const { depth, typeRef } = getTypeReferenceAndArrayDepth(explicitTypeRef);
-            options.isArray = true;
-            options.arrayDepth = depth;
-            return typeRef;
-        }
-        return explicitTypeRef;
-    };
-}

package/dist/core/Nestjs/types/set-metadata.decorator.d.ts

@@ -1,4 +0,0 @@
-export declare type CustomDecorator<TKey = string> = MethodDecorator & ClassDecorator & {
-    KEY: TKey;
-};
-export declare const SetMetadata: <K = string, V = any>(metadataKey: K, metadataValue: V) => CustomDecorator<K>;

package/dist/core/Nestjs/types/set-metadata.decorator.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetMetadata = void 0;
-const SetMetadata = (metadataKey, metadataValue) => {
-    const decoratorFactory = (target, key, descriptor) => {
-        if (descriptor) {
-            Reflect.defineMetadata(metadataKey, metadataValue, descriptor.value);
-            return descriptor;
-        }
-        Reflect.defineMetadata(metadataKey, metadataValue, target);
-        return target;
-    };
-    decoratorFactory.KEY = metadataKey;
-    return decoratorFactory;
-};
-exports.SetMetadata = SetMetadata;

package/dist/core/Nestjs/types/type-metadata.storage.d.ts

@@ -1,69 +0,0 @@
-import { ClassExtensionsMetadata, ClassMetadata, EnumMetadata, FieldResolverMetadata, MethodArgsMetadata, PropertyExtensionsMetadata, PropertyMetadata, ResolverClassMetadata, ResolverTypeMetadata, UnionMetadata } from './metadata';
-import { ClassDirectiveMetadata, PropertyDirectiveMetadata } from './metadata/directive.metadata';
-import { InterfaceMetadata } from './metadata/interface.metadata';
-import { ObjectTypeMetadata } from './metadata/object-type.metadata';
-import { Type } from './common';
-export declare const METADATA_FACTORY_NAME = "_GRAPHQL_METADATA_FACTORY";
-export declare class TypeMetadataStorageHost {
-    private queries;
-    private mutations;
-    private subscriptions;
-    private fieldResolvers;
-    private readonly resolvers;
-    private readonly fields;
-    private readonly params;
-    private readonly interfaces;
-    private readonly enums;
-    private readonly unions;
-    private readonly classDirectives;
-    private readonly fieldDirectives;
-    private readonly classExtensions;
-    private readonly fieldExtensions;
-    private readonly objectTypes;
-    private readonly inputTypes;
-    private readonly argumentTypes;
-    addMutationMetadata(metadata: ResolverTypeMetadata): void;
-    getMutationsMetadata(): ResolverTypeMetadata[];
-    addQueryMetadata(metadata: ResolverTypeMetadata): void;
-    getQueriesMetadata(): ResolverTypeMetadata[];
-    addSubscriptionMetadata(metadata: ResolverTypeMetadata): void;
-    getSubscriptionsMetadata(): ResolverTypeMetadata[];
-    addResolverPropertyMetadata(metadata: FieldResolverMetadata): void;
-    addArgsMetadata(metadata: ClassMetadata): void;
-    getArgumentsMetadata(): ClassMetadata[];
-    getArgumentsMetadataByTarget(target: Type<unknown>): ClassMetadata | undefined;
-    addInterfaceMetadata(metadata: InterfaceMetadata): void;
-    getInterfacesMetadata(): InterfaceMetadata[];
-    getInterfaceMetadataByTarget(target: Type<unknown>): InterfaceMetadata | undefined;
-    addInputTypeMetadata(metadata: ClassMetadata): void;
-    getInputTypesMetadata(): ClassMetadata[];
-    getInputTypeMetadataByTarget(target: Type<unknown>): ObjectTypeMetadata | undefined;
-    addObjectTypeMetadata(metadata: ObjectTypeMetadata): void;
-    getObjectTypesMetadata(): ObjectTypeMetadata[];
-    getObjectTypeMetadataByTarget(target: Type<unknown>): ObjectTypeMetadata | undefined;
-    addEnumMetadata(metadata: EnumMetadata): void;
-    getEnumsMetadata(): EnumMetadata[];
-    addUnionMetadata(metadata: UnionMetadata): void;
-    getUnionsMetadata(): UnionMetadata[];
-    addDirectiveMetadata(metadata: ClassDirectiveMetadata): void;
-    addDirectivePropertyMetadata(metadata: PropertyDirectiveMetadata): void;
-    addExtensionsMetadata(metadata: ClassExtensionsMetadata): void;
-    addExtensionsPropertyMetadata(metadata: PropertyExtensionsMetadata): void;
-    addResolverMetadata(metadata: ResolverClassMetadata): void;
-    addClassFieldMetadata(metadata: PropertyMetadata): void;
-    addMethodParamMetadata(metadata: MethodArgsMetadata): void;
-    compile(orphanedTypes?: Function[]): void;
-    loadClassPluginMetadata(metadata: ClassMetadata[]): void;
-    applyPluginMetadata(prototype: Function): void;
-    compileClassMetadata(metadata: ClassMetadata[]): void;
-    clear(): void;
-    private getClassFieldsByPredicate;
-    private compileResolversMetadata;
-    private compileFieldResolverMetadata;
-    private compileExternalFieldResolverMetadata;
-    private compileExtendedResolversMetadata;
-    private isFieldDirectiveOrExtension;
-    private mergeParentResolverHandlers;
-    private mergeParentFieldHandlers;
-}
-export declare const TypeMetadataStorage: TypeMetadataStorageHost;

package/dist/core/Nestjs/types/type-metadata.storage.js

@@ -1,342 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeMetadataStorage = exports.TypeMetadataStorageHost = exports.METADATA_FACTORY_NAME = void 0;
-const field_decorator_1 = require("./decorators/field.decorator");
-const cannot_determine_host_type_error_1 = require("./errors/cannot-determine-host-type.error");
-const undefined_type_error_1 = require("./errors/undefined-type.error");
-const common_1 = require("./common");
-exports.METADATA_FACTORY_NAME = '_GRAPHQL_METADATA_FACTORY';
-class TypeMetadataStorageHost {
-    constructor() {
-        this.queries = new Array();
-        this.mutations = new Array();
-        this.subscriptions = new Array();
-        this.fieldResolvers = new Array();
-        this.resolvers = new Array();
-        this.fields = new Array();
-        this.params = new Array();
-        this.interfaces = new Array();
-        this.enums = new Array();
-        this.unions = new Array();
-        this.classDirectives = new Array();
-        this.fieldDirectives = new Array();
-        this.classExtensions = new Array();
-        this.fieldExtensions = new Array();
-        this.objectTypes = new Array();
-        this.inputTypes = new Array();
-        this.argumentTypes = new Array();
-    }
-    addMutationMetadata(metadata) {
-        this.mutations.push(metadata);
-    }
-    getMutationsMetadata() {
-        return this.mutations;
-    }
-    addQueryMetadata(metadata) {
-        this.queries.push(metadata);
-    }
-    getQueriesMetadata() {
-        return this.queries;
-    }
-    addSubscriptionMetadata(metadata) {
-        this.subscriptions.push(metadata);
-    }
-    getSubscriptionsMetadata() {
-        return this.subscriptions;
-    }
-    addResolverPropertyMetadata(metadata) {
-        this.fieldResolvers.push(metadata);
-    }
-    addArgsMetadata(metadata) {
-        this.argumentTypes.push(metadata);
-    }
-    getArgumentsMetadata() {
-        return this.argumentTypes;
-    }
-    getArgumentsMetadataByTarget(target) {
-        return this.argumentTypes.find(item => item.target === target);
-    }
-    addInterfaceMetadata(metadata) {
-        this.interfaces.push(metadata);
-    }
-    getInterfacesMetadata() {
-        return this.interfaces;
-    }
-    getInterfaceMetadataByTarget(target) {
-        return this.interfaces.find(item => item.target === target);
-    }
-    addInputTypeMetadata(metadata) {
-        this.inputTypes.push(metadata);
-    }
-    getInputTypesMetadata() {
-        return this.inputTypes;
-    }
-    getInputTypeMetadataByTarget(target) {
-        return this.inputTypes.find(item => item.target === target);
-    }
-    addObjectTypeMetadata(metadata) {
-        this.objectTypes.push(metadata);
-    }
-    getObjectTypesMetadata() {
-        return this.objectTypes;
-    }
-    getObjectTypeMetadataByTarget(target) {
-        return this.objectTypes.find(item => item.target === target);
-    }
-    addEnumMetadata(metadata) {
-        this.enums.push(metadata);
-    }
-    getEnumsMetadata() {
-        return this.enums;
-    }
-    addUnionMetadata(metadata) {
-        this.unions.push(metadata);
-    }
-    getUnionsMetadata() {
-        return this.unions;
-    }
-    addDirectiveMetadata(metadata) {
-        const exist = this.fieldDirectives.some(directiveMetadata => directiveMetadata.sdl === metadata.sdl &&
-            directiveMetadata.target === metadata.target);
-        if (!exist) {
-            this.classDirectives.push(metadata);
-        }
-    }
-    addDirectivePropertyMetadata(metadata) {
-        const exist = this.fieldDirectives.some(directiveMetadata => directiveMetadata.fieldName === metadata.fieldName &&
-            directiveMetadata.sdl === metadata.sdl &&
-            directiveMetadata.target === metadata.target);
-        if (!exist) {
-            this.fieldDirectives.push(metadata);
-        }
-    }
-    addExtensionsMetadata(metadata) {
-        this.classExtensions.push(metadata);
-    }
-    addExtensionsPropertyMetadata(metadata) {
-        this.fieldExtensions.push(metadata);
-    }
-    addResolverMetadata(metadata) {
-        this.resolvers.push(metadata);
-    }
-    addClassFieldMetadata(metadata) {
-        const existingMetadata = this.fields.find(item => item.target === metadata.target && item.name === metadata.name);
-        if (existingMetadata) {
-            const { options } = existingMetadata;
-            if ((0, common_1.isUndefined)(options.nullable) && (0, common_1.isUndefined)(options.defaultValue)) {
-                options.nullable = metadata.options.nullable;
-            }
-        }
-        else {
-            this.fields.push(metadata);
-        }
-    }
-    addMethodParamMetadata(metadata) {
-        this.params.push(metadata);
-    }
-    compile(orphanedTypes = []) {
-        this.classDirectives.reverse();
-        this.classExtensions.reverse();
-        this.fieldDirectives.reverse();
-        this.fieldExtensions.reverse();
-        const classMetadata = [
-            ...this.objectTypes,
-            ...this.inputTypes,
-            ...this.argumentTypes,
-            ...this.interfaces
-        ];
-        this.loadClassPluginMetadata(classMetadata);
-        this.compileClassMetadata(classMetadata);
-        this.compileFieldResolverMetadata(this.fieldResolvers);
-        const resolversMetadata = [
-            ...this.queries,
-            ...this.mutations,
-            ...this.subscriptions
-        ];
-        this.compileResolversMetadata(resolversMetadata);
-        this.compileExtendedResolversMetadata();
-        orphanedTypes
-            .filter(type => type && type.prototype)
-            .forEach(type => this.applyPluginMetadata(type.prototype));
-    }
-    loadClassPluginMetadata(metadata) {
-        metadata
-            .filter(item => item?.target)
-            .forEach(item => this.applyPluginMetadata(item.target.prototype));
-    }
-    applyPluginMetadata(prototype) {
-        do {
-            if (!prototype.constructor) {
-                return;
-            }
-            if (!prototype.constructor[exports.METADATA_FACTORY_NAME]) {
-                continue;
-            }
-            const metadata = prototype.constructor[exports.METADATA_FACTORY_NAME]();
-            const properties = Object.keys(metadata);
-            properties.forEach(key => {
-                if (metadata[key].type) {
-                    const { type, ...options } = metadata[key];
-                    (0, field_decorator_1.addFieldMetadata)(type, options, prototype, key, undefined, true);
-                }
-                else {
-                    (0, field_decorator_1.addFieldMetadata)(metadata[key], undefined, prototype, key, undefined, true);
-                }
-            });
-        } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
-            prototype !== Object.prototype &&
-            prototype);
-    }
-    compileClassMetadata(metadata) {
-        metadata.forEach(item => {
-            const belongsToClass = common_1.isTargetEqual.bind(undefined, item);
-            if (!item.properties) {
-                item.properties = this.getClassFieldsByPredicate(belongsToClass);
-            }
-            if (!item.directives) {
-                item.directives = this.classDirectives.filter(belongsToClass);
-            }
-            if (!item.extensions) {
-                item.extensions = this.classExtensions
-                    .filter(belongsToClass)
-                    .reduce((curr, acc) => ({ ...curr, ...acc.value }), {});
-            }
-        });
-    }
-    clear() {
-        Object.assign(this, new TypeMetadataStorageHost());
-    }
-    getClassFieldsByPredicate(belongsToClass) {
-        const fields = this.fields.filter(belongsToClass);
-        fields.forEach(field => {
-            const isHostEqual = common_1.isTargetEqual.bind(undefined, field);
-            field.methodArgs = this.params.filter(param => isHostEqual(param) && field.name === param.methodName);
-            field.directives = this.fieldDirectives.filter(this.isFieldDirectiveOrExtension.bind(this, field));
-            field.extensions = this.fieldExtensions
-                .filter(this.isFieldDirectiveOrExtension.bind(this, field))
-                .reduce((curr, acc) => ({ ...curr, ...acc.value }), {});
-        });
-        return fields;
-    }
-    compileResolversMetadata(metadata) {
-        metadata.forEach(item => {
-            const isTypeEqual = common_1.isTargetEqual.bind(undefined, item);
-            const resolverMetadata = this.resolvers.find(isTypeEqual);
-            item.classMetadata = resolverMetadata;
-            item.methodArgs = this.params.filter(param => isTypeEqual(param) && item.methodName === param.methodName);
-            item.directives = this.fieldDirectives.filter(this.isFieldDirectiveOrExtension.bind(this, item));
-            item.extensions = this.fieldExtensions
-                .filter(this.isFieldDirectiveOrExtension.bind(this, item))
-                .reduce((curr, acc) => ({ ...curr, ...acc.value }), {});
-        });
-    }
-    compileFieldResolverMetadata(metadata) {
-        this.compileResolversMetadata(metadata);
-        metadata.forEach(item => {
-            const belongsToClass = common_1.isTargetEqual.bind(undefined, item);
-            item.directives = this.fieldDirectives.filter(this.isFieldDirectiveOrExtension.bind(this, item));
-            item.extensions = this.fieldExtensions
-                .filter(this.isFieldDirectiveOrExtension.bind(this, item))
-                .reduce((curr, acc) => ({ ...curr, ...acc.value }), {});
-            item.objectTypeFn =
-                item.kind === 'external'
-                    ? this.resolvers?.find(belongsToClass)?.typeFn
-                    : () => item.target;
-            if (item.kind === 'external') {
-                this.compileExternalFieldResolverMetadata(item);
-            }
-        });
-    }
-    compileExternalFieldResolverMetadata(item) {
-        const objectTypeRef = this.resolvers
-            .find(el => (0, common_1.isTargetEqual)(el, item))
-            ?.typeFn();
-        const objectOrInterfaceTypeMetadata = this.objectTypes.find(objTypeDef => objTypeDef.target === objectTypeRef) ||
-            this.interfaces.find(interfaceTypeDef => interfaceTypeDef.target === objectTypeRef);
-        if (!objectOrInterfaceTypeMetadata) {
-            throw new cannot_determine_host_type_error_1.CannotDetermineHostTypeError(item.schemaName, objectTypeRef?.name);
-        }
-        const objectOrInterfaceTypeField = objectOrInterfaceTypeMetadata.properties?.find(fieldDef => fieldDef.name === item.methodName);
-        if (!objectOrInterfaceTypeField) {
-            if (!item.typeFn || !item.typeOptions) {
-                throw new undefined_type_error_1.UndefinedTypeError(item.target.name, item.methodName);
-            }
-            const fieldMetadata = {
-                name: item.methodName,
-                schemaName: item.schemaName,
-                deprecationReason: item.deprecationReason,
-                description: item.description,
-                typeFn: item.typeFn,
-                target: objectTypeRef,
-                options: item.typeOptions,
-                methodArgs: item.methodArgs,
-                directives: item.directives,
-                extensions: item.extensions,
-                complexity: item.complexity
-            };
-            this.addClassFieldMetadata(fieldMetadata);
-            objectOrInterfaceTypeMetadata.properties?.push(fieldMetadata);
-        }
-        else {
-            const isEmpty = (arr) => arr.length === 0;
-            if (isEmpty(objectOrInterfaceTypeField.methodArgs)) {
-                objectOrInterfaceTypeField.methodArgs = item.methodArgs;
-            }
-            if (isEmpty(objectOrInterfaceTypeField.directives)) {
-                objectOrInterfaceTypeField.directives = item.directives;
-            }
-            if (!objectOrInterfaceTypeField.extensions) {
-                objectOrInterfaceTypeField.extensions = item.extensions;
-            }
-            objectOrInterfaceTypeField.complexity =
-                item.complexity === undefined
-                    ? objectOrInterfaceTypeField.complexity
-                    : item.complexity;
-        }
-    }
-    compileExtendedResolversMetadata() {
-        this.resolvers.forEach(item => {
-            let parentClass = Object.getPrototypeOf(item.target);
-            while (parentClass.prototype) {
-                const parentMetadata = this.resolvers.find(item => item.target === parentClass);
-                if (parentMetadata) {
-                    this.queries = this.mergeParentResolverHandlers(this.queries, parentClass, item);
-                    this.mutations = this.mergeParentResolverHandlers(this.mutations, parentClass, item);
-                    this.subscriptions = this.mergeParentResolverHandlers(this.subscriptions, parentClass, item);
-                    this.fieldResolvers = this.mergeParentFieldHandlers(this.fieldResolvers, parentClass, item);
-                }
-                parentClass = Object.getPrototypeOf(parentClass);
-            }
-        });
-    }
-    isFieldDirectiveOrExtension(host, metadata) {
-        return (metadata.target === host.target &&
-            metadata.fieldName === (host.methodName || host.name));
-    }
-    mergeParentResolverHandlers(metadata, parentClass, classMetadata) {
-        const mergedMetadata = metadata.map(metadata => metadata.target !== parentClass
-            ? metadata
-            : {
-                ...metadata,
-                target: classMetadata.target,
-                classMetadata
-            });
-        return mergedMetadata;
-    }
-    mergeParentFieldHandlers(metadata, parentClass, classMetadata) {
-        const parentMetadata = this.mergeParentResolverHandlers(metadata, parentClass, classMetadata);
-        const mergedMetadata = parentMetadata.map(metadata => metadata.target === parentClass
-            ? metadata
-            : {
-                ...metadata,
-                objectTypeFn: (0, common_1.isThrowing)(metadata.objectTypeFn)
-                    ? classMetadata.typeFn
-                    : metadata.objectTypeFn
-            });
-        return mergedMetadata;
-    }
-}
-exports.TypeMetadataStorageHost = TypeMetadataStorageHost;
-const globalRef = global;
-exports.TypeMetadataStorage = globalRef.GqlTypeMetadataStorage ||
-    (globalRef.GqlTypeMetadataStorage = new TypeMetadataStorageHost());

package/dist/core/Nestjs/types/utils/enum.utils.d.ts

@@ -1,3 +0,0 @@
-export declare type SwaggerEnumType = string[] | number[] | (string | number)[] | Record<number, string>;
-export declare function getEnumValues(enumType: SwaggerEnumType): string[] | number[];
-export declare function getEnumType(values: (string | number)[]): 'string' | 'number';

package/dist/core/Nestjs/types/utils/enum.utils.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnumType = exports.getEnumValues = void 0;
-const common_1 = require("../common");
-function getEnumValues(enumType) {
-    if (Array.isArray(enumType)) {
-        return enumType;
-    }
-    if (typeof enumType !== 'object') {
-        return [];
-    }
-    const values = [];
-    const uniqueValues = {};
-    for (const key in enumType) {
-        const value = enumType[key];
-        if (!uniqueValues.hasOwnProperty(value) &&
-            !uniqueValues.hasOwnProperty(key)) {
-            values.push(value);
-            uniqueValues[value] = value;
-        }
-    }
-    return values;
-}
-exports.getEnumValues = getEnumValues;
-function getEnumType(values) {
-    const hasString = values.filter(common_1.isString).length > 0;
-    return hasString ? 'string' : 'number';
-}
-exports.getEnumType = getEnumType;

package/dist/core/Nestjs/types/utils/get-fields-and-decorator.util.d.ts

@@ -1,3 +0,0 @@
-import 'reflect-metadata';
-import { Type } from '../common';
-export declare function getFieldsAndDecoratorForType<T>(objType: Type<T>): any;

package/dist/core/Nestjs/types/utils/get-fields-and-decorator.util.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFieldsAndDecoratorForType = void 0;
-require("reflect-metadata");
-const common_1 = require("../common");
-const args_type_decorator_1 = require("../decorators/args-type.decorator");
-const input_type_decorator_1 = require("../decorators/input-type.decorator");
-const interface_type_decorator_1 = require("../decorators/interface-type.decorator");
-const unable_to_find_fields_error_1 = require("../errors/unable-to-find-fields.error");
-const add_class_type_metadata_util_1 = require("../interfaces/add-class-type-metadata.util");
-const object_type_decorator_1 = require("../object-type.decorator");
-const lazy_metadata_storage_1 = require("../lazy-metadata.storage");
-const type_metadata_storage_1 = require("../type-metadata.storage");
-function getFieldsAndDecoratorForType(objType) {
-    const classType = Reflect.getMetadata(add_class_type_metadata_util_1.CLASS_TYPE_METADATA, objType);
-    if (!classType) {
-        throw new unable_to_find_fields_error_1.UnableToFindFieldsError(objType.name);
-    }
-    lazy_metadata_storage_1.LazyMetadataStorage.load([objType], {
-        skipFieldLazyMetadata: true
-    });
-    const [classMetadata, decoratorFactory] = getClassMetadataAndFactoryByTargetAndType(classType, objType);
-    type_metadata_storage_1.TypeMetadataStorage.loadClassPluginMetadata([classMetadata]);
-    type_metadata_storage_1.TypeMetadataStorage.compileClassMetadata([classMetadata]);
-    let fields = classMetadata?.properties;
-    if (!fields) {
-        throw new unable_to_find_fields_error_1.UnableToFindFieldsError(objType.name);
-    }
-    fields = inheritClassFields(objType, fields);
-    return {
-        fields,
-        decoratorFactory
-    };
-}
-exports.getFieldsAndDecoratorForType = getFieldsAndDecoratorForType;
-function getClassMetadataAndFactoryByTargetAndType(classType, objType) {
-    switch (classType) {
-        case common_1.ClassType.ARGS:
-            return [
-                type_metadata_storage_1.TypeMetadataStorage.getArgumentsMetadataByTarget(objType),
-                args_type_decorator_1.ArgsType
-            ];
-        case common_1.ClassType.OBJECT:
-            return [
-                type_metadata_storage_1.TypeMetadataStorage.getObjectTypeMetadataByTarget(objType),
-                object_type_decorator_1.ObjectType
-            ];
-        case common_1.ClassType.INPUT:
-            return [
-                type_metadata_storage_1.TypeMetadataStorage.getInputTypeMetadataByTarget(objType),
-                input_type_decorator_1.InputType
-            ];
-        case common_1.ClassType.INTERFACE:
-            return [
-                type_metadata_storage_1.TypeMetadataStorage.getInterfaceMetadataByTarget(objType),
-                interface_type_decorator_1.InterfaceType
-            ];
-    }
-}
-function inheritClassFields(objType, fields) {
-    try {
-        const parentClass = Object.getPrototypeOf(objType);
-        if (parentClass === Function) {
-            return fields;
-        }
-        const { fields: parentFields } = getFieldsAndDecoratorForType(parentClass);
-        return inheritClassFields(parentClass, [...parentFields, ...fields]);
-    }
-    catch (err) {
-        return fields;
-    }
-}

package/dist/core/Nestjs/types/utils/mapped-types.utils.d.ts

@@ -1,2 +0,0 @@
-import { Type } from '../common';
-export declare function clonePluginMetadataFactory(target: Type<unknown>, parent: Type<unknown>, transformFn?: (metadata: Record<string, any>) => Record<string, any>): void;

package/dist/core/Nestjs/types/utils/mapped-types.utils.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clonePluginMetadataFactory = void 0;
-const type_metadata_storage_1 = require("../type-metadata.storage");
-const identity = a => a;
-function clonePluginMetadataFactory(target, parent, transformFn = identity) {
-    let targetMetadata = {};
-    do {
-        if (!parent.constructor) {
-            return;
-        }
-        if (!parent.constructor[type_metadata_storage_1.METADATA_FACTORY_NAME]) {
-            continue;
-        }
-        const parentMetadata = parent.constructor[type_metadata_storage_1.METADATA_FACTORY_NAME]();
-        targetMetadata = {
-            ...parentMetadata,
-            ...targetMetadata
-        };
-    } while ((parent = Reflect.getPrototypeOf(parent)) &&
-        parent !== Object.prototype &&
-        parent);
-    targetMetadata = transformFn(targetMetadata);
-    if (target[type_metadata_storage_1.METADATA_FACTORY_NAME]) {
-        const originalFactory = target[type_metadata_storage_1.METADATA_FACTORY_NAME];
-        target[type_metadata_storage_1.METADATA_FACTORY_NAME] = () => {
-            const originalMetadata = originalFactory();
-            return {
-                ...originalMetadata,
-                ...targetMetadata
-            };
-        };
-    }
-    else {
-        target[type_metadata_storage_1.METADATA_FACTORY_NAME] = () => targetMetadata;
-    }
-}
-exports.clonePluginMetadataFactory = clonePluginMetadataFactory;

package/dist/core/Nestjs/types/utils/model-properties-accessor.d.ts

@@ -1,6 +0,0 @@
-import { Type } from '../common';
-import 'reflect-metadata';
-export declare class ModelPropertiesAccessor {
-    getModelProperties(prototype: Type<unknown>): string[];
-    applyMetadataFactory(prototype: Type<unknown>): void;
-}