Add federation support

.prettierrc

@@ -1,4 +1,5 @@
 {
+  "printWidth": 100,
   "trailingComma": "all",
   "singleQuote": true
 }

lib/decorators/index.ts

@@ -6,6 +6,7 @@ export * from './mutation.decorator';
 export * from './parent.decorator';
 export * from './query.decorator';
 export * from './resolve-property.decorator';
+export * from './resolve-reference.decorator';
 export * from './resolver.decorator';
 export * from './root.decorator';
 export * from './scalar.decorator';

lib/decorators/resolve-reference.decorator.ts

@@ -0,0 +1,8 @@
+import { RESOLVER_REFERENCE_METADATA } from '../graphql.constants';
+import { SetMetadata } from '@nestjs/common';
+
+export function ResolveReference(): MethodDecorator {
+  return (target: Function | Object, key?: string | symbol, descriptor?: any) => {
+    SetMetadata(RESOLVER_REFERENCE_METADATA, true)(target, key, descriptor);
+  };
+}

lib/external/type-graphql.types.ts

@@ -1,5 +1,5 @@
 import { Type } from '@nestjs/common';
-import { GraphQLScalarType } from 'graphql';
+import { GraphQLDirective, GraphQLScalarType } from 'graphql';
 
 /**
  * Some external types have to be included in order to provide types safety
@@ -8,12 +8,7 @@ import { GraphQLScalarType } from 'graphql';
  * see: https://github.com/19majkel94/type-graphql
  * 0.16.0
  */
-export type TypeValue =
-  | Type<any>
-  | GraphQLScalarType
-  | Function
-  | object
-  | symbol;
+export type TypeValue = Type<any> | GraphQLScalarType | Function | object | symbol;
 export type ReturnTypeFuncValue = TypeValue | [TypeValue];
 export type ReturnTypeFunc = (returns?: void) => ReturnTypeFuncValue;
 export type NullableListOptions = 'items' | 'itemsAndList';
@@ -38,12 +33,14 @@ export interface ResolverClassOptions {
 }
 export type ClassTypeResolver = (of?: void) => Type<any>;
 export type BasicOptions = DecoratorTypeOptions & DescriptionOptions;
