{"version":3,"sources":["jsdelivr-header.js","/dist/schema-merging/src/merge-resolvers.js","/dist/schema-merging/src/typedefs-mergers/arguments.js","/dist/schema-merging/src/typedefs-mergers/comments.js","/dist/schema-merging/src/typedefs-mergers/directives.js","/dist/schema-merging/src/typedefs-mergers/enum-values.js","/dist/schema-merging/src/typedefs-mergers/enum.js","/dist/schema-merging/src/typedefs-mergers/utils.js","/dist/schema-merging/src/typedefs-mergers/fields.js","/dist/schema-merging/src/typedefs-mergers/input-type.js","/dist/schema-merging/src/typedefs-mergers/interface.js","/dist/schema-merging/src/typedefs-mergers/merge-named-type-array.js","/dist/schema-merging/src/typedefs-mergers/type.js","/dist/schema-merging/src/typedefs-mergers/union.js","/dist/schema-merging/src/typedefs-mergers/merge-nodes.js","/dist/schema-merging/src/typedefs-mergers/merge-typedefs.js","/dist/schema-merging/src/extensions.js","/dist/schema-merging/src/merge-schemas.js"],"names":[],"mappings":"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","file":"/npm/@graphql-toolkit/schema-merging@0.10.7/index.cjs.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/@graphql-toolkit/schema-merging@0.10.7/index.cjs.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","import * as deepMerge from 'deepmerge';\nimport { isScalarType } from 'graphql';\nconst isMergeableObject = (target) => {\n    if (!target) {\n        return false;\n    }\n    if (typeof target !== 'object') {\n        return false;\n    }\n    const stringValue = Object.prototype.toString.call(target);\n    if (stringValue === '[object RegExp]') {\n        return false;\n    }\n    if (stringValue === '[object Date]') {\n        return false;\n    }\n    if (isScalarType(target)) {\n        return false;\n    }\n    return true;\n};\nexport function mergeResolvers(resolversDefinitions, options) {\n    if (!resolversDefinitions || resolversDefinitions.length === 0) {\n        return {};\n    }\n    if (resolversDefinitions.length === 1) {\n        return resolversDefinitions[0];\n    }\n    const resolversFactories = new Array();\n    const resolvers = new Array();\n    for (const resolversDefinition of resolversDefinitions) {\n        if (typeof resolversDefinition === 'function') {\n            resolversFactories.push(resolversDefinition);\n        }\n        else if (typeof resolversDefinition === 'object') {\n            resolvers.push(resolversDefinition);\n        }\n    }\n    let result = {};\n    if (resolversFactories.length) {\n        result = ((...args) => {\n            const resultsOfFactories = resolversFactories.map((factory) => factory(...args));\n            return deepMerge.all([...resolvers, ...resultsOfFactories], { isMergeableObject });\n        });\n    }\n    else {\n        result = deepMerge.all(resolvers, { isMergeableObject });\n    }\n    if (options && options.exclusions) {\n        for (const exclusion of options.exclusions) {\n            const [typeName, fieldName] = exclusion.split('.');\n            if (!fieldName || fieldName === '*') {\n                delete result[typeName];\n            }\n            else if (result[typeName]) {\n                delete result[typeName][fieldName];\n            }\n        }\n    }\n    return result;\n}\n//# sourceMappingURL=merge-resolvers.js.map","import { compareNodes } from '@graphql-toolkit/common';\nexport function mergeArguments(args1, args2, config) {\n    const result = deduplicateArguments([].concat(args2, args1).filter(a => a));\n    if (config && config.sort) {\n        result.sort(compareNodes);\n    }\n    return result;\n}\nfunction deduplicateArguments(args) {\n    return args.reduce((acc, current) => {\n        const dup = acc.find(arg => arg.name.value === current.name.value);\n        if (!dup) {\n            return acc.concat([current]);\n        }\n        return acc;\n    }, []);\n}\n//# sourceMappingURL=arguments.js.map","import { getDescription, visit, } from 'graphql';\nlet commentsRegistry = {};\nexport function resetComments() {\n    commentsRegistry = {};\n}\nexport function collectComment(node) {\n    const entityName = node.name.value;\n    pushComment(node, entityName);\n    switch (node.kind) {\n        case 'EnumTypeDefinition':\n            node.values.forEach((value) => {\n                pushComment(value, entityName, value.name.value);\n            });\n            break;\n        case 'ObjectTypeDefinition':\n        case 'InputObjectTypeDefinition':\n        case 'InterfaceTypeDefinition':\n            if (node.fields) {\n                node.fields.forEach((field) => {\n                    pushComment(field, entityName, field.name.value);\n                    if (isFieldDefinitionNode(field) && field.arguments) {\n                        field.arguments.forEach((arg) => {\n                            pushComment(arg, entityName, field.name.value, arg.name.value);\n                        });\n                    }\n                });\n            }\n            break;\n    }\n}\nexport function pushComment(node, entity, field, argument) {\n    const comment = getDescription(node, { commentDescriptions: true });\n    if (typeof comment !== 'string' || comment.length === 0) {\n        return;\n    }\n    const keys = [entity];\n    if (field) {\n        keys.push(field);\n        if (argument) {\n            keys.push(argument);\n        }\n    }\n    const path = keys.join('.');\n    if (!commentsRegistry[path]) {\n        commentsRegistry[path] = [];\n    }\n    commentsRegistry[path].push(comment);\n}\nexport function printComment(comment) {\n    return '\\n# ' + comment.replace(/\\n/g, '\\n# ');\n}\n/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n/**\n * NOTE: ==> This file has been modified just to add comments to the printed AST\n * This is a temp measure, we will move to using the original non modified printer.js ASAP.\n */\n// import { visit, VisitFn } from 'graphql/language/visitor';\n/**\n * Given maybeArray, print an empty string if it is null or empty, otherwise\n * print all items together separated by separator if provided\n */\nfunction join(maybeArray, separator) {\n    return maybeArray ? maybeArray.filter((x) => x).join(separator || '') : '';\n}\nfunction addDescription(cb) {\n    return (node, _key, _parent, path, ancestors) => {\n        const keys = [];\n        const parent = path.reduce((prev, key) => {\n            if (['fields', 'arguments', 'values'].includes(key)) {\n                keys.push(prev.name.value);\n            }\n            return prev[key];\n        }, ancestors[0]);\n        const key = [...keys, parent.name.value].join('.');\n        const items = [];\n        if (commentsRegistry[key]) {\n            items.push(...commentsRegistry[key]);\n        }\n        return join([...items.map(printComment), node.description, cb(node)], '\\n');\n    };\n}\nfunction indent(maybeString) {\n    return maybeString && `  ${maybeString.replace(/\\n/g, '\\n  ')}`;\n}\n/**\n * Given array, print each item on its own line, wrapped in an\n * indented \"{ }\" block.\n */\nfunction block(array) {\n    return array && array.length !== 0 ? `{\\n${indent(join(array, '\\n'))}\\n}` : '';\n}\n/**\n * If maybeString is not null or empty, then wrap with start and end, otherwise\n * print an empty string.\n */\nfunction wrap(start, maybeString, end) {\n    return maybeString ? start + maybeString + (end || '') : '';\n}\n/**\n * Print a block string in the indented block form by adding a leading and\n * trailing blank line. However, if a block string starts with whitespace and is\n * a single-line, adding a leading blank line would strip that whitespace.\n */\nfunction printBlockString(value, isDescription) {\n    const escaped = value.replace(/\"\"\"/g, '\\\\\"\"\"');\n    return (value[0] === ' ' || value[0] === '\\t') && value.indexOf('\\n') === -1\n        ? `\"\"\"${escaped.replace(/\"$/, '\"\\n')}\"\"\"`\n        : `\"\"\"\\n${isDescription ? escaped : indent(escaped)}\\n\"\"\"`;\n}\n/**\n * Converts an AST into a string, using one set of reasonable\n * formatting rules.\n */\nexport function printWithComments(ast) {\n    return visit(ast, {\n        leave: {\n            Name: (node) => node.value,\n            Variable: (node) => `$${node.name}`,\n            // Document\n            Document: (node) => `${node.definitions\n                .map((defNode) => `${defNode}\\n${defNode[0] === '#' ? '' : '\\n'}`)\n                .join('')\n                .trim()}\\n`,\n            OperationTypeDefinition: (node) => `${node.operation}: ${node.type}`,\n            VariableDefinition: ({ variable, type, defaultValue }) => `${variable}: ${type}${wrap(' = ', defaultValue)}`,\n            SelectionSet: ({ selections }) => block(selections),\n            Field: ({ alias, name, arguments: args, directives, selectionSet }) => join([wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet], '  '),\n            Argument: addDescription(({ name, value }) => `${name}: ${value}`),\n            // Value\n            IntValue: ({ value }) => value,\n            FloatValue: ({ value }) => value,\n            StringValue: ({ value, block: isBlockString }, key) => isBlockString ? printBlockString(value, key === 'description') : JSON.stringify(value),\n            BooleanValue: ({ value }) => (value ? 'true' : 'false'),\n            NullValue: () => 'null',\n            EnumValue: ({ value }) => value,\n            ListValue: ({ values }) => `[${join(values, ', ')}]`,\n            ObjectValue: ({ fields }) => `{${join(fields, ', ')}}`,\n            ObjectField: ({ name, value }) => `${name}: ${value}`,\n            // Directive\n            Directive: ({ name, arguments: args }) => `@${name}${wrap('(', join(args, ', '), ')')}`,\n            // Type\n            NamedType: ({ name }) => name,\n            ListType: ({ type }) => `[${type}]`,\n            NonNullType: ({ type }) => `${type}!`,\n            // Type System Definitions\n            SchemaDefinition: ({ directives, operationTypes }) => join(['schema', join(directives, ' '), block(operationTypes)], ' '),\n            ScalarTypeDefinition: addDescription(({ name, directives }) => join(['scalar', name, join(directives, ' ')], ' ')),\n            ObjectTypeDefinition: addDescription(({ name, interfaces, directives, fields }) => join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ')),\n            FieldDefinition: addDescription(({ name, arguments: args, type, directives }) => `${name + wrap('(', join(args, ', '), ')')}: ${type}${wrap(' ', join(directives, ' '))}`),\n            InputValueDefinition: addDescription(({ name, type, defaultValue, directives }) => join([`${name}: ${type}`, wrap('= ', defaultValue), join(directives, ' ')], ' ')),\n            InterfaceTypeDefinition: addDescription(({ name, directives, fields }) => join(['interface', name, join(directives, ' '), block(fields)], ' ')),\n            UnionTypeDefinition: addDescription(({ name, directives, types }) => join(['union', name, join(directives, ' '), types && types.length !== 0 ? `= ${join(types, ' | ')}` : ''], ' ')),\n            EnumTypeDefinition: addDescription(({ name, directives, values }) => join(['enum', name, join(directives, ' '), block(values)], ' ')),\n            EnumValueDefinition: addDescription(({ name, directives }) => join([name, join(directives, ' ')], ' ')),\n            InputObjectTypeDefinition: addDescription(({ name, directives, fields }) => join(['input', name, join(directives, ' '), block(fields)], ' ')),\n            ScalarTypeExtension: ({ name, directives }) => join(['extend scalar', name, join(directives, ' ')], ' '),\n            ObjectTypeExtension: ({ name, interfaces, directives, fields }) => join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' '),\n            InterfaceTypeExtension: ({ name, directives, fields }) => join(['extend interface', name, join(directives, ' '), block(fields)], ' '),\n            UnionTypeExtension: ({ name, directives, types }) => join(['extend union', name, join(directives, ' '), types && types.length !== 0 ? `= ${join(types, ' | ')}` : ''], ' '),\n            EnumTypeExtension: ({ name, directives, values }) => join(['extend enum', name, join(directives, ' '), block(values)], ' '),\n            InputObjectTypeExtension: ({ name, directives, fields }) => join(['extend input', name, join(directives, ' '), block(fields)], ' '),\n            DirectiveDefinition: addDescription(({ name, arguments: args, locations }) => `directive @${name}${wrap('(', join(args, ', '), ')')} on ${join(locations, ' | ')}`),\n        },\n    });\n}\nfunction isFieldDefinitionNode(node) {\n    return node.kind === 'FieldDefinition';\n}\n//# sourceMappingURL=comments.js.map","import { print } from 'graphql';\nfunction directiveAlreadyExists(directivesArr, otherDirective) {\n    return !!directivesArr.find(directive => directive.name.value === otherDirective.name.value);\n}\nfunction nameAlreadyExists(name, namesArr) {\n    return namesArr.some(({ value }) => value === name.value);\n}\nfunction mergeArguments(a1, a2) {\n    const result = [...a2];\n    for (const argument of a1) {\n        const existingIndex = result.findIndex(a => a.name.value === argument.name.value);\n        if (existingIndex > -1) {\n            const existingArg = result[existingIndex];\n            if (existingArg.value.kind === 'ListValue') {\n                const source = existingArg.value.values;\n                const target = argument.value.values;\n                // merge values of two lists\n                existingArg.value.values = deduplicateLists(source, target, (targetVal, source) => {\n                    const value = targetVal.value;\n                    return !value || !source.some((sourceVal) => sourceVal.value === value);\n                });\n            }\n            else {\n                existingArg.value = argument.value;\n            }\n        }\n        else {\n            result.push(argument);\n        }\n    }\n    return result;\n}\nfunction deduplicateDirectives(directives) {\n    return directives\n        .map((directive, i, all) => {\n        const firstAt = all.findIndex(d => d.name.value === directive.name.value);\n        if (firstAt !== i) {\n            const dup = all[firstAt];\n            directive.arguments = mergeArguments(directive.arguments, dup.arguments);\n            return null;\n        }\n        return directive;\n    })\n        .filter(d => d);\n}\nexport function mergeDirectives(d1, d2, config) {\n    const reverseOrder = config && config.reverseDirectives;\n    const asNext = reverseOrder ? d1 : d2;\n    const asFirst = reverseOrder ? d2 : d1;\n    const result = deduplicateDirectives([...asNext]);\n    for (const directive of asFirst) {\n        if (directiveAlreadyExists(result, directive)) {\n            const existingDirectiveIndex = result.findIndex(d => d.name.value === directive.name.value);\n            const existingDirective = result[existingDirectiveIndex];\n            result[existingDirectiveIndex].arguments = mergeArguments(directive.arguments, existingDirective.arguments);\n        }\n        else {\n            result.push(directive);\n        }\n    }\n    return result;\n}\nfunction validateInputs(node, existingNode) {\n    const printedNode = print(node);\n    const printedExistingNode = print(existingNode);\n    const leaveInputs = new RegExp('(directive @w*d*)|( on .*$)', 'g');\n    const sameArguments = printedNode.replace(leaveInputs, '') === printedExistingNode.replace(leaveInputs, '');\n    if (!sameArguments) {\n        throw new Error(`Unable to merge GraphQL directive \"${node.name.value}\". \\nExisting directive:  \\n\\t${printedExistingNode} \\nReceived directive: \\n\\t${printedNode}`);\n    }\n}\nexport function mergeDirective(node, existingNode) {\n    if (existingNode) {\n        validateInputs(node, existingNode);\n        return {\n            ...node,\n            locations: [\n                ...existingNode.locations,\n                ...node.locations.filter(name => !nameAlreadyExists(name, existingNode.locations)),\n            ],\n        };\n    }\n    return node;\n}\nfunction deduplicateLists(source, target, filterFn) {\n    return source.concat(target.filter(val => filterFn(val, source)));\n}\n//# sourceMappingURL=directives.js.map","import { mergeDirectives } from './directives';\nimport { compareNodes } from '@graphql-toolkit/common';\nexport function mergeEnumValues(first, second, config) {\n    const enumValueMap = new Map();\n    for (const firstValue of first) {\n        enumValueMap.set(firstValue.name.value, firstValue);\n    }\n    for (const secondValue of second) {\n        const enumValue = secondValue.name.value;\n        if (enumValueMap.has(enumValue)) {\n            const firstValue = enumValueMap.get(enumValue);\n            firstValue.description = secondValue.description || firstValue.description;\n            firstValue.directives = mergeDirectives(secondValue.directives, firstValue.directives);\n        }\n        else {\n            enumValueMap.set(enumValue, secondValue);\n        }\n    }\n    const result = [...enumValueMap.values()];\n    if (config && config.sort) {\n        result.sort(compareNodes);\n    }\n    return result;\n}\n//# sourceMappingURL=enum-values.js.map","import { mergeDirectives } from './directives';\nimport { mergeEnumValues } from './enum-values';\nexport function mergeEnum(e1, e2, config) {\n    if (e2) {\n        return {\n            name: e1.name,\n            description: e1['description'] || e2['description'],\n            kind: (config && config.convertExtensions) || e1.kind === 'EnumTypeDefinition' || e2.kind === 'EnumTypeDefinition'\n                ? 'EnumTypeDefinition'\n                : 'EnumTypeExtension',\n            loc: e1.loc,\n            directives: mergeDirectives(e1.directives, e2.directives, config),\n            values: mergeEnumValues(e1.values, e2.values, config),\n        };\n    }\n    return config && config.convertExtensions\n        ? {\n            ...e1,\n            kind: 'EnumTypeDefinition',\n        }\n        : e1;\n}\n//# sourceMappingURL=enum.js.map","import { Source, Kind, } from 'graphql';\nexport function isStringTypes(types) {\n    return typeof types === 'string';\n}\nexport function isSourceTypes(types) {\n    return types instanceof Source;\n}\nexport function isGraphQLType(definition) {\n    return definition.kind === 'ObjectTypeDefinition';\n}\nexport function isGraphQLTypeExtension(definition) {\n    return definition.kind === 'ObjectTypeExtension';\n}\nexport function isGraphQLEnum(definition) {\n    return definition.kind === 'EnumTypeDefinition';\n}\nexport function isGraphQLEnumExtension(definition) {\n    return definition.kind === 'EnumTypeExtension';\n}\nexport function isGraphQLUnion(definition) {\n    return definition.kind === 'UnionTypeDefinition';\n}\nexport function isGraphQLUnionExtension(definition) {\n    return definition.kind === 'UnionTypeExtension';\n}\nexport function isGraphQLScalar(definition) {\n    return definition.kind === 'ScalarTypeDefinition';\n}\nexport function isGraphQLScalarExtension(definition) {\n    return definition.kind === 'ScalarTypeExtension';\n}\nexport function isGraphQLInputType(definition) {\n    return definition.kind === 'InputObjectTypeDefinition';\n}\nexport function isGraphQLInputTypeExtension(definition) {\n    return definition.kind === 'InputObjectTypeExtension';\n}\nexport function isGraphQLInterface(definition) {\n    return definition.kind === 'InterfaceTypeDefinition';\n}\nexport function isGraphQLInterfaceExtension(definition) {\n    return definition.kind === 'InterfaceTypeExtension';\n}\nexport function isGraphQLDirective(definition) {\n    return definition.kind === 'DirectiveDefinition';\n}\nexport function extractType(type) {\n    let visitedType = type;\n    while (visitedType.kind === 'ListType' || visitedType.kind === 'NonNullType') {\n        visitedType = visitedType.type;\n    }\n    return visitedType;\n}\nexport function isSchemaDefinition(node) {\n    return node.kind === 'SchemaDefinition';\n}\nexport function isWrappingTypeNode(type) {\n    return type.kind !== Kind.NAMED_TYPE;\n}\nexport function isListTypeNode(type) {\n    return type.kind === Kind.LIST_TYPE;\n}\nexport function isNonNullTypeNode(type) {\n    return type.kind === Kind.NON_NULL_TYPE;\n}\nexport function printTypeNode(type) {\n    if (isListTypeNode(type)) {\n        return `[${printTypeNode(type.type)}]`;\n    }\n    if (isNonNullTypeNode(type)) {\n        return `${printTypeNode(type.type)}!`;\n    }\n    return type.name.value;\n}\n//# sourceMappingURL=utils.js.map","import { extractType, isWrappingTypeNode, isListTypeNode, isNonNullTypeNode, printTypeNode } from './utils';\nimport { mergeDirectives } from './directives';\nimport { isNotEqual, compareNodes } from '@graphql-toolkit/common';\nimport { mergeArguments } from './arguments';\nfunction fieldAlreadyExists(fieldsArr, otherField) {\n    const result = fieldsArr.find(field => field.name.value === otherField.name.value);\n    if (result) {\n        const t1 = extractType(result.type);\n        const t2 = extractType(otherField.type);\n        if (t1.name.value !== t2.name.value) {\n            throw new Error(`Field \"${otherField.name.value}\" already defined with a different type. Declared as \"${t1.name.value}\", but you tried to override with \"${t2.name.value}\"`);\n        }\n    }\n    return !!result;\n}\nexport function mergeFields(type, f1, f2, config) {\n    const result = [...f2];\n    for (const field of f1) {\n        if (fieldAlreadyExists(result, field)) {\n            const existing = result.find((f) => f.name.value === field.name.value);\n            if (config && config.throwOnConflict) {\n                preventConflicts(type, existing, field, false);\n            }\n            else {\n                preventConflicts(type, existing, field, true);\n            }\n            if (isNonNullTypeNode(field.type) && !isNonNullTypeNode(existing.type)) {\n                existing.type = field.type;\n            }\n            existing['arguments'] = mergeArguments(field['arguments'], existing['arguments'], config);\n            existing['directives'] = mergeDirectives(field['directives'], existing['directives'], config);\n            existing['description'] = field['description'] || existing['description'];\n        }\n        else {\n            result.push(field);\n        }\n    }\n    if (config && config.sort) {\n        result.sort(compareNodes);\n    }\n    if (config && config.exclusions) {\n        return result.filter(field => !config.exclusions.includes(`${type.name.value}.${field.name.value}`));\n    }\n    return result;\n}\nfunction preventConflicts(type, a, b, ignoreNullability = false) {\n    const aType = printTypeNode(a.type);\n    const bType = printTypeNode(b.type);\n    if (isNotEqual(aType, bType)) {\n        if (safeChangeForFieldType(a.type, b.type, ignoreNullability) === false) {\n            throw new Error(`Field '${type.name.value}.${a.name.value}' changed type from '${aType}' to '${bType}'`);\n        }\n    }\n}\nfunction safeChangeForFieldType(oldType, newType, ignoreNullability = false) {\n    // both are named\n    if (!isWrappingTypeNode(oldType) && !isWrappingTypeNode(newType)) {\n        return oldType.toString() === newType.toString();\n    }\n    // new is non-null\n    if (isNonNullTypeNode(newType)) {\n        const ofType = isNonNullTypeNode(oldType) ? oldType.type : oldType;\n        return safeChangeForFieldType(ofType, newType.type);\n    }\n    // old is non-null\n    if (isNonNullTypeNode(oldType)) {\n        return safeChangeForFieldType(newType, oldType, ignoreNullability);\n    }\n    // old is list\n    if (isListTypeNode(oldType)) {\n        return ((isListTypeNode(newType) && safeChangeForFieldType(oldType.type, newType.type)) ||\n            (isNonNullTypeNode(newType) && safeChangeForFieldType(oldType, newType.type)));\n    }\n    return false;\n}\n//# sourceMappingURL=fields.js.map","import { mergeFields } from './fields';\nimport { mergeDirectives } from './directives';\nexport function mergeInputType(node, existingNode, config) {\n    if (existingNode) {\n        try {\n            return {\n                name: node.name,\n                description: node['description'] || existingNode['description'],\n                kind: (config && config.convertExtensions) ||\n                    node.kind === 'InputObjectTypeDefinition' ||\n                    existingNode.kind === 'InputObjectTypeDefinition'\n                    ? 'InputObjectTypeDefinition'\n                    : 'InputObjectTypeExtension',\n                loc: node.loc,\n                fields: mergeFields(node, node.fields, existingNode.fields, config),\n                directives: mergeDirectives(node.directives, existingNode.directives, config),\n            };\n        }\n        catch (e) {\n            throw new Error(`Unable to merge GraphQL input type \"${node.name.value}\": ${e.message}`);\n        }\n    }\n    return config && config.convertExtensions\n        ? {\n            ...node,\n            kind: 'InputObjectTypeDefinition',\n        }\n        : node;\n}\n//# sourceMappingURL=input-type.js.map","import { mergeFields } from './fields';\nimport { mergeDirectives } from './directives';\nexport function mergeInterface(node, existingNode, config) {\n    if (existingNode) {\n        try {\n            return {\n                name: node.name,\n                description: node['description'] || existingNode['description'],\n                kind: (config && config.convertExtensions) ||\n                    node.kind === 'InterfaceTypeDefinition' ||\n                    existingNode.kind === 'InterfaceTypeDefinition'\n                    ? 'InterfaceTypeDefinition'\n                    : 'InterfaceTypeExtension',\n                loc: node.loc,\n                fields: mergeFields(node, node.fields, existingNode.fields, config),\n                directives: mergeDirectives(node.directives, existingNode.directives, config),\n            };\n        }\n        catch (e) {\n            throw new Error(`Unable to merge GraphQL interface \"${node.name.value}\": ${e.message}`);\n        }\n    }\n    return config && config.convertExtensions\n        ? {\n            ...node,\n            kind: 'InterfaceTypeDefinition',\n        }\n        : node;\n}\n//# sourceMappingURL=interface.js.map","import { compareNodes } from '@graphql-toolkit/common';\nfunction alreadyExists(arr, other) {\n    return !!arr.find(i => i.name.value === other.name.value);\n}\nexport function mergeNamedTypeArray(first, second, config) {\n    const result = [...second, ...first.filter(d => !alreadyExists(second, d))];\n    if (config && config.sort) {\n        result.sort(compareNodes);\n    }\n    return result;\n}\n//# sourceMappingURL=merge-named-type-array.js.map","import { mergeFields } from './fields';\nimport { mergeDirectives } from './directives';\nimport { mergeNamedTypeArray } from './merge-named-type-array';\nexport function mergeType(node, existingNode, config) {\n    if (existingNode) {\n        try {\n            return {\n                name: node.name,\n                description: node['description'] || existingNode['description'],\n                kind: (config && config.convertExtensions) ||\n                    node.kind === 'ObjectTypeDefinition' ||\n                    existingNode.kind === 'ObjectTypeDefinition'\n                    ? 'ObjectTypeDefinition'\n                    : 'ObjectTypeExtension',\n                loc: node.loc,\n                fields: mergeFields(node, node.fields, existingNode.fields, config),\n                directives: mergeDirectives(node.directives, existingNode.directives, config),\n                interfaces: mergeNamedTypeArray(node.interfaces, existingNode.interfaces, config),\n            };\n        }\n        catch (e) {\n            throw new Error(`Unable to merge GraphQL type \"${node.name.value}\": ${e.message}`);\n        }\n    }\n    return config && config.convertExtensions\n        ? {\n            ...node,\n            kind: 'ObjectTypeDefinition',\n        }\n        : node;\n}\n//# sourceMappingURL=type.js.map","import { mergeDirectives } from './directives';\nimport { mergeNamedTypeArray } from './merge-named-type-array';\nexport function mergeUnion(first, second, config) {\n    if (second) {\n        return {\n            name: first.name,\n            description: first['description'] || second['description'],\n            directives: mergeDirectives(first.directives, second.directives, config),\n            kind: (config && config.convertExtensions) ||\n                first.kind === 'UnionTypeDefinition' ||\n                second.kind === 'UnionTypeDefinition'\n                ? 'UnionTypeDefinition'\n                : 'UnionTypeExtension',\n            loc: first.loc,\n            types: mergeNamedTypeArray(first.types, second.types, config),\n        };\n    }\n    return config && config.convertExtensions\n        ? {\n            ...first,\n            kind: 'UnionTypeDefinition',\n        }\n        : first;\n}\n//# sourceMappingURL=union.js.map","import { isGraphQLEnum, isGraphQLInputType, isGraphQLInterface, isGraphQLScalar, isGraphQLType, isGraphQLUnion, isGraphQLDirective, isGraphQLTypeExtension, isGraphQLInputTypeExtension, isGraphQLEnumExtension, isGraphQLUnionExtension, isGraphQLScalarExtension, isGraphQLInterfaceExtension, } from './utils';\nimport { mergeType } from './type';\nimport { mergeEnum } from './enum';\nimport { mergeUnion } from './union';\nimport { mergeInputType } from './input-type';\nimport { mergeInterface } from './interface';\nimport { mergeDirective } from './directives';\nimport { collectComment } from './comments';\nexport function mergeGraphQLNodes(nodes, config) {\n    return nodes.reduce((prev, nodeDefinition) => {\n        const node = nodeDefinition;\n        if (node && node.name && node.name.value) {\n            const name = node.name.value;\n            if (config && config.commentDescriptions) {\n                collectComment(node);\n            }\n            if (config &&\n                config.exclusions &&\n                (config.exclusions.includes(name + '.*') || config.exclusions.includes(name))) {\n                delete prev[name];\n            }\n            else if (isGraphQLType(nodeDefinition) || isGraphQLTypeExtension(nodeDefinition)) {\n                prev[name] = mergeType(nodeDefinition, prev[name], config);\n            }\n            else if (isGraphQLEnum(nodeDefinition) || isGraphQLEnumExtension(nodeDefinition)) {\n                prev[name] = mergeEnum(nodeDefinition, prev[name], config);\n            }\n            else if (isGraphQLUnion(nodeDefinition) || isGraphQLUnionExtension(nodeDefinition)) {\n                prev[name] = mergeUnion(nodeDefinition, prev[name], config);\n            }\n            else if (isGraphQLScalar(nodeDefinition) || isGraphQLScalarExtension(nodeDefinition)) {\n                prev[name] = nodeDefinition;\n            }\n            else if (isGraphQLInputType(nodeDefinition) || isGraphQLInputTypeExtension(nodeDefinition)) {\n                prev[name] = mergeInputType(nodeDefinition, prev[name], config);\n            }\n            else if (isGraphQLInterface(nodeDefinition) || isGraphQLInterfaceExtension(nodeDefinition)) {\n                prev[name] = mergeInterface(nodeDefinition, prev[name], config);\n            }\n            else if (isGraphQLDirective(nodeDefinition)) {\n                prev[name] = mergeDirective(nodeDefinition, prev[name]);\n            }\n        }\n        return prev;\n    }, {});\n}\n//# sourceMappingURL=merge-nodes.js.map","import { parse, Kind, isSchema } from 'graphql';\nimport { isSourceTypes, isStringTypes, isSchemaDefinition } from './utils';\nimport { mergeGraphQLNodes } from './merge-nodes';\nimport { resetComments, printWithComments } from './comments';\nimport { createSchemaDefinition, printSchemaWithDirectives } from '@graphql-toolkit/common';\nexport function mergeGraphQLSchemas(types, config) {\n    // tslint:disable-next-line: no-console\n    console.info(`\n    GraphQL Toolkit/Epoxy \n    Deprecation Notice;\n    'mergeGraphQLSchemas' is deprecated and will be removed in the next version.\n    Please use 'mergeTypeDefs' instead!\n  `);\n    return mergeGraphQLTypes(types, config);\n}\nexport function mergeTypeDefs(types, config) {\n    resetComments();\n    const doc = {\n        kind: Kind.DOCUMENT,\n        definitions: mergeGraphQLTypes(types, {\n            useSchemaDefinition: true,\n            forceSchemaDefinition: false,\n            throwOnConflict: false,\n            commentDescriptions: false,\n            ...config,\n        }),\n    };\n    let result;\n    if (config && config.commentDescriptions) {\n        result = printWithComments(doc);\n    }\n    else {\n        result = doc;\n    }\n    resetComments();\n    return result;\n}\nexport function mergeGraphQLTypes(types, config) {\n    resetComments();\n    const allNodes = types\n        .map((type) => {\n        if (isSchema(type)) {\n            return parse(printSchemaWithDirectives(type));\n        }\n        else if (isStringTypes(type) || isSourceTypes(type)) {\n            return parse(type);\n        }\n        return type;\n    })\n        .map((ast) => ast.definitions)\n        .reduce((defs, newDef = []) => [...defs, ...newDef], []);\n    // XXX: right now we don't handle multiple schema definitions\n    let schemaDef = allNodes.filter(isSchemaDefinition).reduce((def, node) => {\n        node.operationTypes\n            .filter((op) => op.type.name.value)\n            .forEach((op) => {\n            def[op.operation] = op.type.name.value;\n        });\n        return def;\n    }, {\n        query: null,\n        mutation: null,\n        subscription: null,\n    });\n    const mergedNodes = mergeGraphQLNodes(allNodes, config);\n    const allTypes = Object.keys(mergedNodes);\n    if (config && config.sort) {\n        allTypes.sort(typeof config.sort === 'function' ? config.sort : undefined);\n    }\n    if (config && config.useSchemaDefinition) {\n        const queryType = schemaDef.query ? schemaDef.query : allTypes.find((t) => t === 'Query');\n        const mutationType = schemaDef.mutation ? schemaDef.mutation : allTypes.find((t) => t === 'Mutation');\n        const subscriptionType = schemaDef.subscription\n            ? schemaDef.subscription\n            : allTypes.find((t) => t === 'Subscription');\n        schemaDef = {\n            query: queryType,\n            mutation: mutationType,\n            subscription: subscriptionType,\n        };\n    }\n    const schemaDefinition = createSchemaDefinition(schemaDef, {\n        force: config.forceSchemaDefinition,\n    });\n    if (!schemaDefinition) {\n        return Object.values(mergedNodes);\n    }\n    return [...Object.values(mergedNodes), parse(schemaDefinition).definitions[0]];\n}\n//# sourceMappingURL=merge-typedefs.js.map","import { isObjectType, isInterfaceType, isInputObjectType, isUnionType, isScalarType, isEnumType, isSpecifiedScalarType, isIntrospectionType, } from 'graphql';\nimport * as deepMerge from 'deepmerge';\nexport function travelSchemaPossibleExtensions(schema, hooks) {\n    hooks.onSchema(schema);\n    const typesMap = schema.getTypeMap();\n    for (const [, type] of Object.entries(typesMap)) {\n        const isPredefinedScalar = isScalarType(type) && isSpecifiedScalarType(type);\n        const isIntrospection = isIntrospectionType(type);\n        if (isPredefinedScalar || isIntrospection) {\n            continue;\n        }\n        if (isObjectType(type)) {\n            hooks.onObjectType(type);\n            const fields = type.getFields();\n            for (const [, field] of Object.entries(fields)) {\n                hooks.onObjectField(type, field);\n                const args = field.args || [];\n                for (const arg of args) {\n                    hooks.onObjectFieldArg(type, field, arg);\n                }\n            }\n        }\n        else if (isInterfaceType(type)) {\n            hooks.onInterface(type);\n            const fields = type.getFields();\n            for (const [, field] of Object.entries(fields)) {\n                hooks.onInterfaceField(type, field);\n                const args = field.args || [];\n                for (const arg of args) {\n                    hooks.onInterfaceFieldArg(type, field, arg);\n                }\n            }\n        }\n        else if (isInputObjectType(type)) {\n            hooks.onInputType(type);\n            const fields = type.getFields();\n            for (const [, field] of Object.entries(fields)) {\n                hooks.onInputFieldType(type, field);\n            }\n        }\n        else if (isUnionType(type)) {\n            hooks.onUnion(type);\n        }\n        else if (isScalarType(type)) {\n            hooks.onScalar(type);\n        }\n        else if (isEnumType(type)) {\n            hooks.onEnum(type);\n            for (const value of type.getValues()) {\n                hooks.onEnumValue(type, value);\n            }\n        }\n    }\n}\nexport function mergeExtensions(extensions) {\n    return extensions.reduce((result, extensionObj) => deepMerge.all([result, extensionObj]), {});\n}\nfunction applyExtensionObject(obj, extensions) {\n    if (!obj) {\n        return;\n    }\n    obj.extensions = deepMerge.all([obj.extensions || {}, extensions || {}]);\n}\nexport function applyExtensions(schema, extensions) {\n    applyExtensionObject(schema, extensions.schemaExtensions);\n    for (const [typeName, data] of Object.entries(extensions.types || {})) {\n        const type = schema.getType(typeName);\n        if (type) {\n            applyExtensionObject(type, data.extensions);\n            if (data.type === 'object' || data.type === 'interface') {\n                for (const [fieldName, fieldData] of Object.entries(data.fields)) {\n                    const field = type.getFields()[fieldName];\n                    if (field) {\n                        applyExtensionObject(field, fieldData.extensions);\n                        for (const [arg, argData] of Object.entries(fieldData.arguments)) {\n                            applyExtensionObject(field.args.find((a) => a.name === arg), argData);\n                        }\n                    }\n                }\n            }\n            else if (data.type === 'input') {\n                for (const [fieldName, fieldData] of Object.entries(data.fields)) {\n                    const field = type.getFields()[fieldName];\n                    applyExtensionObject(field, fieldData.extensions);\n                }\n            }\n            else if (data.type === 'enum') {\n                for (const [valueName, valueData] of Object.entries(data.values)) {\n                    const value = type.getValue(valueName);\n                    applyExtensionObject(value, valueData);\n                }\n            }\n        }\n    }\n    return schema;\n}\nexport function extractExtensionsFromSchema(schema) {\n    const result = {\n        schemaExtensions: {},\n        types: {},\n    };\n    travelSchemaPossibleExtensions(schema, {\n        onSchema: (schema) => (result.schemaExtensions = schema.extensions || {}),\n        onObjectType: (type) => (result.types[type.name] = { fields: {}, type: 'object', extensions: type.extensions || {} }),\n        onObjectField: (type, field) => (result.types[type.name].fields[field.name] = {\n            arguments: {},\n            extensions: field.extensions || {},\n        }),\n        onObjectFieldArg: (type, field, arg) => (result.types[type.name].fields[field.name].arguments[arg.name] = arg.extensions || {}),\n        onInterface: (type) => (result.types[type.name] = { fields: {}, type: 'interface', extensions: type.extensions || {} }),\n        onInterfaceField: (type, field) => (result.types[type.name].fields[field.name] = {\n            arguments: {},\n            extensions: field.extensions || {},\n        }),\n        onInterfaceFieldArg: (type, field, arg) => (result.types[type.name].fields[field.name].arguments[arg.name] =\n            arg.extensions || {}),\n        onEnum: (type) => (result.types[type.name] = { values: {}, type: 'enum', extensions: type.extensions || {} }),\n        onEnumValue: (type, value) => (result.types[type.name].values[value.name] = value.extensions || {}),\n        onScalar: (type) => (result.types[type.name] = { type: 'scalar', extensions: type.extensions || {} }),\n        onUnion: (type) => (result.types[type.name] = { type: 'union', extensions: type.extensions || {} }),\n        onInputType: (type) => (result.types[type.name] = { fields: {}, type: 'input', extensions: type.extensions || {} }),\n        onInputFieldType: (type, field) => (result.types[type.name].fields[field.name] = { extensions: field.extensions || {} }),\n    });\n    return result;\n}\n//# sourceMappingURL=extensions.js.map","import { buildASTSchema, buildSchema } from 'graphql';\nimport { SchemaDirectiveVisitor, addResolveFunctionsToSchema, addErrorLoggingToSchema, } from 'graphql-tools';\nimport { mergeTypeDefs } from './typedefs-mergers/merge-typedefs';\nimport { mergeResolvers } from './merge-resolvers';\nimport { extractResolversFromSchema, composeResolvers, asArray, } from '@graphql-toolkit/common';\nimport { mergeExtensions, extractExtensionsFromSchema, applyExtensions } from './extensions';\nconst defaultResolverValidationOptions = {\n    requireResolversForArgs: false,\n    requireResolversForNonScalar: false,\n    requireResolversForAllFields: false,\n    requireResolversForResolveType: false,\n    allowResolversNotInSchema: true,\n};\nexport function mergeSchemas(config) {\n    const typeDefs = mergeTypes(config);\n    const extractedResolvers = [];\n    const extractedExtensions = [];\n    for (const schema of config.schemas) {\n        extractedResolvers.push(extractResolversFromSchema(schema));\n        extractedExtensions.push(extractExtensionsFromSchema(schema));\n    }\n    extractedResolvers.push(...ensureResolvers(config));\n    const resolvers = composeResolvers(mergeResolvers(extractedResolvers, config), config.resolversComposition || {});\n    const extensions = mergeExtensions(extractedExtensions);\n    return makeSchema({ resolvers, typeDefs, extensions }, config);\n}\nexport async function mergeSchemasAsync(config) {\n    const [typeDefs, resolvers, extensions] = await Promise.all([\n        mergeTypes(config),\n        Promise.all(config.schemas.map(async (schema) => extractResolversFromSchema(schema))).then((extractedResolvers) => composeResolvers(mergeResolvers([...extractedResolvers, ...ensureResolvers(config)], config), config.resolversComposition || {})),\n        Promise.all(config.schemas.map(async (schema) => extractExtensionsFromSchema(schema))).then((extractedExtensions) => mergeExtensions(extractedExtensions)),\n    ]);\n    return makeSchema({ resolvers, typeDefs, extensions }, config);\n}\nfunction mergeTypes({ schemas, typeDefs, ...config }) {\n    return mergeTypeDefs([...schemas, ...(typeDefs ? asArray(typeDefs) : [])], config);\n}\nfunction ensureResolvers(config) {\n    return config.resolvers ? asArray(config.resolvers) : [];\n}\nfunction makeSchema({ resolvers, typeDefs, extensions, }, config) {\n    let schema = typeof typeDefs === 'string' ? buildSchema(typeDefs, config) : buildASTSchema(typeDefs, config);\n    // add resolvers\n    if (resolvers) {\n        addResolveFunctionsToSchema({\n            schema,\n            resolvers,\n            resolverValidationOptions: {\n                ...defaultResolverValidationOptions,\n                ...(config.resolverValidationOptions || {}),\n            },\n        });\n    }\n    // use logger\n    if (config.logger) {\n        addErrorLoggingToSchema(schema, config.logger);\n    }\n    // use schema directives\n    if (config.schemaDirectives) {\n        SchemaDirectiveVisitor.visitSchemaDirectives(schema, config.schemaDirectives);\n    }\n    // extensions\n    applyExtensions(schema, extensions);\n    return schema;\n}\n//# sourceMappingURL=merge-schemas.js.map"]}