@graphql-tools/utils 7.3.0 → 7.5.0

package/es5/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-tools/utils/es5",
-  "version": "7.3.0",
+  "version": "7.5.0",
   "description": "Common package containing utils and types for GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {

package/es5/print-schema-with-directives.d.ts

@@ -1,5 +1,6 @@
-import { GraphQLSchema, GraphQLNamedType, DirectiveNode, InputValueDefinitionNode, GraphQLArgument, GraphQLDirective, DirectiveDefinitionNode, SchemaDefinitionNode, SchemaExtensionNode, GraphQLObjectType, ObjectTypeDefinitionNode, GraphQLField, GraphQLInterfaceType, InterfaceTypeDefinitionNode, UnionTypeDefinitionNode, GraphQLUnionType, GraphQLInputObjectType, InputObjectTypeDefinitionNode, GraphQLInputField, GraphQLEnumType, GraphQLEnumValue, EnumTypeDefinitionNode } from 'graphql';
-import { PrintSchemaWithDirectivesOptions } from './types';
+import { GraphQLSchema, GraphQLNamedType, DirectiveNode, FieldDefinitionNode, InputValueDefinitionNode, GraphQLArgument, EnumValueDefinitionNode, GraphQLDirective, DirectiveDefinitionNode, SchemaDefinitionNode, SchemaExtensionNode, GraphQLObjectType, ObjectTypeDefinitionNode, GraphQLField, GraphQLInterfaceType, InterfaceTypeDefinitionNode, UnionTypeDefinitionNode, GraphQLUnionType, GraphQLInputObjectType, InputObjectTypeDefinitionNode, GraphQLInputField, GraphQLEnumType, GraphQLEnumValue, EnumTypeDefinitionNode, GraphQLScalarType, ScalarTypeDefinitionNode, DocumentNode } from 'graphql';
+import { GetDocumentNodeFromSchemaOptions, PrintSchemaWithDirectivesOptions } from './types';
+export declare function getDocumentNodeFromSchema(schema: GraphQLSchema, options?: GetDocumentNodeFromSchemaOptions): DocumentNode;
 export declare function printSchemaWithDirectives(schema: GraphQLSchema, options?: PrintSchemaWithDirectivesOptions): string;
 export declare function astFromSchema(schema: GraphQLSchema, pathToDirectivesInExtensions: Array<string>): SchemaDefinitionNode | SchemaExtensionNode;
 export declare function astFromDirective(directive: GraphQLDirective, schema: GraphQLSchema, pathToDirectivesInExtensions: Array<string>): DirectiveDefinitionNode;
