@graphql-tools/schema 8.4.0 → 8.5.0-alpha-b76ec274.0

package/{index.js → cjs/addResolversToSchema.js}

@@ -1,115 +1,12 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const graphql = require('graphql');
-const utils = require('@graphql-tools/utils');
-const merge = require('@graphql-tools/merge');
-
-function assertResolversPresent(schema, resolverValidationOptions = {}) {
-    const { requireResolversForArgs, requireResolversForNonScalar, requireResolversForAllFields } = resolverValidationOptions;
-    if (requireResolversForAllFields && (requireResolversForArgs || requireResolversForNonScalar)) {
-        throw new TypeError('requireResolversForAllFields takes precedence over the more specific assertions. ' +
-            'Please configure either requireResolversForAllFields or requireResolversForArgs / ' +
-            'requireResolversForNonScalar, but not a combination of them.');
-    }
-    utils.forEachField(schema, (field, typeName, fieldName) => {
-        // requires a resolver for *every* field.
-        if (requireResolversForAllFields) {
-            expectResolver('requireResolversForAllFields', requireResolversForAllFields, field, typeName, fieldName);
-        }
-        // requires a resolver on every field that has arguments
-        if (requireResolversForArgs && field.args.length > 0) {
-            expectResolver('requireResolversForArgs', requireResolversForArgs, field, typeName, fieldName);
-        }
-        // requires a resolver on every field that returns a non-scalar type
-        if (requireResolversForNonScalar !== 'ignore' && !graphql.isScalarType(graphql.getNamedType(field.type))) {
-            expectResolver('requireResolversForNonScalar', requireResolversForNonScalar, field, typeName, fieldName);
-        }
-    });
-}
-function expectResolver(validator, behavior, field, typeName, fieldName) {
-    if (!field.resolve) {
-        const message = `Resolver missing for "${typeName}.${fieldName}".
-To disable this validator, use:
-  resolverValidationOptions: {
-    ${validator}: 'ignore'
-  }`;
-        if (behavior === 'error') {
-            throw new Error(message);
-        }
-        if (behavior === 'warn') {
-            console.warn(message);
-        }
-        return;
-    }
-    if (typeof field.resolve !== 'function') {
-        throw new Error(`Resolver "${typeName}.${fieldName}" must be a function`);
-    }
-}
-
-function chainResolvers(resolvers) {
-    return (root, args, ctx, info) => resolvers.reduce((prev, curResolver) => {
-        if (curResolver != null) {
-            return curResolver(prev, args, ctx, info);
-        }
-        return graphql.defaultFieldResolver(prev, args, ctx, info);
-    }, root);
-}
-
-// If we have any union or interface types throw if no there is no resolveType resolver
-function checkForResolveTypeResolver(schema, requireResolversForResolveType) {
-    utils.mapSchema(schema, {
-        [utils.MapperKind.ABSTRACT_TYPE]: type => {
-            if (!type.resolveType) {
-                const message = `Type "${type.name}" is missing a "__resolveType" resolver. Pass 'ignore' into ` +
-                    '"resolverValidationOptions.requireResolversForResolveType" to disable this error.';
-                if (requireResolversForResolveType === 'error') {
-                    throw new Error(message);
-                }
-                if (requireResolversForResolveType === 'warn') {
-                    console.warn(message);
-                }
-            }
-            return undefined;
-        },
-    });
-}
-
-function extendResolversFromInterfaces(schema, resolvers) {
-    const extendedResolvers = {};
-    const typeMap = schema.getTypeMap();
-    for (const typeName in typeMap) {
-        const type = typeMap[typeName];
-        if ('getInterfaces' in type) {
-            extendedResolvers[typeName] = {};
-            for (const iFace of type.getInterfaces()) {
-                if (resolvers[iFace.name]) {
-                    for (const fieldName in resolvers[iFace.name]) {
-                        if (fieldName === '__isTypeOf' || !fieldName.startsWith('__')) {
-                            extendedResolvers[typeName][fieldName] = resolvers[iFace.name][fieldName];
-                        }
-                    }
-                }
-            }
-            const typeResolvers = resolvers[typeName];
-            extendedResolvers[typeName] = {
-                ...extendedResolvers[typeName],
-                ...typeResolvers,
-            };
-        }
-        else {
-            const typeResolvers = resolvers[typeName];
-            if (typeResolvers != null) {
-                extendedResolvers[typeName] = typeResolvers;
-            }
-        }
-    }
-    return extendedResolvers;
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addResolversToSchema = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const checkForResolveTypeResolver_js_1 = require("./checkForResolveTypeResolver.js");
+const extendResolversFromInterfaces_js_1 = require("./extendResolversFromInterfaces.js");
 function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInputValidationOptions) {
-    const options = graphql.isSchema(schemaOrOptions)
+    const options = (0, graphql_1.isSchema)(schemaOrOptions)
         ? {
             schema: schemaOrOptions,
             resolvers: legacyInputResolvers !== null && legacyInputResolvers !== void 0 ? legacyInputResolvers : {},
@@ -119,7 +16,7 @@ function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInput
     let { schema, resolvers: inputResolvers, defaultFieldResolver, resolverValidationOptions = {}, inheritResolversFromInterfaces = false, updateResolversInPlace = false, } = options;
     const { requireResolversToMatchSchema = 'error', requireResolversForResolveType } = resolverValidationOptions;
     const resolvers = inheritResolversFromInterfaces
-        ? extendResolversFromInterfaces(schema, inputResolvers)
+        ? (0, extendResolversFromInterfaces_js_1.extendResolversFromInterfaces)(schema, inputResolvers)
         : inputResolvers;
     for (const typeName in resolvers) {
         const resolverValue = resolvers[typeName];
@@ -134,7 +31,7 @@ function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInput
             }
             throw new Error(`"${typeName}" defined in resolvers, but not in schema`);
         }
-        else if (graphql.isSpecifiedScalarType(type)) {
+        else if ((0, graphql_1.isSpecifiedScalarType)(type)) {
             // allow -- without recommending -- overriding of specified scalar types
             for (const fieldName in resolverValue) {
                 if (fieldName.startsWith('__')) {
@@ -145,7 +42,7 @@ function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInput
                 }
             }
         }
-        else if (graphql.isEnumType(type)) {
+        else if ((0, graphql_1.isEnumType)(type)) {
             const values = type.getValues();
             for (const fieldName in resolverValue) {
                 if (!fieldName.startsWith('__') &&
@@ -156,7 +53,7 @@ function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInput
                 }
             }
         }
-        else if (graphql.isUnionType(type)) {
+        else if ((0, graphql_1.isUnionType)(type)) {
             for (const fieldName in resolverValue) {
                 if (!fieldName.startsWith('__') &&
                     requireResolversToMatchSchema &&
@@ -165,7 +62,7 @@ function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInput
                 }
             }
         }
-        else if (graphql.isObjectType(type) || graphql.isInterfaceType(type)) {
+        else if ((0, graphql_1.isObjectType)(type) || (0, graphql_1.isInterfaceType)(type)) {
             for (const fieldName in resolverValue) {
                 if (!fieldName.startsWith('__')) {
                     const fields = type.getFields();
@@ -191,17 +88,18 @@ function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInput
         ? addResolversToExistingSchema(schema, resolvers, defaultFieldResolver)
         : createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver);
     if (requireResolversForResolveType && requireResolversForResolveType !== 'ignore') {
-        checkForResolveTypeResolver(schema, requireResolversForResolveType);
+        (0, checkForResolveTypeResolver_js_1.checkForResolveTypeResolver)(schema, requireResolversForResolveType);
     }
     return schema;
 }
+exports.addResolversToSchema = addResolversToSchema;
 function addResolversToExistingSchema(schema, resolvers, defaultFieldResolver) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
     const typeMap = schema.getTypeMap();
     for (const typeName in resolvers) {
         const type = schema.getType(typeName);
         const resolverValue = resolvers[typeName];
-        if (graphql.isScalarType(type)) {
+        if ((0, graphql_1.isScalarType)(type)) {
             for (const fieldName in resolverValue) {
                 if (fieldName.startsWith('__')) {
                     type[fieldName.substring(2)] = resolverValue[fieldName];
@@ -226,7 +124,7 @@ function addResolversToExistingSchema(schema, resolvers, defaultFieldResolver) {
                 }
             }
         }
-        else if (graphql.isEnumType(type)) {
+        else if ((0, graphql_1.isEnumType)(type)) {
             const config = type.toConfig();
             const enumValueConfigMap = config.values;
             for (const fieldName in resolverValue) {
@@ -252,16 +150,16 @@ function addResolversToExistingSchema(schema, resolvers, defaultFieldResolver) {
                     enumValueConfigMap[fieldName].value = resolverValue[fieldName];
                 }
             }
-            typeMap[typeName] = new graphql.GraphQLEnumType(config);
+            typeMap[typeName] = new graphql_1.GraphQLEnumType(config);
         }
-        else if (graphql.isUnionType(type)) {
+        else if ((0, graphql_1.isUnionType)(type)) {
             for (const fieldName in resolverValue) {
                 if (fieldName.startsWith('__')) {
                     type[fieldName.substring(2)] = resolverValue[fieldName];
                 }
             }
         }
-        else if (graphql.isObjectType(type) || graphql.isInterfaceType(type)) {
+        else if ((0, graphql_1.isObjectType)(type) || (0, graphql_1.isInterfaceType)(type)) {
             for (const fieldName in resolverValue) {
                 if (fieldName.startsWith('__')) {
                     // this is for isTypeOf and resolveType and all the other stuff.
@@ -284,13 +182,13 @@ function addResolversToExistingSchema(schema, resolvers, defaultFieldResolver) {
         }
     }
     // serialize all default values prior to healing fields with new scalar/enum types.
-    utils.forEachDefaultValue(schema, utils.serializeInputValue);
+    (0, utils_1.forEachDefaultValue)(schema, utils_1.serializeInputValue);
     // schema may have new scalar/enum types that require healing
-    utils.healSchema(schema);
+    (0, utils_1.healSchema)(schema);
     // reparse all default values with new parsing functions.
-    utils.forEachDefaultValue(schema, utils.parseInputValue);
+    (0, utils_1.forEachDefaultValue)(schema, utils_1.parseInputValue);
     if (defaultFieldResolver != null) {
-        utils.forEachField(schema, field => {
+        (0, utils_1.forEachField)(schema, field => {
             if (!field.resolve) {
                 field.resolve = defaultFieldResolver;
             }
@@ -299,12 +197,12 @@ function addResolversToExistingSchema(schema, resolvers, defaultFieldResolver) {
     return schema;
 }
 function createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver) {
-    schema = utils.mapSchema(schema, {
-        [utils.MapperKind.SCALAR_TYPE]: type => {
+    schema = (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.SCALAR_TYPE]: type => {
             var _a, _b, _c, _d, _e, _f;
             const config = type.toConfig();
             const resolverValue = resolvers[type.name];
-            if (!graphql.isSpecifiedScalarType(type) && resolverValue != null) {
+            if (!(0, graphql_1.isSpecifiedScalarType)(type) && resolverValue != null) {
                 for (const fieldName in resolverValue) {
                     if (fieldName.startsWith('__')) {
                         config[fieldName.substring(2)] = resolverValue[fieldName];
@@ -328,10 +226,10 @@ function createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver) {
                         config[fieldName] = resolverValue[fieldName];
                     }
                 }
-                return new graphql.GraphQLScalarType(config);
+                return new graphql_1.GraphQLScalarType(config);
             }
         },
-        [utils.MapperKind.ENUM_TYPE]: type => {
+        [utils_1.MapperKind.ENUM_TYPE]: type => {
             var _a, _b, _c, _d, _e, _f;
             const resolverValue = resolvers[type.name];
             const config = type.toConfig();
@@ -360,40 +258,40 @@ function createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver) {
                         enumValueConfigMap[fieldName].value = resolverValue[fieldName];
                     }
                 }
-                return new graphql.GraphQLEnumType(config);
+                return new graphql_1.GraphQLEnumType(config);
             }
         },
-        [utils.MapperKind.UNION_TYPE]: type => {
+        [utils_1.MapperKind.UNION_TYPE]: type => {
             const resolverValue = resolvers[type.name];
             if (resolverValue != null) {
                 const config = type.toConfig();
                 if (resolverValue['__resolveType']) {
                     config.resolveType = resolverValue['__resolveType'];
                 }
-                return new graphql.GraphQLUnionType(config);
+                return new graphql_1.GraphQLUnionType(config);
             }
         },
-        [utils.MapperKind.OBJECT_TYPE]: type => {
+        [utils_1.MapperKind.OBJECT_TYPE]: type => {
             const resolverValue = resolvers[type.name];
             if (resolverValue != null) {
                 const config = type.toConfig();
                 if (resolverValue['__isTypeOf']) {
                     config.isTypeOf = resolverValue['__isTypeOf'];
                 }
-                return new graphql.GraphQLObjectType(config);
+                return new graphql_1.GraphQLObjectType(config);
             }
         },
-        [utils.MapperKind.INTERFACE_TYPE]: type => {
+        [utils_1.MapperKind.INTERFACE_TYPE]: type => {
             const resolverValue = resolvers[type.name];
             if (resolverValue != null) {
                 const config = type.toConfig();
                 if (resolverValue['__resolveType']) {
                     config.resolveType = resolverValue['__resolveType'];
                 }
-                return new graphql.GraphQLInterfaceType(config);
+                return new graphql_1.GraphQLInterfaceType(config);
             }
         },
-        [utils.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+        [utils_1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
             const resolverValue = resolvers[typeName];
             if (resolverValue != null) {
                 const fieldResolve = resolverValue[fieldName];
@@ -412,8 +310,8 @@ function createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver) {
         },
     });
     if (defaultFieldResolver != null) {
-        schema = utils.mapSchema(schema, {
-            [utils.MapperKind.OBJECT_FIELD]: fieldConfig => ({
+        schema = (0, utils_1.mapSchema)(schema, {
+            [utils_1.MapperKind.OBJECT_FIELD]: fieldConfig => ({
                 ...fieldConfig,
                 resolve: fieldConfig.resolve != null ? fieldConfig.resolve : defaultFieldResolver,
             }),
@@ -426,122 +324,3 @@ function setFieldProperties(field, propertiesObj) {
         field[propertyName] = propertiesObj[propertyName];
     }
 }
-
-/**
- * Builds a schema from the provided type definitions and resolvers.
- *
- * The type definitions are written using Schema Definition Language (SDL). They
- * can be provided as a string, a `DocumentNode`, a function, or an array of any
- * of these. If a function is provided, it will be passed no arguments and
- * should return an array of strings or `DocumentNode`s.
- *
- * Note: You can use `graphql-tag` to not only parse a string into a
- * `DocumentNode` but also to provide additional syntax highlighting in your
- * editor (with the appropriate editor plugin).
- *
- * ```js
- * const typeDefs = gql`
- *   type Query {
- *     posts: [Post]
- *     author(id: Int!): Author
- *   }
- * `;
- * ```
- *
- * The `resolvers` object should be a map of type names to nested object, which
- * themselves map the type's fields to their appropriate resolvers.
- * See the [Resolvers](/docs/resolvers) section of the documentation for more details.
- *
- * ```js
- * const resolvers = {
- *   Query: {
- *     posts: (obj, args, ctx, info) => getAllPosts(),
- *     author: (obj, args, ctx, info) => getAuthorById(args.id)
- *   }
- * };
- * ```
- *
- * Once you've defined both the `typeDefs` and `resolvers`, you can create your
- * schema:
- *
- * ```js
- * const schema = makeExecutableSchema({
- *   typeDefs,
- *   resolvers,
- * })
- * ```
- */
-function makeExecutableSchema({ typeDefs, resolvers = {}, resolverValidationOptions = {}, parseOptions = {}, inheritResolversFromInterfaces = false, pruningOptions, updateResolversInPlace = false, schemaExtensions, }) {
-    // Validate and clean up arguments
-    if (typeof resolverValidationOptions !== 'object') {
-        throw new Error('Expected `resolverValidationOptions` to be an object');
-    }
-    if (!typeDefs) {
-        throw new Error('Must provide typeDefs');
-    }
-    let schema;
-    if (graphql.isSchema(typeDefs)) {
-        schema = typeDefs;
-    }
-    else if (parseOptions === null || parseOptions === void 0 ? void 0 : parseOptions.commentDescriptions) {
-        const mergedTypeDefs = merge.mergeTypeDefs(typeDefs, {
-            ...parseOptions,
-            commentDescriptions: true,
-        });
-        schema = graphql.buildSchema(mergedTypeDefs, parseOptions);
-    }
-    else {
-        const mergedTypeDefs = merge.mergeTypeDefs(typeDefs, parseOptions);
-        schema = graphql.buildASTSchema(mergedTypeDefs, parseOptions);
-    }
-    if (pruningOptions) {
-        schema = utils.pruneSchema(schema);
-    }
-    // We allow passing in an array of resolver maps, in which case we merge them
-    schema = addResolversToSchema({
-        schema,
-        resolvers: merge.mergeResolvers(resolvers),
-        resolverValidationOptions,
-        inheritResolversFromInterfaces,
-        updateResolversInPlace,
-    });
-    if (Object.keys(resolverValidationOptions).length > 0) {
-        assertResolversPresent(schema, resolverValidationOptions);
-    }
-    if (schemaExtensions) {
-        schemaExtensions = merge.mergeExtensions(utils.asArray(schemaExtensions));
-        merge.applyExtensions(schema, schemaExtensions);
-    }
-    return schema;
-}
-
-/**
- * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
- * @param config Configuration object
- */
-function mergeSchemas(config) {
-    const extractedTypeDefs = utils.asArray(config.typeDefs || []);
-    const extractedResolvers = utils.asArray(config.resolvers || []);
-    const extractedSchemaExtensions = utils.asArray(config.schemaExtensions || []);
-    const schemas = config.schemas || [];
-    for (const schema of schemas) {
-        extractedTypeDefs.push(schema);
-        extractedResolvers.push(utils.getResolversFromSchema(schema, true));
-        extractedSchemaExtensions.push(merge.extractExtensionsFromSchema(schema));
-    }
-    return makeExecutableSchema({
-        parseOptions: config,
-        ...config,
-        typeDefs: extractedTypeDefs,
-        resolvers: extractedResolvers,
-        schemaExtensions: extractedSchemaExtensions,
-    });
-}
-
-exports.addResolversToSchema = addResolversToSchema;
-exports.assertResolversPresent = assertResolversPresent;
-exports.chainResolvers = chainResolvers;
-exports.checkForResolveTypeResolver = checkForResolveTypeResolver;
-exports.extendResolversFromInterfaces = extendResolversFromInterfaces;
-exports.makeExecutableSchema = makeExecutableSchema;
-exports.mergeSchemas = mergeSchemas;

package/cjs/assertResolversPresent.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertResolversPresent = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+function assertResolversPresent(schema, resolverValidationOptions = {}) {
+    const { requireResolversForArgs, requireResolversForNonScalar, requireResolversForAllFields } = resolverValidationOptions;
+    if (requireResolversForAllFields && (requireResolversForArgs || requireResolversForNonScalar)) {
+        throw new TypeError('requireResolversForAllFields takes precedence over the more specific assertions. ' +
+            'Please configure either requireResolversForAllFields or requireResolversForArgs / ' +
+            'requireResolversForNonScalar, but not a combination of them.');
+    }
+    (0, utils_1.forEachField)(schema, (field, typeName, fieldName) => {
+        // requires a resolver for *every* field.
+        if (requireResolversForAllFields) {
+            expectResolver('requireResolversForAllFields', requireResolversForAllFields, field, typeName, fieldName);
+        }
+        // requires a resolver on every field that has arguments
+        if (requireResolversForArgs && field.args.length > 0) {
+            expectResolver('requireResolversForArgs', requireResolversForArgs, field, typeName, fieldName);
+        }
+        // requires a resolver on every field that returns a non-scalar type
+        if (requireResolversForNonScalar !== 'ignore' && !(0, graphql_1.isScalarType)((0, graphql_1.getNamedType)(field.type))) {
+            expectResolver('requireResolversForNonScalar', requireResolversForNonScalar, field, typeName, fieldName);
+        }
+    });
+}
+exports.assertResolversPresent = assertResolversPresent;
+function expectResolver(validator, behavior, field, typeName, fieldName) {
+    if (!field.resolve) {
+        const message = `Resolver missing for "${typeName}.${fieldName}".
+To disable this validator, use:
+  resolverValidationOptions: {
+    ${validator}: 'ignore'
+  }`;
+        if (behavior === 'error') {
+            throw new Error(message);
+        }
+        if (behavior === 'warn') {
+            console.warn(message);
+        }
+        return;
+    }
+    if (typeof field.resolve !== 'function') {
+        throw new Error(`Resolver "${typeName}.${fieldName}" must be a function`);
+    }
+}

package/cjs/chainResolvers.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainResolvers = void 0;
+const graphql_1 = require("graphql");
+function chainResolvers(resolvers) {
+    return (root, args, ctx, info) => resolvers.reduce((prev, curResolver) => {
+        if (curResolver != null) {
+            return curResolver(prev, args, ctx, info);
+        }
+        return (0, graphql_1.defaultFieldResolver)(prev, args, ctx, info);
+    }, root);
+}
+exports.chainResolvers = chainResolvers;

package/cjs/checkForResolveTypeResolver.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForResolveTypeResolver = void 0;
+const utils_1 = require("@graphql-tools/utils");
+// If we have any union or interface types throw if no there is no resolveType resolver
+function checkForResolveTypeResolver(schema, requireResolversForResolveType) {
+    (0, utils_1.mapSchema)(schema, {
+        [utils_1.MapperKind.ABSTRACT_TYPE]: type => {
+            if (!type.resolveType) {
+                const message = `Type "${type.name}" is missing a "__resolveType" resolver. Pass 'ignore' into ` +
+                    '"resolverValidationOptions.requireResolversForResolveType" to disable this error.';
+                if (requireResolversForResolveType === 'error') {
+                    throw new Error(message);
+                }
+                if (requireResolversForResolveType === 'warn') {
+                    console.warn(message);
+                }
+            }
+            return undefined;
+        },
+    });
+}
+exports.checkForResolveTypeResolver = checkForResolveTypeResolver;

package/cjs/extendResolversFromInterfaces.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendResolversFromInterfaces = void 0;
+function extendResolversFromInterfaces(schema, resolvers) {
+    const extendedResolvers = {};
+    const typeMap = schema.getTypeMap();
+    for (const typeName in typeMap) {
+        const type = typeMap[typeName];
+        if ('getInterfaces' in type) {
+            extendedResolvers[typeName] = {};
+            for (const iFace of type.getInterfaces()) {
+                if (resolvers[iFace.name]) {
+                    for (const fieldName in resolvers[iFace.name]) {
+                        if (fieldName === '__isTypeOf' || !fieldName.startsWith('__')) {
+                            extendedResolvers[typeName][fieldName] = resolvers[iFace.name][fieldName];
+                        }
+                    }
+                }
+            }
+            const typeResolvers = resolvers[typeName];
+            extendedResolvers[typeName] = {
+                ...extendedResolvers[typeName],
+                ...typeResolvers,
+            };
+        }
+        else {
+            const typeResolvers = resolvers[typeName];
+            if (typeResolvers != null) {
+                extendedResolvers[typeName] = typeResolvers;
+            }
+        }
+    }
+    return extendedResolvers;
+}
+exports.extendResolversFromInterfaces = extendResolversFromInterfaces;

package/cjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendResolversFromInterfaces = exports.checkForResolveTypeResolver = exports.addResolversToSchema = exports.chainResolvers = exports.assertResolversPresent = void 0;
+const tslib_1 = require("tslib");
+var assertResolversPresent_js_1 = require("./assertResolversPresent.js");
+Object.defineProperty(exports, "assertResolversPresent", { enumerable: true, get: function () { return assertResolversPresent_js_1.assertResolversPresent; } });
+var chainResolvers_js_1 = require("./chainResolvers.js");
+Object.defineProperty(exports, "chainResolvers", { enumerable: true, get: function () { return chainResolvers_js_1.chainResolvers; } });
+var addResolversToSchema_js_1 = require("./addResolversToSchema.js");
+Object.defineProperty(exports, "addResolversToSchema", { enumerable: true, get: function () { return addResolversToSchema_js_1.addResolversToSchema; } });
+var checkForResolveTypeResolver_js_1 = require("./checkForResolveTypeResolver.js");
+Object.defineProperty(exports, "checkForResolveTypeResolver", { enumerable: true, get: function () { return checkForResolveTypeResolver_js_1.checkForResolveTypeResolver; } });
+var extendResolversFromInterfaces_js_1 = require("./extendResolversFromInterfaces.js");
+Object.defineProperty(exports, "extendResolversFromInterfaces", { enumerable: true, get: function () { return extendResolversFromInterfaces_js_1.extendResolversFromInterfaces; } });
+tslib_1.__exportStar(require("./makeExecutableSchema.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./merge-schemas.js"), exports);