@graphql-tools/schema 7.1.0-alpha-796c16fa.0 → 7.1.2

package/buildSchemaFromTypeDefinitions.d.ts

@@ -1,5 +1,4 @@
 import { GraphQLSchema, DocumentNode } from 'graphql';
 import { ITypeDefinitions, GraphQLParseOptions } from '@graphql-tools/utils';
-export declare function buildSchemaFromTypeDefinitions(typeDefinitions: ITypeDefinitions, parseOptions?: GraphQLParseOptions): GraphQLSchema;
-export declare function isDocumentNode(typeDefinitions: ITypeDefinitions): typeDefinitions is DocumentNode;
+export declare function buildSchemaFromTypeDefinitions(typeDefinitions: ITypeDefinitions, parseOptions?: GraphQLParseOptions, noExtensionExtraction?: boolean): GraphQLSchema;
 export declare function buildDocumentFromTypeDefinitions(typeDefinitions: ITypeDefinitions, parseOptions?: GraphQLParseOptions): DocumentNode;

package/checkForResolveTypeResolver.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLSchema } from 'graphql';
 import { ValidatorBehavior } from '@graphql-tools/utils';
-export declare function checkForResolveTypeResolver(schema: GraphQLSchema, requireResolversForResolveType?: ValidatorBehavior): void;
+export declare function checkForResolveTypeResolver(schema: GraphQLSchema, requireResolversForResolveType: ValidatorBehavior): void;

package/concatenateTypeDefs.d.ts

@@ -1,2 +1,2 @@
 import { ITypedef } from '@graphql-tools/utils';
-export declare function concatenateTypeDefs(typeDefinitionsAry: Array<ITypedef>, calledFunctionRefs?: any): string;
+export declare function concatenateTypeDefs(typeDefinitionsAry: Array<ITypedef>, calledFunctionRefs?: Set<ITypedef>): string;

package/es5/buildSchemaFromTypeDefinitions.d.ts

@@ -1,5 +1,4 @@
 import { GraphQLSchema, DocumentNode } from 'graphql';
 import { ITypeDefinitions, GraphQLParseOptions } from '@graphql-tools/utils';
-export declare function buildSchemaFromTypeDefinitions(typeDefinitions: ITypeDefinitions, parseOptions?: GraphQLParseOptions): GraphQLSchema;
-export declare function isDocumentNode(typeDefinitions: ITypeDefinitions): typeDefinitions is DocumentNode;
+export declare function buildSchemaFromTypeDefinitions(typeDefinitions: ITypeDefinitions, parseOptions?: GraphQLParseOptions, noExtensionExtraction?: boolean): GraphQLSchema;
 export declare function buildDocumentFromTypeDefinitions(typeDefinitions: ITypeDefinitions, parseOptions?: GraphQLParseOptions): DocumentNode;

package/es5/checkForResolveTypeResolver.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLSchema } from 'graphql';
 import { ValidatorBehavior } from '@graphql-tools/utils';
-export declare function checkForResolveTypeResolver(schema: GraphQLSchema, requireResolversForResolveType?: ValidatorBehavior): void;
+export declare function checkForResolveTypeResolver(schema: GraphQLSchema, requireResolversForResolveType: ValidatorBehavior): void;

package/es5/concatenateTypeDefs.d.ts

@@ -1,2 +1,2 @@
 import { ITypedef } from '@graphql-tools/utils';
-export declare function concatenateTypeDefs(typeDefinitionsAry: Array<ITypedef>, calledFunctionRefs?: any): string;
+export declare function concatenateTypeDefs(typeDefinitionsAry: Array<ITypedef>, calledFunctionRefs?: Set<ITypedef>): string;

package/es5/extensionDefinitions.d.ts

@@ -1,10 +1,22 @@
 import { DocumentNode, DefinitionNode } from 'graphql';