@@ -11,6 +12,10 @@ export declare function astFromInterfaceType(type: GraphQLInterfaceType, schema:
 export declare function astFromUnionType(type: GraphQLUnionType, schema: GraphQLSchema, pathToDirectivesInExtensions: Array<string>): UnionTypeDefinitionNode;
 export declare function astFromInputObjectType(type: GraphQLInputObjectType, schema: GraphQLSchema, pathToDirectivesInExtensions: Array<string>): InputObjectTypeDefinitionNode;
 export declare function astFromEnumType(type: GraphQLEnumType, schema: GraphQLSchema, pathToDirectivesInExtensions: Array<string>): EnumTypeDefinitionNode;
+export declare function astFromScalarType(type: GraphQLScalarType, schema: GraphQLSchema, pathToDirectivesInExtensions: Array<string>): ScalarTypeDefinitionNode;
+export declare function astFromField(field: GraphQLField<any, any>, schema: GraphQLSchema, pathToDirectivesInExtensions: Array<string>): FieldDefinitionNode;
+export declare function astFromInputField(field: GraphQLInputField, schema: GraphQLSchema, pathToDirectivesInExtensions: Array<string>): InputValueDefinitionNode;
+export declare function astFromEnumValue(value: GraphQLEnumValue, schema: GraphQLSchema, pathToDirectivesInExtensions: Array<string>): EnumValueDefinitionNode;
 export declare function makeDeprecatedDirective(deprecationReason: string): DirectiveNode;
-export declare function makeDirective(name: string, args: Record<string, any>, directive: GraphQLDirective): DirectiveNode;
-export declare function makeDirectives(schema: GraphQLSchema, directiveValues: Record<string, any>): Array<DirectiveNode>;
+export declare function makeDirectiveNode(name: string, args: Record<string, any>, directive?: GraphQLDirective): DirectiveNode;
+export declare function makeDirectiveNodes(schema: GraphQLSchema, directiveValues: Record<string, any>): Array<DirectiveNode>;

package/es5/types.d.ts

@@ -10,9 +10,10 @@ export interface SchemaPrintOptions {
      */
     commentDescriptions?: boolean;
 }
-export interface PrintSchemaWithDirectivesOptions extends SchemaPrintOptions {
+export interface GetDocumentNodeFromSchemaOptions {
     pathToDirectivesInExtensions?: Array<string>;
 }
+export declare type PrintSchemaWithDirectivesOptions = SchemaPrintOptions & GetDocumentNodeFromSchemaOptions;
 export declare type Maybe<T> = null | undefined | T;
 export declare type Constructor<T> = new (...args: any[]) => T;
 /**

package/index.cjs.js

@@ -445,13 +445,11 @@ function astFromValueUntyped(value) {
  */
 const integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;
 
-// this approach uses the default schema printer rather than a custom solution, so may be more backwards compatible
-// currently does not allow customization of printSchema options having to do with comments.
-function printSchemaWithDirectives(schema, options = {}) {
+function getDocumentNodeFromSchema(schema, options = {}) {
     const pathToDirectivesInExtensions = options.pathToDirectivesInExtensions;
     const typesMap = schema.getTypeMap();
     const schemaNode = astFromSchema(schema, pathToDirectivesInExtensions);
-    const result = schemaNode != null ? [graphql.print(schemaNode)] : [];
+    const definitions = schemaNode != null ? [schemaNode] : [];
     for (const typeName in typesMap) {
         const type = typesMap[typeName];
         const isPredefinedScalar = graphql.isSpecifiedScalarType(type);
@@ -460,22 +458,22 @@ function printSchemaWithDirectives(schema, options = {}) {
             continue;
         }
         if (graphql.isObjectType(type)) {
-            result.push(graphql.print(astFromObjectType(type, schema, pathToDirectivesInExtensions)));
+            definitions.push(astFromObjectType(type, schema, pathToDirectivesInExtensions));
         }
         else if (graphql.isInterfaceType(type)) {
-            result.push(graphql.print(astFromInterfaceType(type, schema, pathToDirectivesInExtensions)));
+            definitions.push(astFromInterfaceType(type, schema, pathToDirectivesInExtensions));
         }
         else if (graphql.isUnionType(type)) {
-            result.push(graphql.print(astFromUnionType(type, schema, pathToDirectivesInExtensions)));
+            definitions.push(astFromUnionType(type, schema, pathToDirectivesInExtensions));
         }
         else if (graphql.isInputObjectType(type)) {
-            result.push(graphql.print(astFromInputObjectType(type, schema, pathToDirectivesInExtensions)));
+            definitions.push(astFromInputObjectType(type, schema, pathToDirectivesInExtensions));
         }
         else if (graphql.isEnumType(type)) {
-            result.push(graphql.print(astFromEnumType(type, schema, pathToDirectivesInExtensions)));
+            definitions.push(astFromEnumType(type, schema, pathToDirectivesInExtensions));
         }
         else if (graphql.isScalarType(type)) {
-            result.push(graphql.print(astFromScalarType(type, schema, pathToDirectivesInExtensions)));
+            definitions.push(astFromScalarType(type, schema, pathToDirectivesInExtensions));
         }
         else {
             throw new Error(`Unknown type ${type}.`);
@@ -486,9 +484,18 @@ function printSchemaWithDirectives(schema, options = {}) {
         if (graphql.isSpecifiedDirective(directive)) {
             continue;
         }
-        result.push(graphql.print(astFromDirective(directive, schema, pathToDirectivesInExtensions)));
+        definitions.push(astFromDirective(directive, schema, pathToDirectivesInExtensions));
     }
-    return result.join('\n');
+    return {
+        kind: graphql.Kind.DOCUMENT,
+        definitions,
+    };
+}
+// this approach uses the default schema printer rather than a custom solution, so may be more backwards compatible
+// currently does not allow customization of printSchema options having to do with comments.
+function printSchemaWithDirectives(schema, options = {}) {
+    const documentNode = getDocumentNodeFromSchema(schema, options);
+    return graphql.print(documentNode);
 }
 function astFromSchema(schema, pathToDirectivesInExtensions) {
     var _a, _b;
@@ -584,7 +591,7 @@ function getDirectiveNodes(entity, schema, pathToDirectivesInExtensions) {
     }
     let directives;
     if (directivesInExtensions != null) {
-        directives = makeDirectives(schema, directivesInExtensions);
+        directives = makeDirectiveNodes(schema, directivesInExtensions);
     }
     else {
         directives = [].concat(...nodes.filter(node => node.directives != null).map(node => node.directives));
@@ -598,7 +605,7 @@ function getDeprecatableDirectiveNodes(entity, schema, pathToDirectivesInExtensi
     const directivesInExtensions = getDirectivesInExtensions(entity, pathToDirectivesInExtensions);
     let directives;
     if (directivesInExtensions != null) {
-        directives = makeDirectives(schema, directivesInExtensions);
+        directives = makeDirectiveNodes(schema, directivesInExtensions);
     }
     else {
         directives = (_a = entity.astNode) === null || _a === void 0 ? void 0 : _a.directives;
@@ -732,10 +739,34 @@ function astFromEnumType(type, schema, pathToDirectivesInExtensions) {
     };
 }
 function astFromScalarType(type, schema, pathToDirectivesInExtensions) {
-    var _a, _b;
+    var _a, _b, _c, _d;
+    let directiveNodesBesidesSpecifiedBy = [];
+    let specifiedByDirectiveNode;
+    const directivesInExtensions = getDirectivesInExtensions(type, pathToDirectivesInExtensions);
+    let allDirectives;
+    if (directivesInExtensions != null) {
+        allDirectives = makeDirectiveNodes(schema, directivesInExtensions);
+    }
+    else {
+        allDirectives = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.directives;
+    }
+    if (allDirectives != null) {
+        directiveNodesBesidesSpecifiedBy = allDirectives.filter(directive => directive.name.value !== 'specifiedBy');
+        if (type.specifiedByUrl != null) {
+            specifiedByDirectiveNode = (_b = allDirectives.filter(directive => directive.name.value === 'specifiedBy')) === null || _b === void 0 ? void 0 : _b[0];
+        }
+    }
+    if (type.specifiedByUrl != null && specifiedByDirectiveNode == null) {
+        specifiedByDirectiveNode = makeDirectiveNode('specifiedBy', {
+            url: type.specifiedByUrl,
+        });
+    }
+    const directives = specifiedByDirectiveNode == null
+        ? directiveNodesBesidesSpecifiedBy
+        : [specifiedByDirectiveNode].concat(directiveNodesBesidesSpecifiedBy);
     return {
         kind: graphql.Kind.SCALAR_TYPE_DEFINITION,
-        description: ((_b = (_a = type.astNode) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : type.description) ? {
+        description: ((_d = (_c = type.astNode) === null || _c === void 0 ? void 0 : _c.description) !== null && _d !== void 0 ? _d : type.description) ? {
             kind: graphql.Kind.STRING,
             value: type.description,
             block: true,
@@ -745,7 +776,7 @@ function astFromScalarType(type, schema, pathToDirectivesInExtensions) {
             kind: graphql.Kind.NAME,
             value: type.name,
         },
-        directives: getDirectiveNodes(type, schema, pathToDirectivesInExtensions),
+        directives,
     };
 }
 function astFromField(field, schema, pathToDirectivesInExtensions) {
@@ -783,6 +814,7 @@ function astFromInputField(field, schema, pathToDirectivesInExtensions) {
         },
         type: astFromType(field.type),
         directives: getDeprecatableDirectiveNodes(field, schema, pathToDirectivesInExtensions),
+        defaultValue: graphql.astFromValue(field.defaultValue, field.type),
     };
 }
 function astFromEnumValue(value, schema, pathToDirectivesInExtensions) {
@@ -803,9 +835,9 @@ function astFromEnumValue(value, schema, pathToDirectivesInExtensions) {
     };
 }
 function makeDeprecatedDirective(deprecationReason) {
-    return makeDirective('deprecated', { reason: deprecationReason }, graphql.GraphQLDeprecatedDirective);
+    return makeDirectiveNode('deprecated', { reason: deprecationReason }, graphql.GraphQLDeprecatedDirective);
 }
-function makeDirective(name, args, directive) {
+function makeDirectiveNode(name, args, directive) {
     const directiveArguments = [];
     if (directive != null) {
         directive.args.forEach(arg => {
@@ -844,17 +876,17 @@ function makeDirective(name, args, directive) {
         arguments: directiveArguments,
     };
 }
-function makeDirectives(schema, directiveValues) {
+function makeDirectiveNodes(schema, directiveValues) {
     const directiveNodes = [];
     Object.entries(directiveValues).forEach(([directiveName, arrayOrSingleValue]) => {
         const directive = schema.getDirective(directiveName);
         if (Array.isArray(arrayOrSingleValue)) {
             arrayOrSingleValue.forEach(value => {
-                directiveNodes.push(makeDirective(directiveName, value, directive));
+                directiveNodes.push(makeDirectiveNode(directiveName, value, directive));
             });
         }
         else {
-            directiveNodes.push(makeDirective(directiveName, arrayOrSingleValue, directive));
+            directiveNodes.push(makeDirectiveNode(directiveName, arrayOrSingleValue, directive));
         }
     });
     return directiveNodes;
@@ -4235,7 +4267,7 @@ function isAsyncIterable(value) {
 }
 
 function isDocumentNode(object) {
-    return object.kind !== undefined;
+    return object && typeof object === 'object' && 'kind' in object && object.kind === graphql.Kind.DOCUMENT;
 }
 
 exports.SchemaDirectiveVisitor = SchemaDirectiveVisitor;
@@ -4248,9 +4280,13 @@ exports.asArray = asArray;
 exports.astFromArg = astFromArg;
 exports.astFromDirective = astFromDirective;
 exports.astFromEnumType = astFromEnumType;
+exports.astFromEnumValue = astFromEnumValue;
+exports.astFromField = astFromField;
+exports.astFromInputField = astFromInputField;
 exports.astFromInputObjectType = astFromInputObjectType;
 exports.astFromInterfaceType = astFromInterfaceType;
 exports.astFromObjectType = astFromObjectType;
+exports.astFromScalarType = astFromScalarType;
 exports.astFromSchema = astFromSchema;
 exports.astFromUnionType = astFromUnionType;
 exports.astFromValueUntyped = astFromValueUntyped;
@@ -4280,6 +4316,7 @@ exports.getDeprecatableDirectiveNodes = getDeprecatableDirectiveNodes;
 exports.getDirectiveNodes = getDirectiveNodes;
 exports.getDirectives = getDirectives;
 exports.getDirectivesInExtensions = getDirectivesInExtensions;
+exports.getDocumentNodeFromSchema = getDocumentNodeFromSchema;
 exports.getFieldsWithDirectives = getFieldsWithDirectives;
 exports.getImplementingTypes = getImplementingTypes;
 exports.getLeadingCommentBlock = getLeadingCommentBlock;
@@ -4299,8 +4336,8 @@ exports.isNamedStub = isNamedStub;
 exports.isNotEqual = isNotEqual;
 exports.isValidPath = isValidPath;
 exports.makeDeprecatedDirective = makeDeprecatedDirective;
-exports.makeDirective = makeDirective;
-exports.makeDirectives = makeDirectives;
+exports.makeDirectiveNode = makeDirectiveNode;
+exports.makeDirectiveNodes = makeDirectiveNodes;
 exports.mapAsyncIterator = mapAsyncIterator;
 exports.mapSchema = mapSchema;
 exports.mergeDeep = mergeDeep;