@graphql-tools/schema 8.4.0 → 8.5.0

package/cjs/makeExecutableSchema.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeExecutableSchema = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const addResolversToSchema_js_1 = require("./addResolversToSchema.js");
+const assertResolversPresent_js_1 = require("./assertResolversPresent.js");
+const merge_1 = require("@graphql-tools/merge");
+/**
+ * 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 ((0, graphql_1.isSchema)(typeDefs)) {
+        schema = typeDefs;
+    }
+    else if (parseOptions === null || parseOptions === void 0 ? void 0 : parseOptions.commentDescriptions) {
+        const mergedTypeDefs = (0, merge_1.mergeTypeDefs)(typeDefs, {
+            ...parseOptions,
+            commentDescriptions: true,
+        });
+        schema = (0, graphql_1.buildSchema)(mergedTypeDefs, parseOptions);
+    }
+    else {
+        const mergedTypeDefs = (0, merge_1.mergeTypeDefs)(typeDefs, parseOptions);
+        schema = (0, graphql_1.buildASTSchema)(mergedTypeDefs, parseOptions);
+    }
+    if (pruningOptions) {
+        schema = (0, utils_1.pruneSchema)(schema);
+    }
+    // We allow passing in an array of resolver maps, in which case we merge them
+    schema = (0, addResolversToSchema_js_1.addResolversToSchema)({
+        schema,
+        resolvers: (0, merge_1.mergeResolvers)(resolvers),
+        resolverValidationOptions,
+        inheritResolversFromInterfaces,
+        updateResolversInPlace,
+    });
+    if (Object.keys(resolverValidationOptions).length > 0) {
+        (0, assertResolversPresent_js_1.assertResolversPresent)(schema, resolverValidationOptions);
+    }
+    if (schemaExtensions) {
+        schemaExtensions = (0, merge_1.mergeExtensions)((0, utils_1.asArray)(schemaExtensions));
+        (0, merge_1.applyExtensions)(schema, schemaExtensions);
+    }
+    return schema;
+}
+exports.makeExecutableSchema = makeExecutableSchema;

package/cjs/merge-schemas.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSchemas = void 0;
+const merge_1 = require("@graphql-tools/merge");
+const utils_1 = require("@graphql-tools/utils");
+const makeExecutableSchema_js_1 = require("./makeExecutableSchema.js");
+/**
+ * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
+ * @param config Configuration object
+ */
+function mergeSchemas(config) {
+    const extractedTypeDefs = (0, utils_1.asArray)(config.typeDefs || []);
+    const extractedResolvers = (0, utils_1.asArray)(config.resolvers || []);
+    const extractedSchemaExtensions = (0, utils_1.asArray)(config.schemaExtensions || []);
+    const schemas = config.schemas || [];
+    for (const schema of schemas) {
+        extractedTypeDefs.push(schema);
+        extractedResolvers.push((0, utils_1.getResolversFromSchema)(schema, true));
+        extractedSchemaExtensions.push((0, merge_1.extractExtensionsFromSchema)(schema));
+    }
+    return (0, makeExecutableSchema_js_1.makeExecutableSchema)({
+        parseOptions: config,
+        ...config,
+        typeDefs: extractedTypeDefs,
+        resolvers: extractedResolvers,
+        schemaExtensions: extractedSchemaExtensions,
+    });
+}
+exports.mergeSchemas = mergeSchemas;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/types.js

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

package/{index.mjs → esm/addResolversToSchema.js}