-export declare function extractExtensionDefinitions(ast: DocumentNode): {
+export declare function filterAndExtractExtensionDefinitions(ast: DocumentNode): {
+    typesAst: {
+        definitions: DefinitionNode[];
+        kind: "Document";
+        loc?: import("graphql").Location;
+    };
+    extensionsAst: {
+        definitions: DefinitionNode[];
+        kind: "Document";
+        loc?: import("graphql").Location;
+    };
+};
+export declare function filterExtensionDefinitions(ast: DocumentNode): {
     definitions: DefinitionNode[];
     kind: "Document";
     loc?: import("graphql").Location;
 };
-export declare function filterExtensionDefinitions(ast: DocumentNode): {
+export declare function extractExtensionDefinitions(ast: DocumentNode): {
     definitions: DefinitionNode[];
     kind: "Document";
     loc?: import("graphql").Location;

package/es5/index.cjs.js

@@ -146,74 +146,77 @@ function attachDirectiveResolvers(schema, directiveResolvers) {
         _a));
 }
 
-function extractExtensionDefinitions(ast) {
-    var extensionDefs = ast.definitions.filter(function (def) {
-        return def.kind === graphql.Kind.OBJECT_TYPE_EXTENSION ||
-            def.kind === graphql.Kind.INTERFACE_TYPE_EXTENSION ||
-            def.kind === graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION ||
-            def.kind === graphql.Kind.UNION_TYPE_EXTENSION ||
-            def.kind === graphql.Kind.ENUM_TYPE_EXTENSION ||
-            def.kind === graphql.Kind.SCALAR_TYPE_EXTENSION ||
-            def.kind === graphql.Kind.SCHEMA_EXTENSION;
+var isExtensionNode = function (def) {
+    return def.kind === graphql.Kind.OBJECT_TYPE_EXTENSION ||
+        def.kind === graphql.Kind.INTERFACE_TYPE_EXTENSION ||
+        def.kind === graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION ||
+        def.kind === graphql.Kind.UNION_TYPE_EXTENSION ||
+        def.kind === graphql.Kind.ENUM_TYPE_EXTENSION ||
+        def.kind === graphql.Kind.SCALAR_TYPE_EXTENSION ||
+        def.kind === graphql.Kind.SCHEMA_EXTENSION;
+};
+function filterAndExtractExtensionDefinitions(ast) {
+    var extensionDefs = [];
+    var typesDefs = [];
+    ast.definitions.forEach(function (def) {
+        if (isExtensionNode(def)) {
+            extensionDefs.push(def);
+        }
+        else {
+            typesDefs.push(def);
+        }
     });
-    return tslib.__assign(tslib.__assign({}, ast), { definitions: extensionDefs });
+    return {
+        typesAst: tslib.__assign(tslib.__assign({}, ast), { definitions: typesDefs }),
+        extensionsAst: tslib.__assign(tslib.__assign({}, ast), { definitions: extensionDefs }),
+    };
 }
 function filterExtensionDefinitions(ast) {
-    var extensionDefs = ast.definitions.filter(function (def) {
-        return def.kind !== graphql.Kind.OBJECT_TYPE_EXTENSION &&
-            def.kind !== graphql.Kind.INTERFACE_TYPE_EXTENSION &&
-            def.kind !== graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION &&
-            def.kind !== graphql.Kind.UNION_TYPE_EXTENSION &&
-            def.kind !== graphql.Kind.ENUM_TYPE_EXTENSION &&
-            def.kind !== graphql.Kind.SCALAR_TYPE_EXTENSION &&
-            def.kind !== graphql.Kind.SCHEMA_EXTENSION;
-    });
-    return tslib.__assign(tslib.__assign({}, ast), { definitions: extensionDefs });
+    var typesAst = filterAndExtractExtensionDefinitions(ast).typesAst;
+    return typesAst;
+}
+function extractExtensionDefinitions(ast) {
+    var extensionsAst = filterAndExtractExtensionDefinitions(ast).extensionsAst;
+    return extensionsAst;
 }
 
 function concatenateTypeDefs(typeDefinitionsAry, calledFunctionRefs) {
-    if (calledFunctionRefs === void 0) { calledFunctionRefs = []; }
-    var resolvedTypeDefinitions = [];
+    if (calledFunctionRefs === void 0) { calledFunctionRefs = new Set(); }
+    var resolvedTypeDefinitions = new Set();
     typeDefinitionsAry.forEach(function (typeDef) {
         if (typeof typeDef === 'function') {
-            if (calledFunctionRefs.indexOf(typeDef) === -1) {
-                calledFunctionRefs.push(typeDef);
-                resolvedTypeDefinitions = resolvedTypeDefinitions.concat(concatenateTypeDefs(typeDef(), calledFunctionRefs));
+            if (!calledFunctionRefs.has(typeDef)) {
+                calledFunctionRefs.add(typeDef);
+                resolvedTypeDefinitions.add(concatenateTypeDefs(typeDef(), calledFunctionRefs));
             }
         }
         else if (typeof typeDef === 'string') {
-            resolvedTypeDefinitions.push(typeDef.trim());
+            resolvedTypeDefinitions.add(typeDef.trim());
         }
         else if (typeDef.kind !== undefined) {
-            resolvedTypeDefinitions.push(graphql.print(typeDef).trim());
+            resolvedTypeDefinitions.add(graphql.print(typeDef).trim());
         }
         else {
             var type = typeof typeDef;
             throw new Error("typeDef array must contain only strings, documents, or functions, got " + type);
         }
     });
-    return uniq(resolvedTypeDefinitions.map(function (x) { return x.trim(); })).join('\n');
-}
-function uniq(array) {
-    return array.reduce(function (accumulator, currentValue) {
-        return accumulator.indexOf(currentValue) === -1 ? tslib.__spread(accumulator, [currentValue]) : accumulator;
-    }, []);
+    return tslib.__spread(resolvedTypeDefinitions).join('\n');
 }
 
-function buildSchemaFromTypeDefinitions(typeDefinitions, parseOptions) {
+function buildSchemaFromTypeDefinitions(typeDefinitions, parseOptions, noExtensionExtraction) {
     var document = buildDocumentFromTypeDefinitions(typeDefinitions, parseOptions);
-    var typesAst = filterExtensionDefinitions(document);
+    if (noExtensionExtraction) {
+        return graphql.buildASTSchema(document);
+    }
+    var _a = filterAndExtractExtensionDefinitions(document), typesAst = _a.typesAst, extensionsAst = _a.extensionsAst;
     var backcompatOptions = { commentDescriptions: true };
     var schema = graphql.buildASTSchema(typesAst, backcompatOptions);
-    var extensionsAst = extractExtensionDefinitions(document);
     if (extensionsAst.definitions.length > 0) {
         schema = graphql.extendSchema(schema, extensionsAst, backcompatOptions);
     }
     return schema;
 }
-function isDocumentNode(typeDefinitions) {
-    return typeDefinitions.kind !== undefined;
-}
 function buildDocumentFromTypeDefinitions(typeDefinitions, parseOptions) {
     var document;
     if (typeof typeDefinitions === 'string') {
@@ -222,7 +225,7 @@ function buildDocumentFromTypeDefinitions(typeDefinitions, parseOptions) {
     else if (Array.isArray(typeDefinitions)) {
         document = utils.parseGraphQLSDL('', concatenateTypeDefs(typeDefinitions), parseOptions).document;
     }
-    else if (isDocumentNode(typeDefinitions)) {
+    else if (utils.isDocumentNode(typeDefinitions)) {
         document = typeDefinitions;
     }
     else {
@@ -289,7 +292,7 @@ function checkForResolveTypeResolver(schema, requireResolversForResolveType) {
     var _a;
     utils.mapSchema(schema, (_a = {},
         _a[utils.MapperKind.ABSTRACT_TYPE] = function (type) {
-            if (!type.resolveType && requireResolversForResolveType) {
+            if (!type.resolveType) {
                 var message = "Type \"" + type.name + "\" is missing a \"__resolveType\" resolver. Pass 'ignore' into " +
                     '"resolverValidationOptions.requireResolversForResolveType" to disable this error.';
                 if (requireResolversForResolveType === 'error') {
@@ -419,7 +422,9 @@ function addResolversToSchema(schemaOrOptions, legacyInputResolvers, legacyInput
     schema = updateResolversInPlace
         ? addResolversToExistingSchema(schema, resolvers, defaultFieldResolver)
         : createNewSchemaWithResolvers(schema, resolvers, defaultFieldResolver);
-    checkForResolveTypeResolver(schema, requireResolversForResolveType);
+    if (requireResolversForResolveType || requireResolversForResolveType !== 'ignore') {
+        checkForResolveTypeResolver(schema, requireResolversForResolveType);
+    }
     return schema;
 }
 function addResolversToExistingSchema(schema, resolvers, defaultFieldResolver) {
@@ -720,7 +725,7 @@ function addCatchUndefinedToSchema(schema) {
  * ```
  */
 function makeExecutableSchema(_a) {
-    var typeDefs = _a.typeDefs, _b = _a.resolvers, resolvers = _b === void 0 ? {} : _b, logger = _a.logger, _c = _a.allowUndefinedInResolve, allowUndefinedInResolve = _c === void 0 ? true : _c, _d = _a.resolverValidationOptions, resolverValidationOptions = _d === void 0 ? {} : _d, directiveResolvers = _a.directiveResolvers, schemaDirectives = _a.schemaDirectives, _e = _a.schemaTransforms, schemaTransforms = _e === void 0 ? [] : _e, _f = _a.parseOptions, parseOptions = _f === void 0 ? {} : _f, _g = _a.inheritResolversFromInterfaces, inheritResolversFromInterfaces = _g === void 0 ? false : _g, pruningOptions = _a.pruningOptions;
+    var typeDefs = _a.typeDefs, _b = _a.resolvers, resolvers = _b === void 0 ? {} : _b, logger = _a.logger, _c = _a.allowUndefinedInResolve, allowUndefinedInResolve = _c === void 0 ? true : _c, _d = _a.resolverValidationOptions, resolverValidationOptions = _d === void 0 ? {} : _d, directiveResolvers = _a.directiveResolvers, schemaDirectives = _a.schemaDirectives, userProvidedSchemaTransforms = _a.schemaTransforms, _e = _a.parseOptions, parseOptions = _e === void 0 ? {} : _e, _f = _a.inheritResolversFromInterfaces, inheritResolversFromInterfaces = _f === void 0 ? false : _f, pruningOptions = _a.pruningOptions, _g = _a.updateResolversInPlace, updateResolversInPlace = _g === void 0 ? false : _g, _h = _a.noExtensionExtraction, noExtensionExtraction = _h === void 0 ? false : _h;
     // Validate and clean up arguments
     if (typeof resolverValidationOptions !== 'object') {
         throw new Error('Expected `resolverValidationOptions` to be an object');
@@ -728,42 +733,58 @@ function makeExecutableSchema(_a) {
     if (!typeDefs) {
         throw new Error('Must provide typeDefs');
     }
-    // We allow passing in an array of resolver maps, in which case we merge them
-    var resolverMap = Array.isArray(resolvers) ? resolvers.reduce(utils.mergeDeep, {}) : resolvers;
     // Arguments are now validated and cleaned up
-    var schema = buildSchemaFromTypeDefinitions(typeDefs, parseOptions);
-    schema = addResolversToSchema({
-        schema: schema,
-        resolvers: resolverMap,
-        resolverValidationOptions: resolverValidationOptions,
-        inheritResolversFromInterfaces: inheritResolversFromInterfaces,
-    });
-    if (Object.keys(resolverValidationOptions).length > 0) {
-        assertResolversPresent(schema, resolverValidationOptions);
-    }
+    var schemaTransforms = [
+        function (schema) {
+            // We allow passing in an array of resolver maps, in which case we merge them
+            var resolverMap = Array.isArray(resolvers) ? resolvers.reduce(utils.mergeDeep, {}) : resolvers;
+            var schemaWithResolvers = addResolversToSchema({
+                schema: schema,
+                resolvers: resolverMap,
+                resolverValidationOptions: resolverValidationOptions,
+                inheritResolversFromInterfaces: inheritResolversFromInterfaces,
+                updateResolversInPlace: updateResolversInPlace,
+            });
+            if (Object.keys(resolverValidationOptions).length > 0) {
+                assertResolversPresent(schemaWithResolvers, resolverValidationOptions);
+            }
+            return schemaWithResolvers;
+        },
+    ];
     if (!allowUndefinedInResolve) {
-        schema = addCatchUndefinedToSchema(schema);
+        schemaTransforms.push(addCatchUndefinedToSchema);
     }
     if (logger != null) {
-        schema = addErrorLoggingToSchema(schema, logger);
+        schemaTransforms.push(function (schema) { return addErrorLoggingToSchema(schema, logger); });
     }
     if (typeof resolvers['__schema'] === 'function') {
         // TODO a bit of a hack now, better rewrite generateSchema to attach it there.
         // not doing that now, because I'd have to rewrite a lot of tests.
-        schema = addSchemaLevelResolver(schema, resolvers['__schema']);
+        schemaTransforms.push(function (schema) {
+            return addSchemaLevelResolver(schema, resolvers['__schema']);
+        });
+    }
+    if (userProvidedSchemaTransforms) {
+        schemaTransforms.push(function (schema) {
+            return userProvidedSchemaTransforms.reduce(function (s, schemaTransform) { return schemaTransform(s); }, schema);
+        });
     }
-    schemaTransforms.forEach(function (schemaTransform) {
-        schema = schemaTransform(schema);
-    });
     // directive resolvers are implemented using SchemaDirectiveVisitor.visitSchemaDirectives
     // schema visiting modifies the schema in place
     if (directiveResolvers != null) {
-        schema = attachDirectiveResolvers(schema, directiveResolvers);
+        schemaTransforms.push(function (schema) { return attachDirectiveResolvers(schema, directiveResolvers); });
     }
     if (schemaDirectives != null) {
-        utils.SchemaDirectiveVisitor.visitSchemaDirectives(schema, schemaDirectives);
+        schemaTransforms.push(function (schema) {
+            utils.SchemaDirectiveVisitor.visitSchemaDirectives(schema, schemaDirectives);
+            return schema;
+        });
+    }
+    if (pruningOptions) {
+        schemaTransforms.push(utils.pruneSchema);
     }
-    return pruningOptions ? utils.pruneSchema(schema, pruningOptions) : schema;
+    var schemaFromTypeDefs = buildSchemaFromTypeDefinitions(typeDefs, parseOptions, noExtensionExtraction);
+    return schemaTransforms.reduce(function (schema, schemaTransform) { return schemaTransform(schema); }, schemaFromTypeDefs);
 }
 
 exports.addCatchUndefinedToSchema = addCatchUndefinedToSchema;
@@ -780,6 +801,7 @@ exports.concatenateTypeDefs = concatenateTypeDefs;
 exports.decorateWithLogger = decorateWithLogger;
 exports.extendResolversFromInterfaces = extendResolversFromInterfaces;
 exports.extractExtensionDefinitions = extractExtensionDefinitions;
+exports.filterAndExtractExtensionDefinitions = filterAndExtractExtensionDefinitions;
 exports.filterExtensionDefinitions = filterExtensionDefinitions;
 exports.makeExecutableSchema = makeExecutableSchema;
 //# sourceMappingURL=index.cjs.js.map