Use field configs

packages/stitch/src/mergeInfo.ts

@@ -16,7 +16,8 @@ import {
   TypeMap,
   IResolvers,
   IFieldResolverOptions,
-  mapSchemaByField,
+  mapSchema,
+  MapperKind,
 } from '@graphql-tools/utils';
 
 import { delegateToSchema, isSubschemaConfig, SubschemaConfig } from '@graphql-tools/delegate';
@@ -217,17 +218,20 @@ export function completeMergeInfo(mergeInfo: MergeInfo, resolvers: IResolvers):
 }
 
 export function addMergeInfo(stitchedSchema: GraphQLSchema, mergeInfo: MergeInfo): GraphQLSchema {
-  return mapSchemaByField(stitchedSchema, ([fieldName, originalFieldConfig]) => {
-    const newFieldConfig = { ...originalFieldConfig };
-    const resolver = originalFieldConfig.resolve;
-    if (resolver != null) {
-      newFieldConfig.resolve = (parent, args, context, info) => resolver(parent, args, context, { ...info, mergeInfo });
-    }
-    const subscriber = originalFieldConfig.subscribe;
-    if (subscriber != null) {
-      newFieldConfig.subscribe = (parent, args, context, info) =>
-        subscriber(parent, args, context, { ...info, mergeInfo });
-    }
-    return [fieldName, newFieldConfig];
+  return mapSchema(stitchedSchema, {
+    [MapperKind.OBJECT_FIELD]: originalFieldConfig => {
+      const newFieldConfig = { ...originalFieldConfig };
+      const resolver = originalFieldConfig.resolve;
+      if (resolver != null) {
+        newFieldConfig.resolve = (parent, args, context, info) =>
+          resolver(parent, args, context, { ...info, mergeInfo });
+      }
+      const subscriber = originalFieldConfig.subscribe;
+      if (subscriber != null) {
+        newFieldConfig.subscribe = (parent, args, context, info) =>
+          subscriber(parent, args, context, { ...info, mergeInfo });
+      }
+      return newFieldConfig;
+    },
   });
 }

packages/stitch/tests/alternateStitchSchemas.test.ts

@@ -9,12 +9,10 @@ import {
   FieldNode,
   printSchema,
   graphqlSync,
-  GraphQLField,
   assertValidSchema,
   GraphQLFieldConfig,
   isSpecifiedScalarType,
   GraphQLNamedType,
-  GraphQLFieldConfigArgumentMap,
 } from 'graphql';
 
 import {
@@ -355,26 +353,15 @@ describe('transform object fields', () => {
         (
           typeName: string,
           fieldName: string,
-          field: GraphQLField<any, any>,
+          fieldConfig: GraphQLFieldConfig<any, any>,
         ) => {
           if (typeName !== 'Property' || fieldName !== 'name') {
             return undefined;
           }
           return {
-            description: field.deprecationReason,
-            type: field.type,
-            args: field.args.reduce<GraphQLFieldConfigArgumentMap>(
-              (prev, curr) => ({
-                ...prev,
-                [curr.name]: curr,
-              }),
-              {},
-            ),
+            ...fieldConfig,
+            description: fieldConfig.deprecationReason,
             resolve: () => 'test',
-            subscribe: field.subscribe,
-            deprecationReason: field.deprecationReason,
-            extensions: field.extensions,
-            astNode: field.astNode,
           };
         },
         (typeName: string, fieldName: string, fieldNode: FieldNode) => {
@@ -434,27 +421,23 @@ describe('default values', () => {
         (
           typeName: string,
           fieldName: string,
-          field: GraphQLField<any, any>,
+          fieldConfig: GraphQLFieldConfig<any, any>,
         ) => {
           if (typeName === 'Query' && fieldName === 'jsonTest') {
-            const fieldConfig: GraphQLFieldConfig<any, any> = {
-              description: field.deprecationReason,
-              type: field.type,
-              args: field.args.reduce<GraphQLFieldConfigArgumentMap>(
-                (prev, curr) => ({
-                  ...prev,
-                  [curr.name]: curr,
-                }),
-                {},
-              ),
-              resolve: field.resolve,
-              subscribe: field.subscribe,
-              deprecationReason: field.deprecationReason,
-              extensions: field.extensions,
-              astNode: field.astNode,
-            };
-            fieldConfig.args.input.defaultValue = { test: 'test' };
-            return { name: 'renamedJsonTest', field: fieldConfig };
+            return [
+              'renamedJsonTest',
+              {
+                ...fieldConfig,
+                description: fieldConfig.deprecationReason,
+                args: {
+                  ...fieldConfig.args,
+                  input: {
+                    ...fieldConfig.args.input,
+                    defaultValue: { test: 'test' }
+                  }
+                }
+              }
+            ];
           }
         },
       ),

packages/utils/src/Interfaces.ts

@@ -25,6 +25,7 @@ import {
   GraphQLOutputType,
   FieldDefinitionNode,
   GraphQLFieldConfig,
+  GraphQLInputFieldConfig,
 } from 'graphql';
 
 import { SchemaVisitor } from './SchemaVisitor';
@@ -130,12 +131,16 @@ export type FieldNodeMapper = (
 
 export type FieldNodeMappers = Record<string, Record<string, FieldNodeMapper>>;
 
-export type FieldFilter = (typeName?: string, fieldName?: string, field?: GraphQLField<any, any>) => boolean;
+export type FieldFilter = (
+  typeName?: string,
+  fieldName?: string,
+  fieldConfig?: GraphQLFieldConfig<any, any>
+) => boolean;
 
 export type RootFieldFilter = (
   operation?: 'Query' | 'Mutation' | 'Subscription',
   rootFieldName?: string,
-  field?: GraphQLField<any, any>
+  fieldConfig?: GraphQLFieldConfig<any, any>
 ) => boolean;
 
 export type RenameTypesOptions = {
@@ -353,6 +358,15 @@ export enum MapperKind {
   MUTATION = 'MapperKind.MUTATION',
   SUBSCRIPTION = 'MapperKind.SUBSCRIPTION',
   DIRECTIVE = 'MapperKind.DIRECTIVE',
+  FIELD = 'MapperKind.FIELD',
+  COMPOSITE_FIELD = 'MapperKind.COMPOSITE_FIELD',
+  OBJECT_FIELD = 'MapperKind.OBJECT_FIELD',
+  ROOT_FIELD = 'MapperKind.ROOT_FIELD',
+  QUERY_ROOT_FIELD = 'MapperKind.QUERY_ROOT_FIELD',
+  MUTATION_ROOT_FIELD = 'MapperKind.MUTATION_ROOT_FIELD',
+  SUBSCRIPTION_ROOT_FIELD = 'MapperKind.SUBSCRIPTION_ROOT_FIELD',
+  INTERFACE_FIELD = 'MapperKind.INTERFACE_FIELD',
+  INPUT_OBJECT_FIELD = 'MapperKind.INPUT_OBJECT_FIELD',
 }
 
 export interface SchemaMapper {
@@ -370,6 +384,13 @@ export interface SchemaMapper {
   [MapperKind.MUTATION]?: ObjectTypeMapper;
   [MapperKind.SUBSCRIPTION]?: ObjectTypeMapper;
   [MapperKind.DIRECTIVE]?: DirectiveMapper;
+  [MapperKind.OBJECT_FIELD]?: ObjectFieldMapper;
+  [MapperKind.ROOT_FIELD]?: ObjectFieldMapper;
+  [MapperKind.QUERY_ROOT_FIELD]?: ObjectFieldMapper;
+  [MapperKind.MUTATION_ROOT_FIELD]?: ObjectFieldMapper;
+  [MapperKind.SUBSCRIPTION_ROOT_FIELD]?: ObjectFieldMapper;
+  [MapperKind.INTERFACE_FIELD]?: InterfaceFieldMapper;
+  [MapperKind.INPUT_OBJECT_FIELD]?: InputObjectFieldMapper;
 }
 
 export type NamedTypeMapper = (type: GraphQLNamedType, schema: GraphQLSchema) => GraphQLNamedType | null | undefined;
@@ -407,6 +428,13 @@ export type DirectiveMapper = (
   schema: GraphQLSchema
 ) => GraphQLDirective | null | undefined;
 
-export type FieldMapper = (
-  originalField: [string, GraphQLFieldConfig<any, any>]
-) => [string, GraphQLFieldConfig<any, any>] | null | undefined;
+export type FieldMapper<
+  F extends GraphQLFieldConfig<any, any> | GraphQLInputFieldConfig,
+  T extends GraphQLObjectType | GraphQLInterfaceType | GraphQLInputObjectType
+> = (fieldConfig: F, fieldName: string, type: T, schema: GraphQLSchema) => F | [string, F] | null | undefined;
+
+export type ObjectFieldMapper = FieldMapper<GraphQLFieldConfig<any, any>, GraphQLObjectType>;
+
+export type InterfaceFieldMapper = FieldMapper<GraphQLFieldConfig<any, any>, GraphQLInterfaceType>;
+
+export type InputObjectFieldMapper = FieldMapper<GraphQLInputFieldConfig, GraphQLInputObjectType>;

packages/utils/src/fields.ts

@@ -1,61 +1,131 @@
-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 newFieldConfigMap: GraphQLFieldConfigMap<any, any> = Object.entries(
-      (type as GraphQLObjectType).getFields()
-    ).reduce(
-      (acc, [fieldName, field]) => ({
-        ...acc,
-        [fieldName]: fieldToFieldConfig(field),
-      }),
-      {}
-    );
-
-    Object.keys(fields).forEach(fieldName => {
-      newFieldConfigMap[fieldName] = fields[fieldName];
+import { GraphQLFieldConfigMap, GraphQLObjectType, GraphQLFieldConfig, GraphQLSchema } from 'graphql';
+import { MapperKind } from './Interfaces';
+import { mapSchema } from './mapSchema';
+import { rewireTypes } from './rewire';
+
+export function modifyFields(
+  schema: GraphQLSchema,
+  {
+    append = [],
+    remove = [],
+  }: {
+    append?: Array<{ typeName: string; additionalFields: GraphQLFieldConfigMap<any, any> }>;
+    remove?: Array<{
+      typeName: string;
+      testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean;
+    }>;
+  }
+): GraphQLSchema {
+  const queryType = schema.getQueryType();
+  const mutationType = schema.getMutationType();
+  const subscriptionType = schema.getSubscriptionType();
+
+  const queryTypeName = queryType != null ? queryType.name : undefined;
+  const mutationTypeName = mutationType != null ? mutationType.name : undefined;
+  const subscriptionTypeName = subscriptionType != null ? subscriptionType.name : undefined;
+
+  const config = schema.toConfig();
+
+  const originalTypeMap = {};
+  config.types.forEach(type => {
+    originalTypeMap[type.name] = type;
+  });
+
+  remove.forEach(({ typeName, testFn }) => {
+    const config = (originalTypeMap[typeName] as GraphQLObjectType).toConfig();
+    const originalFieldConfigMap = config.fields;
+    const newFieldConfigMap = {};
+    Object.keys(originalFieldConfigMap).forEach(fieldName => {
+      if (!testFn(fieldName, originalFieldConfigMap[fieldName])) {
+        newFieldConfigMap[fieldName] = originalFieldConfigMap[fieldName];
+      }
     });
-    type = new GraphQLObjectType({
-      ...(type as GraphQLObjectType).toConfig(),
+    originalTypeMap[typeName] = new GraphQLObjectType({
+      ...config,
       fields: newFieldConfigMap,
     });
-  } else {
-    type = new GraphQLObjectType({
-      name: typeName,
-      fields,
-    });
-  }
-  typeMap[typeName] = type;
+  });
+
+  append.forEach(({ typeName, additionalFields }) => {
+    if (originalTypeMap[typeName] == null) {
+      originalTypeMap[typeName] = new GraphQLObjectType({
+        name: typeName,
+        fields: additionalFields,
+      });
+    } else {
+      const config = (originalTypeMap[typeName] as GraphQLObjectType).toConfig();
+      const originalFieldConfigMap = config.fields;
+      const newFieldConfigMap = {};
+      Object.keys(originalFieldConfigMap).forEach(fieldName => {
+        newFieldConfigMap[fieldName] = originalFieldConfigMap[fieldName];
+      });
+      Object.keys(additionalFields).forEach(fieldName => {
+        newFieldConfigMap[fieldName] = additionalFields[fieldName];
+      });
+      originalTypeMap[typeName] = new GraphQLObjectType({
+        ...config,
+        fields: newFieldConfigMap,
+      });
+    }
+  });
+
+  const { typeMap, directives } = rewireTypes(originalTypeMap, config.directives);
+
+  return new GraphQLSchema({
+    ...config,
+    query: queryTypeName ? (typeMap[queryTypeName] as GraphQLObjectType) : undefined,
+    mutation: mutationTypeName ? (typeMap[mutationTypeName] as GraphQLObjectType) : undefined,
+    subscription: subscriptionTypeName != null ? (typeMap[subscriptionTypeName] as GraphQLObjectType) : undefined,
+    types: Object.keys(typeMap).map(typeName => typeMap[typeName]),
+    directives,
+  });
+}
+
+export function appendFields(
+  schema: GraphQLSchema,
+  typeName: string,
+  additionalFields: GraphQLFieldConfigMap<any, any>
+): GraphQLSchema {
+  return modifyFields(schema, { append: [{ typeName, additionalFields }] });
 }
 
 export function removeFields(
-  typeMap: TypeMap,
+  schema: GraphQLSchema,
   typeName: string,
   testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean
-): GraphQLFieldConfigMap<any, any> {
-  let type = typeMap[typeName];
-
-  const originalFields = (type as GraphQLObjectType).getFields();
-  const newFields = {};
-  const removedFields = {};
-  Object.keys(originalFields).forEach(fieldName => {
-    const originalFieldConfig = fieldToFieldConfig(originalFields[fieldName]);
-    if (testFn(fieldName, originalFieldConfig)) {
-      removedFields[fieldName] = originalFieldConfig;
-    } else {
-      newFields[fieldName] = originalFieldConfig;
-    }
+): [GraphQLSchema, GraphQLFieldConfigMap<any, any>] {
+  const selectedFields = getFields(schema, typeName, testFn);
+  const selectedFieldNames = Object.keys(selectedFields);
+  const newSchema = modifyFields(schema, {
+    remove: [{ typeName, testFn: fieldName => selectedFieldNames.includes(fieldName) }],
   });
 
-  type = new GraphQLObjectType({
-    ...(type as GraphQLObjectType).toConfig(),
-    fields: newFields,
+  return [newSchema, selectedFields];
+}
+
+export function getFields(
+  schema: GraphQLSchema,
+  typeName: string,
+  testFn: (fieldName: string, field: GraphQLFieldConfig<any, any>) => boolean
+): GraphQLFieldConfigMap<any, any> {
+  const selectedFields = {};
+  mapSchema(schema, {
+    [MapperKind.OBJECT_TYPE]: type => {
+      if (type.name === typeName) {
+        const config = type.toConfig();
+        const originalFieldConfigMap = config.fields;
+
+        Object.keys(originalFieldConfigMap).forEach(fieldName => {
+          const originalFieldConfig = originalFieldConfigMap[fieldName];
+          if (testFn(fieldName, originalFieldConfig)) {
+            selectedFields[fieldName] = originalFieldConfig;
+          }
+        });
+      }
+
+      return undefined;
+    },
   });
-  typeMap[typeName] = type;
 
-  return removedFields;
+  return selectedFields;
 }