@@ -1,110 +1,8 @@
-import { isScalarType, getNamedType, defaultFieldResolver, isSchema, isSpecifiedScalarType, isEnumType, isUnionType, isObjectType, isInterfaceType, GraphQLEnumType, GraphQLScalarType, GraphQLUnionType, GraphQLObjectType, GraphQLInterfaceType, buildSchema, buildASTSchema } from 'graphql';
-import { forEachField, mapSchema, MapperKind, forEachDefaultValue, serializeInputValue, healSchema, parseInputValue, pruneSchema, asArray, getResolversFromSchema } from '@graphql-tools/utils';
-import { mergeTypeDefs, mergeResolvers, mergeExtensions, applyExtensions, extractExtensionsFromSchema } from '@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.');
-    }
-    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' && !isScalarType(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 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) {
-    mapSchema(schema, {
-        [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;
-}
-
-function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInputValidationOptions) {
+import { GraphQLEnumType, isSchema, GraphQLScalarType, GraphQLUnionType, GraphQLInterfaceType, GraphQLObjectType, isSpecifiedScalarType, isScalarType, isEnumType, isUnionType, isInterfaceType, isObjectType, } from 'graphql';
+import { mapSchema, MapperKind, forEachDefaultValue, serializeInputValue, healSchema, parseInputValue, forEachField, } from '@graphql-tools/utils';
+import { checkForResolveTypeResolver } from './checkForResolveTypeResolver.js';
+import { extendResolversFromInterfaces } from './extendResolversFromInterfaces.js';
+export function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInputValidationOptions) {
     const options = isSchema(schemaOrOptions)
         ? {
             schema: schemaOrOptions,
@@ -422,116 +320,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 (isSchema(typeDefs)) {
-        schema = typeDefs;
-    }
-    else if (parseOptions === null || parseOptions === void 0 ? void 0 : parseOptions.commentDescriptions) {
-        const mergedTypeDefs = mergeTypeDefs(typeDefs, {
-            ...parseOptions,
-            commentDescriptions: true,
-        });
-        schema = buildSchema(mergedTypeDefs, parseOptions);
-    }
-    else {
-        const mergedTypeDefs = mergeTypeDefs(typeDefs, parseOptions);
-        schema = buildASTSchema(mergedTypeDefs, parseOptions);
-    }
-    if (pruningOptions) {
-        schema = pruneSchema(schema);
-    }
-    // We allow passing in an array of resolver maps, in which case we merge them
-    schema = addResolversToSchema({
-        schema,
-        resolvers: mergeResolvers(resolvers),
-        resolverValidationOptions,
-        inheritResolversFromInterfaces,
-        updateResolversInPlace,
-    });
-    if (Object.keys(resolverValidationOptions).length > 0) {
-        assertResolversPresent(schema, resolverValidationOptions);
-    }
-    if (schemaExtensions) {
-        schemaExtensions = mergeExtensions(asArray(schemaExtensions));
-        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 = asArray(config.typeDefs || []);
-    const extractedResolvers = asArray(config.resolvers || []);
-    const extractedSchemaExtensions = asArray(config.schemaExtensions || []);
-    const schemas = config.schemas || [];
-    for (const schema of schemas) {
-        extractedTypeDefs.push(schema);
-        extractedResolvers.push(getResolversFromSchema(schema, true));
-        extractedSchemaExtensions.push(extractExtensionsFromSchema(schema));
-    }
-    return makeExecutableSchema({
-        parseOptions: config,
-        ...config,
-        typeDefs: extractedTypeDefs,
-        resolvers: extractedResolvers,
-        schemaExtensions: extractedSchemaExtensions,
-    });
-}
-
-export { addResolversToSchema, assertResolversPresent, chainResolvers, checkForResolveTypeResolver, extendResolversFromInterfaces, makeExecutableSchema, mergeSchemas };

package/esm/assertResolversPresent.js

@@ -0,0 +1,43 @@
+import { getNamedType, isScalarType } from 'graphql';
+import { forEachField } from '@graphql-tools/utils';
+export 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.');
+    }
+    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' && !isScalarType(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`);
+    }
+}

package/esm/chainResolvers.js

@@ -0,0 +1,9 @@
+import { defaultFieldResolver } from 'graphql';
+export function chainResolvers(resolvers) {
+    return (root, args, ctx, info) => resolvers.reduce((prev, curResolver) => {
+        if (curResolver != null) {
+            return curResolver(prev, args, ctx, info);
+        }
+        return defaultFieldResolver(prev, args, ctx, info);
+    }, root);
+}

package/esm/checkForResolveTypeResolver.js

@@ -0,0 +1,19 @@
+import { MapperKind, mapSchema } from '@graphql-tools/utils';
+// If we have any union or interface types throw if no there is no resolveType resolver
+export function checkForResolveTypeResolver(schema, requireResolversForResolveType) {
+    mapSchema(schema, {
+        [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;
+        },
+    });
+}