-export type AdvancedOptions = BasicOptions &
-  DepreciationOptions &
-  SchemaNameOptions;
+export type AdvancedOptions = BasicOptions & DepreciationOptions & SchemaNameOptions;
+
 export interface BuildSchemaOptions {
   dateScalarMode?: DateScalarMode;
   scalarsMap?: ScalarsTypeMap[];
+  /** Any types that are not directly referenced or returned by resolvers */
+  orphanedTypes?: Function[];
+  directives?: GraphQLDirective[];
 }
 export type DateScalarMode = 'isoDate' | 'timestamp';
 export interface ScalarsTypeMap {

lib/graphql-definitions.factory.ts

@@ -1,11 +1,12 @@
 import { isEmpty } from '@nestjs/common/utils/shared.utils';
+import { loadPackage } from '@nestjs/common/utils/load-package.util';
 import { gql } from 'apollo-server-core';
 import { makeExecutableSchema } from 'graphql-tools';
 import * as chokidar from 'chokidar';
 import { printSchema } from 'graphql';
 import { GraphQLAstExplorer } from './graphql-ast.explorer';
 import { GraphQLTypesLoader } from './graphql-types.loader';
-import { removeTempField } from './utils/remove-temp.util';
+import { removeTempField, extend } from './utils';
 
 export class GraphQLDefinitionsFactory {
   private readonly gqlAstExplorer = new GraphQLAstExplorer();
@@ -17,17 +18,16 @@ export class GraphQLDefinitionsFactory {
     outputAs?: 'class' | 'interface';
     watch?: boolean;
     debug?: boolean;
+    federation?: boolean;
   }) {
     const isDebugEnabled = !(options && options.debug === false);
     const typePathsExists = options.typePaths && !isEmpty(options.typePaths);
+    const isFederation = options && options.federation;
     if (!typePathsExists) {
       throw new Error(`"typePaths" property cannot be empty.`);
     }
     if (options.watch) {
-      this.printMessage(
-        'GraphQL factory is watching your files...',
-        isDebugEnabled,
-      );
+      this.printMessage('GraphQL factory is watching your files...', isDebugEnabled);
       const watcher = chokidar.watch(options.typePaths);
       watcher.on('change', async file => {
         this.printMessage(
@@ -38,6 +38,7 @@ export class GraphQLDefinitionsFactory {
           options.typePaths,
           options.path,
           options.outputAs,
+          isFederation,
           isDebugEnabled,
         );
       });
@@ -46,6 +47,7 @@ export class GraphQLDefinitionsFactory {
       options.typePaths,
       options.path,
       options.outputAs,
+      isFederation,
       isDebugEnabled,
     );
   }
@@ -54,11 +56,55 @@ export class GraphQLDefinitionsFactory {
     typePaths: string[],
     path: string,
     outputAs: 'class' | 'interface',
+    isFederation: boolean,
     isDebugEnabled: boolean,
   ) {
-    const typeDefs = await this.gqlTypesLoader.mergeTypesByPaths(
-      typePaths || [],
+    if (isFederation) {
+      return this.exploreAndEmitFederation(typePaths, path, outputAs, isDebugEnabled);
+    }
+    return this.exploreAndEmitRegular(typePaths, path, outputAs, isDebugEnabled);
+  }
+
+  private async exploreAndEmitFederation(
+    typePaths: string[],
+    path: string,
+    outputAs: 'class' | 'interface',
+    isDebugEnabled: boolean,
+  ) {
+    const typeDefs = await this.gqlTypesLoader.mergeTypesByPaths(typePaths);
+
+    const { buildFederatedSchema } = loadPackage('@apollo/federation', 'ApolloFederation');
+    const { printSchema } = loadPackage('@apollo/federation', 'ApolloFederation');
+
+    const schema = buildFederatedSchema([
+      {
+        typeDefs: gql`
+          ${typeDefs}
+        `,
+        resolvers: {},
+      },
+    ]);
+    const tsFile = await this.gqlAstExplorer.explore(
+      gql`
+        ${printSchema(schema)}
+      `,
+      path,
+      outputAs,
+    );
+    await tsFile.save();
+    this.printMessage(
+      `[${new Date().toLocaleTimeString()}] The definitions have been updated.`,
+      isDebugEnabled,
     );
+  }
+
+  private async exploreAndEmitRegular(
+    typePaths: string[],
+    path: string,
+    outputAs: 'class' | 'interface',
+    isDebugEnabled: boolean,
+  ) {
+    const typeDefs = await this.gqlTypesLoader.mergeTypesByPaths(typePaths || []);
     if (!typeDefs) {
       throw new Error(`"typeDefs" property cannot be null.`);
     }

lib/graphql-federation.factory.ts

@@ -0,0 +1,100 @@
+import { Injectable } from '@nestjs/common';
+import { gql } from 'apollo-server-core';
+import { loadPackage } from '@nestjs/common/utils/load-package.util';
+import { extend } from './utils';
+import { isEmpty, forEach } from 'lodash';
+import {
+  ScalarsExplorerService,
+  DelegatesExplorerService,
+  ResolversExplorerService,
+} from './services';
+import { mergeSchemas } from 'graphql-tools';
+import { GqlModuleOptions } from './interfaces';
+import { GraphQLSchemaBuilder } from './graphql-schema-builder';
+import { GraphQLFactory } from './graphql.factory';
+import { GraphQLSchema, GraphQLSchemaConfig } from 'graphql';
+import { GraphQLObjectType } from 'graphql';
+
+@Injectable()
+export class GraphQLFederationFactory {
+  constructor(
+    private readonly resolversExplorerService: ResolversExplorerService,
+    private readonly delegatesExplorerService: DelegatesExplorerService,
+    private readonly scalarsExplorerService: ScalarsExplorerService,
+    private readonly gqlSchemaBuilder: GraphQLSchemaBuilder,
+    private readonly graphqlFactory: GraphQLFactory,
+  ) {}
+
+  async mergeOptions(options: GqlModuleOptions = {}): Promise<GqlModuleOptions> {
+    const transformSchema = async s => (options.transformSchema ? options.transformSchema(s) : s);
+
+    let schema: GraphQLSchema;
+    if (options.autoSchemaFile) {
+      // Enable support when Directive support in type-graphql goes stable
+      throw new Error('Code-first not supported yet');
+      schema = await this.generateSchema(options);
+    } else if (isEmpty(options.typeDefs)) {
+      schema = options.schema;
+    } else {
+      schema = this.buildSchemaFromTypeDefs(options);
+    }
+
+    return {
+      ...options,
+      schema: await transformSchema(schema),
+      typeDefs: undefined,
+    };
+  }
+
+  private buildSchemaFromTypeDefs(options: GqlModuleOptions) {
+    const { buildFederatedSchema } = loadPackage('@apollo/federation', 'ApolloFederation');
+
+    return buildFederatedSchema([
+      {
+        typeDefs: gql`
+          ${options.typeDefs}
+        `,
+        resolvers: this.getResolvers(options.resolvers),
+      },
+    ]);
+  }
+
+  private async generateSchema(options: GqlModuleOptions): Promise<GraphQLSchema> {
+    const { buildFederatedSchema, printSchema } = loadPackage(
+      '@apollo/federation',
+      'ApolloFederation',
+    );
+
+    const autoGeneratedSchema: GraphQLSchema = await this.gqlSchemaBuilder.buildFederatedSchema(
+      options.autoSchemaFile,
+      options.buildSchemaOptions,
+      this.resolversExplorerService.getAllCtors(),
+    );
+    const executableSchema = buildFederatedSchema({
+      typeDefs: gql(printSchema(autoGeneratedSchema)),
+      resolvers: this.getResolvers(options.resolvers),
+    });
+
+    const schema = options.schema
+      ? mergeSchemas({
+          schemas: [options.schema, executableSchema],
+        })
+      : executableSchema;
+
+    return schema;
+  }
+
+  private getResolvers(optionResolvers) {
+    optionResolvers = Array.isArray(optionResolvers) ? optionResolvers : [optionResolvers];
+    return this.extendResolvers([
+      this.resolversExplorerService.explore(),
+      this.delegatesExplorerService.explore(),
+      ...this.scalarsExplorerService.explore(),
+      ...optionResolvers,
+    ]);
+  }
+
+  private extendResolvers(resolvers: any[]) {
+    return resolvers.reduce((prev, curr) => extend(prev, curr), {});
+  }
+}