feat(federation): add TypeGraphQLFederationModule

Author: MichalLytek

README.md

@@ -126,6 +126,57 @@ Example of using the config service to generate `TypeGraphQLModule` options:
 export default class AppModule {}
 ```
 
+### `TypeGraphQLFederationModule`
+
+`typegraphql-nestjs` has also support for [Apollo Federation](https://www.apollographql.com/docs/federation/).
+
+However, Apollo Federation requires building a federated GraphQL schema, hence you need to use the `TypeGraphQLFederationModule` module, designed specially for that case.
+
+The usage is really similar to the basic `TypeGraphQLModule` - the only different is that `.forFeature()` method has an option to provide `referenceResolvers` object which is needed in some cases of Apollo Federation:
+
+```ts
+function resolveUserReference(
+  reference: Pick<User, "id">,
+): Promise<User | undefined> {
+  return db.users.find({ id: reference.id });
+}
+
+@Module({
+  imports: [
+    TypeGraphQLFederationModule.forFeature({
+      orphanedTypes: [User],
+      referenceResolvers: {
+        User: {
+          __resolveReference: resolveUserReference,
+        },
+      },
+    }),
+  ],
+  providers: [AccountsResolver],
+})
+export default class AccountModule {}
+```
+
+The `.forRoot()` method has no differences but you should provide the `skipCheck: true` option as federated schema can violate the standard GraphQL schema rules like at least one query defined:
+
+```ts
+@Module({
+  imports: [
+    TypeGraphQLFederationModule.forRoot({
+      validate: false,
+      skipCheck: true,
+    }),
+    AccountModule,
+  ],
+})
+export default class AppModule {}
+```
+
+> Be aware that you cannot mix `TypeGraphQLFederationModule.forRoot()` with the base `TypeGraphQLModule.forFeature()` one.
+> You need to consistently use only `TypeGraphQLFederationModule` across all modules.
+
+Then, for exposing the federated schema using Apollo Gateway, you should use the standard NestJS [GraphQLGatewayModule](https://docs.nestjs.com/graphql/federation#federated-example-gateway).
+
 ## Caveats
 
 While this integration provides a way to use TypeGraphQL with NestJS modules and dependency injector, for now it doesn't support [other NestJS features](https://docs.nestjs.com/graphql/tooling) like guards, interceptors, filters and pipes.
@@ -150,6 +201,10 @@ You can see some examples of the integration in this repo:
 
    Usage of request scoped dependencies - retrieving fresh instances of resolver and service classes on every request (query/mutation)
 
+1. [Apollo Federation](https://github.com/MichalLytek/typegraphql-nestjs/tree/master/examples/4-federation)
+
+   Showcase of Apollo Federation approach, using the `TypeGraphQLFederationModule` and `GraphQLGatewayModule`.
+
 You can run them by using `ts-node`, like `npx ts-node ./examples/1-basics/index.ts`.
 
 All examples folders contain a `query.gql` file with some examples operations you can perform on the GraphQL servers.

package-lock.json

@@ -11,25 +11,31 @@
     "test": "jest"
   },
   "peerDependencies": {
+    "@apollo/federation": "^0.17.0",
     "@nestjs/common": "^7.6.13",
     "@nestjs/core": "^7.6.13",
     "@nestjs/graphql": "^7.9.10",
+    "apollo-graphql": "^0.4.5",
+    "graphql-tag": "^2.12.1",
     "type-graphql": "^1.1.1"
   },
   "dependencies": {
     "tslib": "^2.1.0"
   },
   "devDependencies": {
+    "@apollo/federation": "^0.17.0",
     "@nestjs/common": "^7.6.13",
     "@nestjs/core": "^7.6.13",
     "@nestjs/graphql": "^7.9.10",
     "@nestjs/platform-fastify": "^7.6.13",
     "@nestjs/testing": "^7.6.13",
     "@types/jest": "^26.0.20",
     "@types/node": "^14.14.31",
+    "apollo-graphql": "^0.4.5",
     "apollo-server-fastify": "^2.21.0",
     "class-validator": "^0.13.1",
     "graphql": "^15.5.0",
+    "graphql-tag": "^2.12.1",
     "graphql-tools": "^7.0.4",
     "husky": "^4.3.8",
     "jest": "^26.6.3",

package.json

@@ -3,3 +3,9 @@ export const TYPEGRAPHQL_ROOT_MODULE_OPTIONS =
 
 export const TYPEGRAPHQL_FEATURE_MODULE_OPTIONS =
   "TYPEGRAPHQL_FEATURE_MODULE_OPTIONS";
+
+export const TYPEGRAPHQL_ROOT_FEDERATION_MODULE_OPTIONS =
+  "TYPEGRAPHQL_ROOT_FEDERATION_MODULE_OPTIONS";
+
+export const TYPEGRAPHQL_FEATURE_FEDERATION_MODULE_OPTIONS =
+  "TYPEGRAPHQL_FEATURE_FEDERATION_MODULE_OPTIONS";

src/constants.ts

@@ -1,2 +1,3 @@
 export * from "./types";
 export { TypeGraphQLModule } from "./typegraphql.module";
+export { TypeGraphQLFederationModule } from "./typegraphql-federation.module";

src/index.ts

@@ -0,0 +1,70 @@
+import { Injectable, flatten } from "@nestjs/common";
+import { ModulesContainer, ModuleRef, ContextIdFactory } from "@nestjs/core";
+import { REQUEST_CONTEXT_ID } from "@nestjs/core/router/request/request-constants";
+import { InstanceWrapper } from "@nestjs/core/injector/instance-wrapper";
+import { ClassType, ContainerType, getMetadataStorage } from "type-graphql";
+
+import { TypeGraphQLFeatureModuleOptions } from "./types";
+
+@Injectable()
+export default class OptionsPreparatorService {
+  constructor(
+    private readonly moduleRef: ModuleRef,
+    private readonly modulesContainer: ModulesContainer,
+  ) {}
+
+  prepareOptions<TOptions extends TypeGraphQLFeatureModuleOptions>(
+    featureModuleToken: string,
+  ) {
+    const globalResolvers = getMetadataStorage().resolverClasses.map(
+      metadata => metadata.target,
+    );
+
+    const featureModuleOptionsArray: TOptions[] = [];
+    const resolversClasses: ClassType[] = [];
+    const providersMetadataMap = new Map<Function, InstanceWrapper<any>>();
+
+    for (const module of this.modulesContainer.values()) {
+      for (const provider of module.providers.values()) {
+        if (
+          typeof provider.name === "string" &&
+          provider.name.includes(featureModuleToken)
+        ) {
+          featureModuleOptionsArray.push(provider.instance as TOptions);
+        }
+        if (globalResolvers.includes(provider.metatype)) {
+          providersMetadataMap.set(provider.metatype, provider);
+          resolversClasses.push(provider.metatype as ClassType);
+        }
+      }
+    }
+
+    const orphanedTypes = flatten(
+      featureModuleOptionsArray.map(it => it.orphanedTypes),
+    );
+    const container: ContainerType = {
+      get: (cls, { context }) => {
+        let contextId = context[REQUEST_CONTEXT_ID];
+        if (!contextId) {
+          contextId = ContextIdFactory.create();
+          context[REQUEST_CONTEXT_ID] = contextId;
+        }
+        const providerMetadata = providersMetadataMap.get(cls)!;
+        if (
+          providerMetadata.isDependencyTreeStatic() &&
+          !providerMetadata.isTransient
+        ) {
+          return this.moduleRef.get(cls, { strict: false });
+        }
+        return this.moduleRef.resolve(cls, contextId, { strict: false });
+      },
+    };
+
+    return {
+      resolversClasses,
+      orphanedTypes,
+      container,
+      featureModuleOptionsArray,
+    };
+  }
+}