package/esm/extendResolversFromInterfaces.js

@@ -0,0 +1,31 @@
+export 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;
+}

package/esm/index.js

@@ -0,0 +1,8 @@
+export { assertResolversPresent } from './assertResolversPresent.js';
+export { chainResolvers } from './chainResolvers.js';
+export { addResolversToSchema } from './addResolversToSchema.js';
+export { checkForResolveTypeResolver } from './checkForResolveTypeResolver.js';
+export { extendResolversFromInterfaces } from './extendResolversFromInterfaces.js';
+export * from './makeExecutableSchema.js';
+export * from './types.js';
+export * from './merge-schemas.js';

package/esm/makeExecutableSchema.js

@@ -0,0 +1,92 @@
+import { buildASTSchema, buildSchema, isSchema } from 'graphql';
+import { asArray, pruneSchema } from '@graphql-tools/utils';
+import { addResolversToSchema } from './addResolversToSchema.js';
+import { assertResolversPresent } from './assertResolversPresent.js';
+import { applyExtensions, mergeExtensions, mergeResolvers, mergeTypeDefs } from '@graphql-tools/merge';
+/**
+ * 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,
+ * })
+ * ```
+ */
+export 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 (isSchema(typeDefs)) {
+        schema = typeDefs;
+    }
+    else if (parseOptions === null || parseOptions === void 0 ? void 0 : parseOptions.commentDescriptions) {
+        const mergedTypeDefs = mergeTypeDefs(typeDefs, {
+            ...parseOptions,
+            commentDescriptions: true,
+        });
+        schema = buildSchema(mergedTypeDefs, parseOptions);
+    }
+    else {
+        const mergedTypeDefs = mergeTypeDefs(typeDefs, parseOptions);
+        schema = buildASTSchema(mergedTypeDefs, parseOptions);
+    }
+    if (pruningOptions) {
+        schema = pruneSchema(schema);
+    }
+    // We allow passing in an array of resolver maps, in which case we merge them
+    schema = addResolversToSchema({
+        schema,
+        resolvers: mergeResolvers(resolvers),
+        resolverValidationOptions,
+        inheritResolversFromInterfaces,
+        updateResolversInPlace,
+    });
+    if (Object.keys(resolverValidationOptions).length > 0) {
+        assertResolversPresent(schema, resolverValidationOptions);
+    }
+    if (schemaExtensions) {
+        schemaExtensions = mergeExtensions(asArray(schemaExtensions));
+        applyExtensions(schema, schemaExtensions);
+    }
+    return schema;
+}

package/esm/merge-schemas.js

@@ -0,0 +1,25 @@
+import { extractExtensionsFromSchema } from '@graphql-tools/merge';
+import { asArray, getResolversFromSchema } from '@graphql-tools/utils';
+import { makeExecutableSchema } from './makeExecutableSchema.js';
+/**
+ * Synchronously merges multiple schemas, typeDefinitions and/or resolvers into a single schema.
+ * @param config Configuration object
+ */
+export function mergeSchemas(config) {
+    const extractedTypeDefs = asArray(config.typeDefs || []);
+    const extractedResolvers = asArray(config.resolvers || []);
+    const extractedSchemaExtensions = asArray(config.schemaExtensions || []);
+    const schemas = config.schemas || [];
+    for (const schema of schemas) {
+        extractedTypeDefs.push(schema);
+        extractedResolvers.push(getResolversFromSchema(schema, true));
+        extractedSchemaExtensions.push(extractExtensionsFromSchema(schema));
+    }
+    return makeExecutableSchema({
+        parseOptions: config,
+        ...config,
+        typeDefs: extractedTypeDefs,
+        resolvers: extractedResolvers,
+        schemaExtensions: extractedSchemaExtensions,
+    });
+}

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@graphql-tools/schema",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/merge": "8.2.15",
-    "@graphql-tools/utils": "8.7.0",
+    "@graphql-tools/merge": "8.3.0",
+    "@graphql-tools/utils": "8.8.0",
     "tslib": "^2.4.0",
     "value-or-promise": "1.0.11"
   },
@@ -18,21 +18,42 @@
     "directory": "packages/schema"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}