@goatlab/fluent 0.7.21 → 0.7.24

package/dist/core/Nestjs/types/decorators/apply-is-optional.decorator.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inheritPropertyInitializers = exports.inheritTransformationMetadata = exports.inheritValidationMetadata = exports.applyIsOptionalDecorator = void 0;
+function applyIsOptionalDecorator(targetClass, propertyKey) {
+    if (!isClassValidatorAvailable()) {
+        return;
+    }
+    const classValidator = require('class-validator');
+    const decoratorFactory = classValidator.IsOptional();
+    decoratorFactory(targetClass.prototype, propertyKey);
+}
+exports.applyIsOptionalDecorator = applyIsOptionalDecorator;
+function inheritValidationMetadata(parentClass, targetClass, isPropertyInherited) {
+    if (!isClassValidatorAvailable()) {
+        return;
+    }
+    try {
+        const classValidator = require('class-validator');
+        const metadataStorage = classValidator.getMetadataStorage
+            ? classValidator.getMetadataStorage()
+            : classValidator.getFromContainer(classValidator.MetadataStorage);
+        const getTargetValidationMetadatasArgs = [parentClass, null, false, false];
+        const targetMetadata = metadataStorage.getTargetValidationMetadatas(...getTargetValidationMetadatasArgs);
+        return targetMetadata
+            .filter(({ propertyName }) => !isPropertyInherited || isPropertyInherited(propertyName))
+            .map(value => {
+            const originalType = Reflect.getMetadata('design:type', parentClass.prototype, value.propertyName);
+            if (originalType) {
+                Reflect.defineMetadata('design:type', originalType, targetClass.prototype, value.propertyName);
+            }
+            metadataStorage.addValidationMetadata({
+                ...value,
+                target: targetClass
+            });
+            return value.propertyName;
+        });
+    }
+    catch (err) {
+        console.error(`Validation ("class-validator") metadata cannot be inherited for "${parentClass.name}" class.`);
+        console.error(err);
+    }
+}
+exports.inheritValidationMetadata = inheritValidationMetadata;
+function inheritTransformationMetadata(parentClass, targetClass, isPropertyInherited) {
+    if (!isClassTransformerAvailable()) {
+        return;
+    }
+    try {
+        const transformMetadataKeys = [
+            '_excludeMetadatas',
+            '_exposeMetadatas',
+            '_transformMetadatas',
+            '_typeMetadatas'
+        ];
+        transformMetadataKeys.forEach(key => inheritTransformerMetadata(key, parentClass, targetClass, isPropertyInherited));
+    }
+    catch (err) {
+        console.error(`Transformer ("class-transformer") metadata cannot be inherited for "${parentClass.name}" class.`);
+        console.error(err);
+    }
+}
+exports.inheritTransformationMetadata = inheritTransformationMetadata;
+function inheritTransformerMetadata(key, parentClass, targetClass, isPropertyInherited) {
+    let classTransformer;
+    try {
+        classTransformer = require('class-transformer/cjs/storage');
+    }
+    catch {
+        classTransformer = require('class-transformer/storage');
+    }
+    const metadataStorage = classTransformer.defaultMetadataStorage;
+    while (parentClass && parentClass !== Object) {
+        if (metadataStorage[key].has(parentClass)) {
+            const metadataMap = metadataStorage[key];
+            const parentMetadata = metadataMap.get(parentClass);
+            const targetMetadataEntries = Array.from(parentMetadata.entries())
+                .filter(([key]) => !isPropertyInherited || isPropertyInherited(key))
+                .map(([key, metadata]) => {
+                if (Array.isArray(metadata)) {
+                    const targetMetadata = metadata.map(item => ({
+                        ...item,
+                        target: targetClass
+                    }));
+                    return [key, targetMetadata];
+                }
+                return [key, { ...metadata, target: targetClass }];
+            });
+            if (metadataMap.has(targetClass)) {
+                const existingRules = metadataMap.get(targetClass).entries();
+                metadataMap.set(targetClass, new Map([...existingRules, ...targetMetadataEntries]));
+            }
+            else {
+                metadataMap.set(targetClass, new Map(targetMetadataEntries));
+            }
+        }
+        parentClass = Object.getPrototypeOf(parentClass);
+    }
+}
+function isClassValidatorAvailable() {
+    try {
+        require('class-validator');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isClassTransformerAvailable() {
+    try {
+        require('class-transformer');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function inheritPropertyInitializers(target, sourceClass, isPropertyInherited = (key) => true) {
+    try {
+        const tempInstance = new sourceClass();
+        const propertyNames = Object.getOwnPropertyNames(tempInstance);
+        propertyNames
+            .filter(propertyName => typeof tempInstance[propertyName] !== 'undefined' &&
+            typeof target[propertyName] === 'undefined')
+            .filter(propertyName => isPropertyInherited(propertyName))
+            .forEach(propertyName => {
+            target[propertyName] = tempInstance[propertyName];
+        });
+    }
+    catch { }
+}
+exports.inheritPropertyInitializers = inheritPropertyInitializers;

package/dist/core/Nestjs/types/decorators/args-type.decorator.d.ts

@@ -0,0 +1 @@
+export declare function ArgsType(): ClassDecorator;

package/dist/core/Nestjs/types/decorators/args-type.decorator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgsType = void 0;
+const lazy_metadata_storage_1 = require("../lazy-metadata.storage");
+const type_metadata_storage_1 = require("../type-metadata.storage");
+const add_class_type_metadata_util_1 = require("../interfaces/add-class-type-metadata.util");
+const common_1 = require("../common");
+function ArgsType() {
+    return (target) => {
+        const metadata = {
+            name: target.name,
+            target
+        };
+        lazy_metadata_storage_1.LazyMetadataStorage.store(() => type_metadata_storage_1.TypeMetadataStorage.addArgsMetadata(metadata));
+        type_metadata_storage_1.TypeMetadataStorage.addArgsMetadata(metadata);
+        (0, add_class_type_metadata_util_1.addClassTypeMetadata)(target, common_1.ClassType.ARGS);
+    };
+}
+exports.ArgsType = ArgsType;

package/dist/core/Nestjs/types/decorators/create-property.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare function createPropertyDecorator<T extends Record<string, any> = any>(metakey: string, metadata: T, overrideExisting?: boolean): PropertyDecorator;
+export declare function getTypeIsArrayTuple(input: Function | [Function] | undefined | string | Record<string, any>, isArrayFlag: boolean): [Function | undefined, boolean];

package/dist/core/Nestjs/types/decorators/create-property.decorator.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeIsArrayTuple = exports.createPropertyDecorator = void 0;
+const type_metadata_storage_1 = require("../type-metadata.storage");
+const api_property_decorator_1 = require("./api-property.decorator");
+const isUndefined = val => typeof val === 'undefined';
+const OmitBy = (obj, check) => {
+    obj = { ...obj };
+    Object.entries(obj).forEach(([key, value]) => check(value) && delete obj[key]);
+    return obj;
+};
+function createPropertyDecorator(metakey, metadata, overrideExisting = true) {
+    return (target, propertyKey) => {
+        const properties = Reflect.getMetadata(api_property_decorator_1.DECORATORS.API_MODEL_PROPERTIES_ARRAY, target) || [];
+        const key = `:${propertyKey}`;
+        if (!properties.includes(key)) {
+            Reflect.defineMetadata(api_property_decorator_1.DECORATORS.API_MODEL_PROPERTIES_ARRAY, [...properties, `:${propertyKey}`], target);
+        }
+        const existingMetadata = Reflect.getMetadata(metakey, target, propertyKey);
+        if (existingMetadata) {
+            const newMetadata = OmitBy(metadata, isUndefined);
+            const metadataToSave = overrideExisting
+                ? {
+                    ...existingMetadata,
+                    ...newMetadata
+                }
+                : {
+                    ...newMetadata,
+                    ...existingMetadata
+                };
+            Reflect.defineMetadata(metakey, metadataToSave, target, propertyKey);
+        }
+        else {
+            const type = target?.constructor?.[type_metadata_storage_1.METADATA_FACTORY_NAME]?.()[propertyKey]?.type ??
+                Reflect.getMetadata('design:type', target, propertyKey);
+            Reflect.defineMetadata(metakey, {
+                type,
+                ...OmitBy(metadata, isUndefined)
+            }, target, propertyKey);
+        }
+    };
+}
+exports.createPropertyDecorator = createPropertyDecorator;
+function getTypeIsArrayTuple(input, isArrayFlag) {
+    if (!input) {
+        return [input, isArrayFlag];
+    }
+    if (isArrayFlag) {
+        return [input, isArrayFlag];
+    }
+    const isInputArray = Array.isArray(input);
+    const type = isInputArray ? input[0] : input;
+    return [type, isInputArray];
+}
+exports.getTypeIsArrayTuple = getTypeIsArrayTuple;

package/dist/core/Nestjs/types/decorators/directive.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Directive(sdl: string): MethodDecorator & PropertyDecorator & ClassDecorator;

package/dist/core/Nestjs/types/decorators/directive.decorator.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Directive = void 0;
+const graphql_1 = require("graphql");
+const directive_parsing_error_1 = require("../errors/directive-parsing.error");
+const lazy_metadata_storage_1 = require("../lazy-metadata.storage");
+const type_metadata_storage_1 = require("../type-metadata.storage");
+function Directive(sdl) {
+    return (target, key) => {
+        validateDirective(sdl);
+        lazy_metadata_storage_1.LazyMetadataStorage.store(() => {
+            if (key) {
+                type_metadata_storage_1.TypeMetadataStorage.addDirectivePropertyMetadata({
+                    target: target.constructor,
+                    fieldName: key,
+                    sdl
+                });
+            }
+            else {
+                type_metadata_storage_1.TypeMetadataStorage.addDirectiveMetadata({
+                    target: target,
+                    sdl
+                });
+            }
+        });
+    };
+}
+exports.Directive = Directive;
+function validateDirective(sdl) {
+    try {
+        (0, graphql_1.parse)(`type String ${sdl}`);
+    }
+    catch (err) {
+        throw new directive_parsing_error_1.DirectiveParsingError(sdl);
+    }
+}

package/dist/core/Nestjs/types/decorators/extensions.decorator.d.ts

@@ -0,0 +1 @@
+export declare function Extensions(value: Record<string, unknown>): MethodDecorator & ClassDecorator & PropertyDecorator;

package/dist/core/Nestjs/types/decorators/extensions.decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Extensions = void 0;
+const lazy_metadata_storage_1 = require("../lazy-metadata.storage");
+const type_metadata_storage_1 = require("../type-metadata.storage");
+function Extensions(value) {
+    return (target, propertyKey) => {
+        lazy_metadata_storage_1.LazyMetadataStorage.store(() => {
+            if (propertyKey) {
+                type_metadata_storage_1.TypeMetadataStorage.addExtensionsPropertyMetadata({
+                    target: target.constructor,
+                    fieldName: propertyKey,
+                    value
+                });
+            }
+            else {
+                type_metadata_storage_1.TypeMetadataStorage.addExtensionsMetadata({
+                    target: target,
+                    value
+                });
+            }
+        });
+    };
+}
+exports.Extensions = Extensions;

package/dist/core/Nestjs/types/decorators/field.decorator.d.ts

@@ -0,0 +1,15 @@
+import { Complexity } from '../interfaces/complexity.interface';
+import { FieldMiddleware } from '../interfaces/field-middleware.interface';
+import { BaseTypeOptions } from '../interfaces/base-type-options.interface';
+import { ReturnTypeFunc } from '../interfaces/return-type-func.interface';
+export interface FieldOptions extends BaseTypeOptions {
+    name?: string;
+    description?: string;
+    deprecationReason?: string;
+    complexity?: Complexity;
+    middleware?: FieldMiddleware[];
+}
+export declare function Field(): PropertyDecorator & MethodDecorator;
+export declare function Field(options: FieldOptions): PropertyDecorator & MethodDecorator;
+export declare function Field(returnTypeFunction?: ReturnTypeFunc, options?: FieldOptions): PropertyDecorator & MethodDecorator;
+export declare function addFieldMetadata(typeOrOptions?: ReturnTypeFunc | FieldOptions, fieldOptions?: FieldOptions | undefined, prototype?: Object, propertyKey?: string, descriptor?: TypedPropertyDescriptor<any>, loadEagerly?: boolean): void;

package/dist/core/Nestjs/types/decorators/field.decorator.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFieldMetadata = exports.Field = void 0;
+const lazy_metadata_storage_1 = require("../lazy-metadata.storage");
+const type_metadata_storage_1 = require("../type-metadata.storage");
+const reflection_utils_1 = require("../reflection.utils");
+const common_1 = require("../common");
+function Field(typeOrOptions, fieldOptions) {
+    return (prototype, propertyKey, descriptor) => {
+        addFieldMetadata(typeOrOptions, fieldOptions, prototype, propertyKey, descriptor);
+    };
+}
+exports.Field = Field;
+function addFieldMetadata(typeOrOptions, fieldOptions, prototype, propertyKey, descriptor, loadEagerly) {
+    const [typeFunc, options = {}] = (0, common_1.isFunction)(typeOrOptions)
+        ? [typeOrOptions, fieldOptions]
+        : [undefined, typeOrOptions];
+    const applyMetadataFn = () => {
+        const isResolver = !!descriptor;
+        const isResolverMethod = !!(descriptor && descriptor.value);
+        const { typeFn: getType, options: typeOptions } = (0, reflection_utils_1.reflectTypeFromMetadata)({
+            metadataKey: isResolverMethod ? 'design:returntype' : 'design:type',
+            prototype,
+            propertyKey: propertyKey || '',
+            explicitTypeFn: typeFunc,
+            typeOptions: options
+        });
+        type_metadata_storage_1.TypeMetadataStorage.addClassFieldMetadata({
+            name: propertyKey || '',
+            schemaName: options.name || propertyKey,
+            typeFn: getType,
+            options: typeOptions,
+            target: prototype?.constructor,
+            description: options.description,
+            deprecationReason: options.deprecationReason,
+            complexity: options.complexity,
+            middleware: options.middleware
+        });
+        if (isResolver) {
+            type_metadata_storage_1.TypeMetadataStorage.addResolverPropertyMetadata({
+                kind: 'internal',
+                methodName: propertyKey || '',
+                schemaName: options.name || propertyKey,
+                target: prototype?.constructor,
+                complexity: options.complexity
+            });
+        }
+    };
+    if (loadEagerly) {
+        applyMetadataFn();
+    }
+    else {
+        lazy_metadata_storage_1.LazyMetadataStorage.store(prototype?.constructor, applyMetadataFn, { isField: true });
+    }
+}
+exports.addFieldMetadata = addFieldMetadata;

package/dist/core/Nestjs/types/decorators/input-type.decorator.d.ts

@@ -0,0 +1,7 @@
+export interface InputTypeOptions {
+    description?: string;
+    isAbstract?: boolean;
+}
+export declare function InputType(): ClassDecorator;
+export declare function InputType(options: InputTypeOptions): ClassDecorator;
+export declare function InputType(name: string, options?: InputTypeOptions): ClassDecorator;

package/dist/core/Nestjs/types/decorators/input-type.decorator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputType = void 0;
+const common_1 = require("../common");
+const lazy_metadata_storage_1 = require("../lazy-metadata.storage");
+const type_metadata_storage_1 = require("../type-metadata.storage");
+const add_class_type_metadata_util_1 = require("../interfaces/add-class-type-metadata.util");
+function InputType(nameOrOptions, inputTypeOptions) {
+    const [name, options = {}] = (0, common_1.isString)(nameOrOptions)
+        ? [nameOrOptions, inputTypeOptions]
+        : [undefined, nameOrOptions];
+    return target => {
+        const metadata = {
+            target,
+            name: name || target.name,
+            description: options.description,
+            isAbstract: options.isAbstract
+        };
+        lazy_metadata_storage_1.LazyMetadataStorage.store(() => type_metadata_storage_1.TypeMetadataStorage.addInputTypeMetadata(metadata));
+        (0, add_class_type_metadata_util_1.addClassTypeMetadata)(target, common_1.ClassType.INPUT);
+    };
+}
+exports.InputType = InputType;

package/dist/core/Nestjs/types/decorators/interface-type.decorator.d.ts

@@ -0,0 +1,9 @@
+import { ResolveTypeFn } from '../interfaces/resolve-type-fn.interface';
+export interface InterfaceTypeOptions {
+    description?: string;
+    isAbstract?: boolean;
+    resolveType?: ResolveTypeFn<any, any>;
+    implements?: Function | Function[] | (() => Function | Function[]);
+}
+export declare function InterfaceType(options?: InterfaceTypeOptions): ClassDecorator;
+export declare function InterfaceType(name: string, options?: InterfaceTypeOptions): ClassDecorator;

package/dist/core/Nestjs/types/decorators/interface-type.decorator.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceType = void 0;
+const common_1 = require("../common");
+const lazy_metadata_storage_1 = require("../lazy-metadata.storage");
+const type_metadata_storage_1 = require("../type-metadata.storage");
+const add_class_type_metadata_util_1 = require("../interfaces/add-class-type-metadata.util");
+function InterfaceType(nameOrOptions, interfaceOptions) {
+    const [name, options = {}] = (0, common_1.isString)(nameOrOptions)
+        ? [nameOrOptions, interfaceOptions]
+        : [undefined, nameOrOptions];
+    return target => {
+        const addInterfaceMetadata = () => {
+            const metadata = {
+                name: name || target.name,
+                target,
+                ...options,
+                interfaces: options.implements
+            };
+            type_metadata_storage_1.TypeMetadataStorage.addInterfaceMetadata(metadata);
+        };
+        addInterfaceMetadata();
+        lazy_metadata_storage_1.LazyMetadataStorage.store(() => addInterfaceMetadata());
+        (0, add_class_type_metadata_util_1.addClassTypeMetadata)(target, common_1.ClassType.INTERFACE);
+    };
+}
+exports.InterfaceType = InterfaceType;

package/dist/core/Nestjs/types/decorators/partial-type.helper.d.ts

@@ -0,0 +1,3 @@
+import { Type } from '../common';
+import { ClassDecoratorFactory } from '../interfaces/class-decorator-factory.interface';
+export declare function PartialType<T>(classRef: Type<T>, decorator?: ClassDecoratorFactory): Type<Partial<T>>;

package/dist/core/Nestjs/types/decorators/partial-type.helper.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PartialType = void 0;
+const common_1 = require("../common");
+const field_decorator_1 = require("./field.decorator");
+const type_metadata_storage_1 = require("../type-metadata.storage");
+const get_fields_and_decorator_util_1 = require("../utils/get-fields-and-decorator.util");
+const type_helpers_utils_1 = require("../utils/type-helpers.utils");
+const apply_is_optional_decorator_1 = require("./apply-is-optional.decorator");
+function PartialType(classRef, decorator) {
+    const { fields, decoratorFactory } = (0, get_fields_and_decorator_util_1.getFieldsAndDecoratorForType)(classRef);
+    class PartialObjectType {
+        constructor() {
+            (0, apply_is_optional_decorator_1.inheritPropertyInitializers)(this, classRef);
+        }
+    }
+    if (decorator) {
+        decorator({ isAbstract: true })(PartialObjectType);
+    }
+    else {
+        decoratorFactory({ isAbstract: true })(PartialObjectType);
+    }
+    (0, apply_is_optional_decorator_1.inheritValidationMetadata)(classRef, PartialObjectType);
+    (0, apply_is_optional_decorator_1.inheritTransformationMetadata)(classRef, PartialObjectType);
+    fields.forEach(item => {
+        if ((0, common_1.isFunction)(item.typeFn)) {
+            item.typeFn();
+        }
+        (0, field_decorator_1.Field)(item.typeFn, { ...item.options, nullable: true })(PartialObjectType.prototype, item.name);
+        (0, apply_is_optional_decorator_1.applyIsOptionalDecorator)(PartialObjectType, item.name);
+        (0, type_helpers_utils_1.applyFieldDecorators)(PartialObjectType, item);
+    });
+    if (PartialObjectType[type_metadata_storage_1.METADATA_FACTORY_NAME]) {
+        const pluginFields = Object.keys(PartialObjectType[type_metadata_storage_1.METADATA_FACTORY_NAME]());
+        pluginFields.forEach(key => (0, apply_is_optional_decorator_1.applyIsOptionalDecorator)(PartialObjectType, key));
+    }
+    Object.defineProperty(PartialObjectType, 'name', {
+        value: `Partial${classRef.name}`
+    });
+    return PartialObjectType;
+}
+exports.PartialType = PartialType;

package/dist/core/Nestjs/types/errors/cannot-determine-host-type.error.d.ts

@@ -0,0 +1,3 @@
+export declare class CannotDetermineHostTypeError extends Error {
+    constructor(externalField: string, hostType?: string);
+}

package/dist/core/Nestjs/types/errors/cannot-determine-host-type.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CannotDetermineHostTypeError = void 0;
+class CannotDetermineHostTypeError extends Error {
+    constructor(externalField, hostType) {
+        super(`Cannot determine a GraphQL host type ${hostType ? ` (${hostType}?) ` : ``}for the "${externalField}" field. Make sure your class is decorated with an appropriate decorator (e.g., @ObjectType()).`);
+    }
+}
+exports.CannotDetermineHostTypeError = CannotDetermineHostTypeError;

package/dist/core/Nestjs/types/errors/directive-parsing.error.d.ts

@@ -0,0 +1,3 @@
+export declare class DirectiveParsingError extends Error {
+    constructor(sdl: string);
+}

package/dist/core/Nestjs/types/errors/directive-parsing.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectiveParsingError = void 0;
+class DirectiveParsingError extends Error {
+    constructor(sdl) {
+        super(`Directive SDL "${sdl}" is invalid. Please, pass a valid directive definition.`);
+    }
+}
+exports.DirectiveParsingError = DirectiveParsingError;

package/dist/core/Nestjs/types/errors/unable-to-find-fields.error.d.ts

@@ -0,0 +1,3 @@
+export declare class UnableToFindFieldsError extends Error {
+    constructor(name: string);
+}

package/dist/core/Nestjs/types/errors/unable-to-find-fields.error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnableToFindFieldsError = void 0;
+class UnableToFindFieldsError extends Error {
+    constructor(name) {
+        super(`Unable to find fields for GraphQL type ${name}. Is your class annotated with an appropriate decorator?`);
+    }
+}
+exports.UnableToFindFieldsError = UnableToFindFieldsError;

package/dist/core/Nestjs/types/errors/undefined-type.error.d.ts

@@ -0,0 +1,3 @@
+export declare class UndefinedTypeError extends Error {
+    constructor(name: string, key: string, index?: number);
+}

package/dist/core/Nestjs/types/errors/undefined-type.error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedTypeError = void 0;
+const common_1 = require("../common");
+class UndefinedTypeError extends Error {
+    constructor(name, key, index) {
+        super(`Undefined type error. Make sure you are providing an explicit type for the "${key}" ${(0, common_1.isUndefined)(index) ? '' : `(parameter at index [${index}]) `}of the "${name}" class.`);
+    }
+}
+exports.UndefinedTypeError = UndefinedTypeError;

package/dist/core/Nestjs/types/interfaces/add-class-type-metadata.util.d.ts

@@ -0,0 +1,3 @@
+import { ClassType } from '../common';
+export declare const CLASS_TYPE_METADATA = "graphql:class_type";
+export declare function addClassTypeMetadata(target: Function, classType: ClassType): void;

package/dist/core/Nestjs/types/interfaces/add-class-type-metadata.util.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addClassTypeMetadata = exports.CLASS_TYPE_METADATA = void 0;
+const set_metadata_decorator_1 = require("../set-metadata.decorator");
+exports.CLASS_TYPE_METADATA = 'graphql:class_type';
+function addClassTypeMetadata(target, classType) {
+    const decoratorFactory = (0, set_metadata_decorator_1.SetMetadata)(exports.CLASS_TYPE_METADATA, classType);
+    decoratorFactory(target);
+}
+exports.addClassTypeMetadata = addClassTypeMetadata;

package/dist/core/Nestjs/types/interfaces/base-type-options.interface.d.ts

@@ -0,0 +1,5 @@
+export declare type NullableList = 'items' | 'itemsAndList';
+export interface BaseTypeOptions {
+    nullable?: boolean | NullableList;
+    defaultValue?: any;
+}

package/dist/core/Nestjs/types/interfaces/base-type-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/interfaces/class-decorator-factory.interface.d.ts

@@ -0,0 +1,5 @@
+import { ArgsType } from '../decorators/args-type.decorator';
+import { InputType } from '../decorators/input-type.decorator';
+import { InterfaceType } from '../decorators/interface-type.decorator';
+import { ObjectType } from '../object-type.decorator';
+export declare type ClassDecoratorFactory = typeof ArgsType | typeof ObjectType | typeof InterfaceType | typeof InputType;

package/dist/core/Nestjs/types/interfaces/class-decorator-factory.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/interfaces/complexity.interface.d.ts

@@ -0,0 +1,11 @@
+import { GraphQLCompositeType, GraphQLField } from 'graphql';
+export declare type ComplexityEstimatorArgs = {
+    type: GraphQLCompositeType;
+    field: GraphQLField<any, any>;
+    args: {
+        [key: string]: any;
+    };
+    childComplexity: number;
+};
+export declare type ComplexityEstimator = (options: ComplexityEstimatorArgs) => number | void;
+export declare type Complexity = ComplexityEstimator | number;

package/dist/core/Nestjs/types/interfaces/complexity.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/Nestjs/types/interfaces/field-middleware.interface.d.ts

@@ -0,0 +1,15 @@
+import { GraphQLResolveInfo } from 'graphql';
+export interface MiddlewareContext<TSource = any, TContext = {}, TArgs = {
+    [argName: string]: any;
+}> {
+    source: TSource;
+    args: TArgs;
+    context: TContext;
+    info: GraphQLResolveInfo;
+}
+export declare type NextFn<T = any> = () => Promise<T>;
+export interface FieldMiddleware<TSource = any, TContext = {}, TArgs = {
+    [argName: string]: any;
+}, TOutput = any> {
+    (ctx: MiddlewareContext<TSource, TContext, TArgs>, next: NextFn): Promise<TOutput> | TOutput;
+}

package/dist/core/Nestjs/types/interfaces/field-middleware.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });