export toConfig functions not available in graphql-js (#1433)

* export toConfig functions not available in graphql-js * avoid type,toConfig() workaround now that fieldToFieldConfig available additional benefit of fieldToFieldConfig is that rootFieldTransformer and fieldTransform argumenst in TransformRootFields and TransformObjectFields expect functions that convert fields to fieldConfig, so now end users can easily create their own functions
ardatan · Apr 30, 2020 · 2b7508d · 2b7508d
1 parent 9329c1b
commit 2b7508d
Show file tree

Hide file tree

Showing 5 changed files with 77 additions and 21 deletions.
diff --git a/packages/utils/src/fields.ts b/packages/utils/src/fields.ts
@@ -1,26 +1,27 @@
 import { GraphQLFieldConfigMap, GraphQLObjectType, GraphQLFieldConfig } from 'graphql';
 
 import { TypeMap } from './Interfaces';
+import { fieldToFieldConfig } from './toConfig';
 
 export function appendFields(typeMap: TypeMap, typeName: string, fields: GraphQLFieldConfigMap<any, any>): void {
   let type = typeMap[typeName];
   if (type != null) {
-    const typeConfig = (type as GraphQLObjectType).toConfig();
-
-    const newFields: any = Object.entries(typeConfig.fields).reduce(
-      (prev, [key, val]) => ({
-        ...prev,
-        [key]: val,
+    const newFieldConfigMap: GraphQLFieldConfigMap<any, any> = Object.entries(
+      (type as GraphQLObjectType).getFields()
+    ).reduce(
+      (acc, [fieldName, field]) => ({
+        ...acc,
+        [fieldName]: fieldToFieldConfig(field),
       }),
       {}
     );
 
     Object.keys(fields).forEach(fieldName => {
-      newFields[fieldName] = fields[fieldName];
+      newFieldConfigMap[fieldName] = fields[fieldName];
     });
     type = new GraphQLObjectType({
-      ...typeConfig,
-      fields: newFields,
+      ...(type as GraphQLObjectType).toConfig(),
+      fields: newFieldConfigMap,
     });
   } else {
     type = new GraphQLObjectType({
@@ -37,19 +38,21 @@ export function removeFields(
   testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean
 ): GraphQLFieldConfigMap<any, any> {
   let type = typeMap[typeName];
-  const typeConfig = (type as GraphQLObjectType).toConfig();
-  const originalFields = typeConfig.fields;
+
+  const originalFields = (type as GraphQLObjectType).getFields();
   const newFields = {};
   const removedFields = {};
   Object.keys(originalFields).forEach(fieldName => {
-    if (testFn(fieldName, originalFields[fieldName])) {
-      removedFields[fieldName] = originalFields[fieldName];
+    const originalFieldConfig = fieldToFieldConfig(originalFields[fieldName]);
+    if (testFn(fieldName, originalFieldConfig)) {
+      removedFields[fieldName] = originalFieldConfig;
     } else {
-      newFields[fieldName] = originalFields[fieldName];
+      newFields[fieldName] = originalFieldConfig;
     }
   });
+
   type = new GraphQLObjectType({
-    ...typeConfig,
+    ...(type as GraphQLObjectType).toConfig(),
     fields: newFields,
   });
   typeMap[typeName] = type;

diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.ts
@@ -42,3 +42,4 @@ export * from './mapAsyncIterator';
 export * from './updateArgument';
 export * from './implementsAbstractType';
 export * from './errors';
+export * from './toConfig';
diff --git a/packages/utils/src/toConfig.ts b/packages/utils/src/toConfig.ts
@@ -0,0 +1,51 @@
+import {
+  GraphQLArgument,
+  GraphQLFieldConfigArgumentMap,
+  GraphQLField,
+  GraphQLInputField,
+  GraphQLInputFieldConfig,
+  GraphQLArgumentConfig,
+  GraphQLFieldConfig,
+} from 'graphql';
+
+export function inputFieldToFieldConfig(field: GraphQLInputField): GraphQLInputFieldConfig {
+  return {
+    description: field.description,
+    type: field.type,
+    defaultValue: field.defaultValue,
+    extensions: field.extensions,
+    astNode: field.astNode,
+  };
+}
+
+export function fieldToFieldConfig(field: GraphQLField<any, any>): GraphQLFieldConfig<any, any> {
+  return {
+    description: field.description,
+    type: field.type,
+    args: argsToFieldConfigArgumentMap(field.args),
+    resolve: field.resolve,
+    subscribe: field.subscribe,
+    deprecationReason: field.deprecationReason,
+    extensions: field.extensions,
+    astNode: field.astNode,
+  };
+}
+
+export function argsToFieldConfigArgumentMap(args: ReadonlyArray<GraphQLArgument>): GraphQLFieldConfigArgumentMap {
+  const newArguments = {};
+  args.forEach(arg => {
+    newArguments[arg.name] = argumentToArgumentConfig(arg);
+  });
+
+  return newArguments;
+}
+
+export function argumentToArgumentConfig(arg: GraphQLArgument): GraphQLArgumentConfig {
+  return {
+    description: arg.description,
+    type: arg.type,
+    defaultValue: arg.defaultValue,
+    extensions: arg.extensions,
+    astNode: arg.astNode,
+  };
+}
diff --git a/packages/wrap/src/transforms/TransformCompositeFields.ts b/packages/wrap/src/transforms/TransformCompositeFields.ts
@@ -23,6 +23,7 @@ import {
   FieldNodeTransformer,
   RenamedFieldConfig,
   mapSchema,
+  fieldToFieldConfig,
 } from '@graphql-tools/utils';
 
 export default class TransformCompositeFields implements Transform {
@@ -70,7 +71,6 @@ export default class TransformCompositeFields implements Transform {
   private transformFields(type: GraphQLInterfaceType, fieldTransformer: FieldTransformer): GraphQLInterfaceType;
 
   private transformFields(type: GraphQLObjectType | GraphQLInterfaceType, fieldTransformer: FieldTransformer): any {
-    const typeConfig = type.toConfig();
     const fields = type.getFields();
     const newFields = {};
 
@@ -79,15 +79,15 @@ export default class TransformCompositeFields implements Transform {
       const transformedField = fieldTransformer(type.name, fieldName, field);
 
       if (typeof transformedField === 'undefined') {
-        newFields[fieldName] = typeConfig.fields[fieldName];
+        newFields[fieldName] = fieldToFieldConfig(fields[fieldName]);
       } else if (transformedField !== null) {
         const newName = (transformedField as RenamedFieldConfig).name;
 
         if (newName) {
           newFields[newName] =
             (transformedField as RenamedFieldConfig).field != null
               ? (transformedField as RenamedFieldConfig).field
-              : typeConfig.fields[fieldName];
+              : fieldToFieldConfig(fields[fieldName]);
 
           if (newName !== fieldName) {
             const typeName = type.name;

diff --git a/packages/wrap/src/wrapSchema.ts b/packages/wrap/src/wrapSchema.ts
@@ -6,7 +6,7 @@ import {
   GraphQLFieldResolver,
 } from 'graphql';
 
-import { Transform, MapperKind, mapSchema, applySchemaTransforms } from '@graphql-tools/utils';
+import { Transform, MapperKind, mapSchema, applySchemaTransforms, fieldToFieldConfig } from '@graphql-tools/utils';
 
 import { SubschemaConfig, isSubschemaConfig, defaultMergedResolver } from '@graphql-tools/delegate';
 import { generateProxyingResolvers } from './generateProxyingResolvers';
@@ -45,9 +45,10 @@ function createWrappingSchema(
     [MapperKind.ROOT_OBJECT]: type => {
       const config = type.toConfig();
 
-      Object.keys(config.fields).forEach(fieldName => {
+      const fields = type.getFields();
+      Object.keys(fields).forEach(fieldName => {
         config.fields[fieldName] = {
-          ...config.fields[fieldName],
+          ...fieldToFieldConfig(fields[fieldName]),
           ...proxyingResolvers[type.name][fieldName],
         };
       });