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

package/es5/makeExecutableSchema.d.ts

@@ -43,4 +43,4 @@ import { IExecutableSchemaDefinition } from './types';
  * })
  * ```
  */
-export declare function makeExecutableSchema<TContext = any>({ typeDefs, resolvers, logger, allowUndefinedInResolve, resolverValidationOptions, directiveResolvers, schemaDirectives, schemaTransforms, parseOptions, inheritResolversFromInterfaces, pruningOptions, }: IExecutableSchemaDefinition<TContext>): import("graphql").GraphQLSchema;
+export declare function makeExecutableSchema<TContext = any>({ typeDefs, resolvers, logger, allowUndefinedInResolve, resolverValidationOptions, directiveResolvers, schemaDirectives, schemaTransforms: userProvidedSchemaTransforms, parseOptions, inheritResolversFromInterfaces, pruningOptions, updateResolversInPlace, noExtensionExtraction, }: IExecutableSchemaDefinition<TContext>): import("graphql").GraphQLSchema;

package/es5/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@graphql-tools/schema/es5",
-  "version": "7.1.0-alpha-796c16fa.0",
+  "version": "7.1.2",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0"
   },
   "dependencies": {
-    "@graphql-tools/utils": "^7.0.0",
+    "@graphql-tools/utils": "^7.1.2",
     "tslib": "~2.0.1"
   },
   "repository": "git@github.com:ardatan/graphql-tools.git",

package/es5/types.d.ts

@@ -41,7 +41,7 @@ export interface IExecutableSchemaDefinition<TContext = any> {
     /**
      * An array of schema transformation functions
      */
-    schemaTransforms?: Array<(originalWrappingSchema: GraphQLSchema) => GraphQLSchema>;
+    schemaTransforms?: ExecutableSchemaTransformation[];
     /**
      * Additional options for parsing the type definitions if they are provided
      * as a string
@@ -56,4 +56,13 @@ export interface IExecutableSchemaDefinition<TContext = any> {
      * Additional options for removing unused types from the schema
      */
     pruningOptions?: PruneSchemaOptions;
+    /**
+     * Do not create a schema again and use the one from `buildASTSchema`
+     */
+    updateResolversInPlace?: boolean;
+    /**
+     * Do not extract and apply extensions seperately and leave it to `buildASTSchema`
+     */
+    noExtensionExtraction?: boolean;
 }
+export declare type ExecutableSchemaTransformation = (schema: GraphQLSchema) => GraphQLSchema;

package/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/index.cjs.js

@@ -148,73 +148,80 @@ function attachDirectiveResolvers(schema, directiveResolvers) {
     });
 }
 
-function extractExtensionDefinitions(ast) {
-    const extensionDefs = ast.definitions.filter((def) => 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);
+const isExtensionNode = (def) => 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) {
+    const extensionDefs = [];
+    const typesDefs = [];
+    ast.definitions.forEach(def => {
+        if (isExtensionNode(def)) {
+            extensionDefs.push(def);
+        }
+        else {
+            typesDefs.push(def);
+        }
+    });
     return {
-        ...ast,
-        definitions: extensionDefs,
+        typesAst: {
+            ...ast,
+            definitions: typesDefs,
+        },
+        extensionsAst: {
+            ...ast,
+            definitions: extensionDefs,
+        },
     };
 }
 function filterExtensionDefinitions(ast) {
-    const extensionDefs = ast.definitions.filter((def) => 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 {
-        ...ast,
-        definitions: extensionDefs,
-    };
+    const { typesAst } = filterAndExtractExtensionDefinitions(ast);
+    return typesAst;
+}
+function extractExtensionDefinitions(ast) {
+    const { extensionsAst } = filterAndExtractExtensionDefinitions(ast);
+    return extensionsAst;
 }
 
-function concatenateTypeDefs(typeDefinitionsAry, calledFunctionRefs = []) {
-    let resolvedTypeDefinitions = [];
+function concatenateTypeDefs(typeDefinitionsAry, calledFunctionRefs = new Set()) {
+    const resolvedTypeDefinitions = new Set();
     typeDefinitionsAry.forEach((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 {
             const type = typeof typeDef;
             throw new Error(`typeDef array must contain only strings, documents, or functions, got ${type}`);
         }
     });
-    return uniq(resolvedTypeDefinitions.map(x => x.trim())).join('\n');
-}
-function uniq(array) {
-    return array.reduce((accumulator, currentValue) => accumulator.indexOf(currentValue) === -1 ? [...accumulator, currentValue] : accumulator, []);
+    return [...resolvedTypeDefinitions].join('\n');
 }
 
-function buildSchemaFromTypeDefinitions(typeDefinitions, parseOptions) {
+function buildSchemaFromTypeDefinitions(typeDefinitions, parseOptions, noExtensionExtraction) {
     const document = buildDocumentFromTypeDefinitions(typeDefinitions, parseOptions);
-    const typesAst = filterExtensionDefinitions(document);
+    if (noExtensionExtraction) {
+        return graphql.buildASTSchema(document);
+    }
+    const { typesAst, extensionsAst } = filterAndExtractExtensionDefinitions(document);
     const backcompatOptions = { commentDescriptions: true };
     let schema = graphql.buildASTSchema(typesAst, backcompatOptions);
-    const 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) {
     let document;
     if (typeof typeDefinitions === 'string') {
@@ -223,7 +230,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 {
@@ -287,7 +294,7 @@ function decorateWithLogger(fn, logger, hint) {
 function checkForResolveTypeResolver(schema, requireResolversForResolveType) {
     utils.mapSchema(schema, {
         [utils.MapperKind.ABSTRACT_TYPE]: type => {
-            if (!type.resolveType && requireResolversForResolveType) {
+            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') {
@@ -423,7 +430,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) {
@@ -745,7 +754,7 @@ function addCatchUndefinedToSchema(schema) {
  * })
  * ```
  */
