@goatlab/fluent 0.7.21 → 0.7.22

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

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

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

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

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

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

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

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

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

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

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

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

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

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