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:/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), {});
+ }
+}