Introduce computed fields

packages/delegate/src/types.ts

@@ -152,7 +152,7 @@ export interface SubschemaConfig<K = any, V = any, C = K> extends SubschemaPermu
 
 export interface MergedTypeConfig<K = any, V = any> {
   selectionSet?: string;
-  fields?: Record<string, { selectionSet?: string }>;
+  fields?: Record<string, MergedFieldConfig>;
   resolve?: MergedTypeResolver;
   fieldName?: string;
   args?: (originalResult: any) => Record<string, any>;
@@ -161,6 +161,10 @@ export interface MergedTypeConfig<K = any, V = any> {
   valuesFromResults?: (results: any, keys: ReadonlyArray<K>) => Array<V>;
 }
 
+export interface MergedFieldConfig {
+  selectionSet?: string;
+}
+
 export type MergedTypeResolver = (
   originalResult: any,
   context: Record<string, any>,

packages/stitch/src/index.ts

@@ -1,2 +1,4 @@
 export { stitchSchemas } from './stitchSchemas';
 export { forwardArgsToSelectionSet } from './selectionSetArgs';
+
+export { ComputedFieldsPlugin } from './plugins/computedFieldsPlugin';

packages/stitch/src/plugins/computedFieldsPlugin.ts

@@ -0,0 +1,167 @@
+import {
+  isSubschemaConfig,
+  SubschemaConfig,
+  MergedTypeConfig,
+  MergedFieldConfig,
+  Endpoint,
+} from '@graphql-tools/delegate';
+
+import { filterSchema, pruneSchema, getImplementingTypes } from '@graphql-tools/utils';
+
+import { GraphQLSchema, GraphQLObjectType, GraphQLInterfaceType } from 'graphql';
+
+import { IStitchSchemasOptions, StitchSchemasPlugin } from '../types';
+
+interface ComputedFieldConfig extends MergedFieldConfig {
+  computed?: string;
+}
+
+export class ComputedFieldsPlugin implements StitchSchemasPlugin {
+  public preconfigure(config: IStitchSchemasOptions): IStitchSchemasOptions {
+    if (config.subschemas) {
+      const mapped: Array<GraphQLSchema | SubschemaConfig | Array<SubschemaConfig>> = [];
+
+      config.subschemas.forEach(schemaLikeObject => {
+        if (isSubschemaConfig(schemaLikeObject) && schemaLikeObject.merge) {
+          mapped.push(...isolateComputedMergeSchemas(schemaLikeObject as SubschemaConfig));
+        } else {
+          mapped.push(schemaLikeObject);
+        }
+      });
+
+      config.subschemas = mapped;
+    }
+    return config;
+  }
+}
+
+function isolateComputedMergeSchemas(subschemaConfig: SubschemaConfig): Array<SubschemaConfig> {
+  const staticTypes: Record<string, MergedTypeConfig> = {};
+  const computedTypes: Record<string, MergedTypeConfig> = {};
+
+  Object.keys(subschemaConfig.merge).forEach((typeName: string) => {
+    const mergedTypeConfig: MergedTypeConfig = subschemaConfig.merge[typeName];
+    staticTypes[typeName] = mergedTypeConfig;
+
+    if (mergedTypeConfig.fields) {
+      const staticFields: Record<string, MergedFieldConfig> = {};
+      const computedFields: Record<string, MergedFieldConfig> = {};
+
+      Object.keys(mergedTypeConfig.fields).forEach((fieldName: string) => {
+        const mergedFieldConfig: ComputedFieldConfig = mergedTypeConfig.fields[fieldName] as ComputedFieldConfig;
+
+        if (mergedFieldConfig.selectionSet && mergedFieldConfig.computed) {
+          computedFields[fieldName] = mergedFieldConfig;
+        } else {
+          staticFields[fieldName] = mergedFieldConfig;
+        }
+        delete mergedFieldConfig.computed;
+      });
+
+      const computedFieldCount = Object.keys(computedFields).length;
+      const objectType = subschemaConfig.schema.getType(typeName) as GraphQLObjectType;
+
+      if (computedFieldCount && computedFieldCount !== Object.keys(objectType.getFields()).length) {
+        staticTypes[typeName] = {
+          ...mergedTypeConfig,
+          fields: Object.keys(staticFields).length ? staticFields : undefined,
+        };
+        computedTypes[typeName] = { ...mergedTypeConfig, fields: computedFields };
+      }
+    }
+  });
+
+  if (Object.keys(computedTypes).length) {
+    const endpoint = getSharedEndpoint(subschemaConfig);
+    return [
+      filterComputedSubschema({ ...subschemaConfig, endpoint, merge: computedTypes }),
+      filterStaticSubschema({ ...subschemaConfig, endpoint, merge: staticTypes }, computedTypes),
+    ];
+  }
+
+  return [subschemaConfig];
+}
+
+function getSharedEndpoint(subschemaConfig: SubschemaConfig): Endpoint {
+  if (subschemaConfig.endpoint) {
+    return subschemaConfig.endpoint;
+  } else if (subschemaConfig.executor) {
+    return {
+      executor: subschemaConfig.executor,
+      batch: true,
+    };
+  }
+}
+
+function filterStaticSubschema(
+  subschemaConfig: SubschemaConfig,
+  computedTypes: Record<string, MergedTypeConfig>
+): SubschemaConfig {
+  const typesForInterface: Record<string, string[]> = {};
+  subschemaConfig.schema = pruneSchema(
+    filterSchema({
+      schema: subschemaConfig.schema,
+      objectFieldFilter: (typeName: string, fieldName: string) =>
+        !(computedTypes[typeName] && computedTypes[typeName].fields[fieldName]),
+      interfaceFieldFilter: (typeName: string, fieldName: string) => {
+        if (!typesForInterface[typeName]) {
+          typesForInterface[typeName] = getImplementingTypes(typeName, subschemaConfig.schema);
+        }
+        return !typesForInterface[typeName].some(implementingTypeName => {
+          return computedTypes[implementingTypeName] && computedTypes[implementingTypeName].fields[fieldName];
+        });
+      },
+    }),
+    {
+      skipUnimplementedInterfacesPruning: true,
+    }
+  );
+
+  const remainingTypes = subschemaConfig.schema.getTypeMap();
+  Object.keys(subschemaConfig.merge).forEach(mergeType => {
+    if (!remainingTypes[mergeType]) {
+      delete subschemaConfig.merge[mergeType];
+    }
+  });
+
+  if (!Object.keys(subschemaConfig.merge).length) {
+    delete subschemaConfig.merge;
+  }
+
+  return subschemaConfig;
+}
+
+function filterComputedSubschema(subschemaConfig: SubschemaConfig): SubschemaConfig {
+  const rootFields: Record<string, boolean> = {};
+
+  Object.keys(subschemaConfig.merge).forEach(typeName => {
+    rootFields[subschemaConfig.merge[typeName].fieldName] = true;
+  });
+
+  const interfaceFields: Record<string, Record<string, boolean>> = {};
+  Object.keys(subschemaConfig.merge).forEach(typeName => {
+    (subschemaConfig.schema.getType(typeName) as GraphQLObjectType).getInterfaces().forEach(int => {
+      Object.keys((subschemaConfig.schema.getType(int.name) as GraphQLInterfaceType).getFields()).forEach(
+        intFieldName => {
+          if (subschemaConfig.merge[typeName].fields[intFieldName]) {
+            interfaceFields[int.name] = interfaceFields[int.name] || {};
+            interfaceFields[int.name][intFieldName] = true;
+          }
+        }
+      );
+    });
+  });
+
+  subschemaConfig.schema = pruneSchema(
+    filterSchema({
+      schema: subschemaConfig.schema,
+      rootFieldFilter: (operation: string, fieldName: string) => !!(operation === 'Query' && rootFields[fieldName]),
+      objectFieldFilter: (typeName: string, fieldName: string) =>
+        !!(subschemaConfig.merge[typeName] && subschemaConfig.merge[typeName].fields[fieldName]),
+      interfaceFieldFilter: (typeName: string, fieldName: string) =>
+        !!(interfaceFields[typeName] && interfaceFields[typeName][fieldName]),
+    })
+  );
+
+  return subschemaConfig;
+}

packages/stitch/src/stitchSchemas.ts

@@ -28,26 +28,32 @@ import { createStitchingInfo, completeStitchingInfo, addStitchingInfo } from './
 import { IStitchSchemasOptions } from './types';
 import { SubschemaConfig, isSubschemaConfig } from '@graphql-tools/delegate';
 
-export function stitchSchemas({
-  subschemas = [],
-  types = [],
-  typeDefs,
-  schemas = [],
-  onTypeConflict,
-  mergeDirectives,
-  mergeTypes = false,
-  typeMergingOptions,
-  resolvers = {},
-  schemaDirectives,
-  inheritResolversFromInterfaces = false,
-  logger,
-  allowUndefinedInResolve = true,
-  resolverValidationOptions = {},
-  directiveResolvers,
-  schemaTransforms = [],
-  parseOptions = {},
-  pruningOptions,
-}: IStitchSchemasOptions): GraphQLSchema {
+export function stitchSchemas(config: IStitchSchemasOptions): GraphQLSchema {
+  if (config.plugins) {
+    config = config.plugins.reduce((memo, plugin) => (plugin.preconfigure ? plugin.preconfigure(memo) : memo), config);
+  }
+
+  const {
+    subschemas = [],
+    types = [],
+    typeDefs,
+    schemas = [],
+    onTypeConflict,
+    mergeDirectives,
+    mergeTypes = false,
+    typeMergingOptions,
+    resolvers = {},
+    schemaDirectives,
+    inheritResolversFromInterfaces = false,
+    logger,
+    allowUndefinedInResolve = true,
+    resolverValidationOptions = {},
+    directiveResolvers,
+    schemaTransforms = [],
+    parseOptions = {},
+    pruningOptions,
+  } = config;
+
   if (typeof resolverValidationOptions !== 'object') {
     throw new Error('Expected `resolverValidationOptions` to be an object');
   }

packages/stitch/src/types.ts

@@ -68,6 +68,7 @@ export interface IStitchSchemasOptions<TContext = any> extends Omit<IExecutableS
   mergeDirectives?: boolean;
   mergeTypes?: boolean | Array<string> | MergeTypeFilter;
   typeMergingOptions?: TypeMergingOptions;
+  plugins?: Array<StitchSchemasPlugin>;
 }
 
 export interface TypeMergingOptions {
@@ -89,6 +90,10 @@ export type OnTypeConflict = (
   }
 ) => GraphQLNamedType;
 
+export interface StitchSchemasPlugin {
+  preconfigure?: (config: IStitchSchemasOptions) => IStitchSchemasOptions;
+}
+
 declare module '@graphql-tools/utils' {
   interface IFieldResolverOptions<TSource = any, TContext = any, TArgs = any> {
     fragment?: string;