-function makeExecutableSchema({ typeDefs, resolvers = {}, logger, allowUndefinedInResolve = true, resolverValidationOptions = {}, directiveResolvers, schemaDirectives, schemaTransforms = [], parseOptions = {}, inheritResolversFromInterfaces = false, pruningOptions, }) {
+function makeExecutableSchema({ typeDefs, resolvers = {}, logger, allowUndefinedInResolve = true, resolverValidationOptions = {}, directiveResolvers, schemaDirectives, schemaTransforms: userProvidedSchemaTransforms, parseOptions = {}, inheritResolversFromInterfaces = false, pruningOptions, updateResolversInPlace = false, noExtensionExtraction = false, }) {
     // Validate and clean up arguments
     if (typeof resolverValidationOptions !== 'object') {
         throw new Error('Expected `resolverValidationOptions` to be an object');
@@ -753,42 +762,54 @@ function makeExecutableSchema({ typeDefs, resolvers = {}, logger, allowUndefined
     if (!typeDefs) {
         throw new Error('Must provide typeDefs');
     }
-    // We allow passing in an array of resolver maps, in which case we merge them
-    const resolverMap = Array.isArray(resolvers) ? resolvers.reduce(utils.mergeDeep, {}) : resolvers;
     // Arguments are now validated and cleaned up
-    let schema = buildSchemaFromTypeDefinitions(typeDefs, parseOptions);
-    schema = addResolversToSchema({
-        schema,
-        resolvers: resolverMap,
-        resolverValidationOptions,
-        inheritResolversFromInterfaces,
-    });
-    if (Object.keys(resolverValidationOptions).length > 0) {
-        assertResolversPresent(schema, resolverValidationOptions);
-    }
+    const schemaTransforms = [
+        schema => {
+            // We allow passing in an array of resolver maps, in which case we merge them
+            const resolverMap = Array.isArray(resolvers) ? resolvers.reduce(utils.mergeDeep, {}) : resolvers;
+            const schemaWithResolvers = addResolversToSchema({
+                schema,
+                resolvers: resolverMap,
+                resolverValidationOptions,
+                inheritResolversFromInterfaces,
+                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(schema => 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(schema => addSchemaLevelResolver(schema, resolvers['__schema']));
+    }
+    if (userProvidedSchemaTransforms) {
+        schemaTransforms.push(schema => userProvidedSchemaTransforms.reduce((s, schemaTransform) => schemaTransform(s), schema));
     }
-    schemaTransforms.forEach(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(schema => attachDirectiveResolvers(schema, directiveResolvers));
     }
     if (schemaDirectives != null) {
-        utils.SchemaDirectiveVisitor.visitSchemaDirectives(schema, schemaDirectives);
+        schemaTransforms.push(schema => {
+            utils.SchemaDirectiveVisitor.visitSchemaDirectives(schema, schemaDirectives);
+            return schema;
+        });
+    }
+    if (pruningOptions) {
+        schemaTransforms.push(utils.pruneSchema);
     }
-    return pruningOptions ? utils.pruneSchema(schema, pruningOptions) : schema;
+    const schemaFromTypeDefs = buildSchemaFromTypeDefinitions(typeDefs, parseOptions, noExtensionExtraction);
+    return schemaTransforms.reduce((schema, schemaTransform) => schemaTransform(schema), schemaFromTypeDefs);
 }
 
 exports.addCatchUndefinedToSchema = addCatchUndefinedToSchema;
@@ -805,6 +826,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