Merge pull request #229 from Urigo/bugfix/datasource

dotansimha · web-flow · commit 56a4773a7154 · 2018-12-24T13:18:35.000+02:00
Fix Apollo DataSources Integration
diff --git a/examples/basic/src/app/auth/auth.module.ts b/examples/basic/src/app/auth/auth.module.ts
@@ -24,7 +24,7 @@ export const AuthModule = new GraphQLModule({
   imports: [
     UserModule,
   ],
-  context: async (request: { req: Request }) => ({
+  context: async (networkRequest: { req: Request }) => ({
     authenticatedUser: {
       _id: 1,
       username: 'me',
diff --git a/packages/core/src/graphql-module.ts b/packages/core/src/graphql-module.ts
@@ -65,7 +65,7 @@ export interface GraphQLModuleOptions<Config, Request, Context> {
    * Context builder method. Use this to add your own fields and data to the GraphQL `context`
    * of each execution of GraphQL.
    */
-  context?: BuildContextFn<Config, Request, Context> | Context;
+  context?: BuildContextFn<Config, Request, Context> | Promise<Context> | Context;
   /**
    * The dependencies that this module need to run correctly, you can either provide the `GraphQLModule`,
    * or provide a string with the name of the other module.
@@ -111,7 +111,7 @@ export interface ModuleCache<Request, Context> {
   typeDefs: DocumentNode;
   resolvers: IResolvers<any, ModuleContext<Context>>;
   schemaDirectives: ISchemaDirectives;
-  contextBuilder: (req: Request) => Promise<Context>;
+  contextBuilder: (req: Request, excludeRequest?: boolean) => Promise<Context>;
   modulesMap: ModulesMap<Request>;
   extraSchemas: GraphQLSchema[];
   directiveResolvers: IDirectiveResolvers;
@@ -385,8 +385,8 @@ export class GraphQLModule<Config = any, Request = any, Context = any> {
     return directiveResolvers;
   }
 
-  private checkIfResolverCalledSafely(resolverPath: string, appContext: any, info: any) {
-    if (!('request' in appContext)) {
+  private checkIfResolverCalledSafely(resolverPath: string, request: any, info: any) {
+    if (typeof request === 'undefined') {
       throw new IllegalResolverInvocationError(resolverPath, this.name, `Network Request hasn't been passed!`);
     }
     if (typeof info === 'undefined') {
@@ -399,29 +399,30 @@ export class GraphQLModule<Config = any, Request = any, Context = any> {
     // tslint:disable-next-line:forin
     for (const type in resolvers) {
       const typeResolvers = resolvers[type];
-      if (typeResolvers instanceof GraphQLScalarType) {
-        continue;
-      }
-      // tslint:disable-next-line:forin
-      for (const prop in resolvers[type]) {
-        const resolver = typeResolvers[prop];
-        if (typeof resolver === 'function') {
-          if (prop !== '__resolveType') {
-            typeResolvers[prop] = async (root: any, args: any, appContext: any, info: any) => {
-              this.checkIfResolverCalledSafely(`${type}.${prop}`, appContext, info);
-              const { request } = appContext;
-              const moduleContext = await this.context(request);
-              info.schema = this._cache.schema;
-              return resolver.call(typeResolvers, root, args, moduleContext, info);
-            };
-          } else {
-            typeResolvers[prop] = async (root: any, appContext: any, info: any) => {
-              this.checkIfResolverCalledSafely(`${type}.${prop}`, appContext, info);
-              const { request } = appContext;
-              const moduleContext = await this.context(request);
-              info.schema = this._cache.schema;
-              return resolver.call(typeResolvers, root, moduleContext as any, info);
-            };
+      if (!(typeResolvers instanceof GraphQLScalarType)) {
+        // tslint:disable-next-line:forin
+        for (const prop in resolvers[type]) {
+          const resolver = typeResolvers[prop];
+          if (typeof resolver === 'function') {
+            if (prop !== '__resolveType') {
+              typeResolvers[prop] = async (root: any, args: any, appContext: any, info: any) => {
+                const request = info.request || appContext.request;
+                info.request = request;
+                this.checkIfResolverCalledSafely(`${type}.${prop}`, request, info);
+                const moduleContext = await this.context(request, true);
+                info.schema = this.schema;
+                return resolver.call(typeResolvers, root, args, moduleContext, info);
+              };
+            } else {
+              typeResolvers[prop] = async (root: any, appContext: any, info: any) => {
+                const request = info.request || appContext.request;
+                info.request = request;
+                this.checkIfResolverCalledSafely(`${type}.${prop}`, request, info);
+                const moduleContext = await this.context(request, true);
+                info.schema = this.schema;
+                return resolver.call(typeResolvers, root, moduleContext, info);
+              };
+            }
           }
         }
       }
@@ -436,10 +437,11 @@ export class GraphQLModule<Config = any, Request = any, Context = any> {
       const compositionArr = asArray(resolversComposition[path]);
       resolversComposition[path] = [
         (next: any) => async (root: any, args: any, appContext: any, info: any) => {
-          this.checkIfResolverCalledSafely(path, appContext, info);
-          const { request } = appContext;
-          const moduleContext = await this.context(request);
-          info.schema = this._cache.schema;
+          const request = info.request || appContext.request;
+          info.request = request;
+          this.checkIfResolverCalledSafely(path, request, info);
+          const moduleContext = await this.context(request, true);
+          info.schema = this.schema;
           return next(root, args, moduleContext, info);
         },
         ...compositionArr,
@@ -479,7 +481,7 @@ export class GraphQLModule<Config = any, Request = any, Context = any> {
     const importsTypeDefs = new Set<DocumentNode>();
     const importsResolvers = new Set<IResolvers<any, any>>();
     const importsInjectors = new Set<Injector>();
-    const importsContextBuilders = new Set<(req: Request) => Promise<Context>>();
+    const importsContextBuilders = new Set<(req: Request, excludeRequest?: boolean) => Promise<Context>>();
     const importsSchemaDirectives = new Set<ISchemaDirectives>();
     const importsExtraSchemas = new Set<GraphQLSchema>();
     const importsDirectiveResolvers = new Set<IDirectiveResolvers>();
@@ -610,40 +612,45 @@ export class GraphQLModule<Config = any, Request = any, Context = any> {
       }
     }
 
-    this._cache.contextBuilder = async request => {
-      request['moduleNameContextMap'] = request['moduleNameContextMap'] || new Map();
-      const moduleNameContextMap: Map<string, any> = request['moduleNameContextMap'];
+    this._cache.contextBuilder = async (request, excludeRequest = false) => {
+      const moduleNameContextMap = this.getModuleNameContextMap(request);
       if (!(moduleNameContextMap.has(this.name))) {
-        const importsContextArr$ = [...importsContextBuilders].map(contextBuilder => contextBuilder(request));
+        const importsContextArr$ = [...importsContextBuilders].map(contextBuilder => contextBuilder(request, true));
         const importsContextArr = await Promise.all(importsContextArr$);
-        const importsContext = importsContextArr.reduce((acc, curr) => ({ ...acc, ...(curr as any) }), {});
+        const importsContext = importsContextArr.reduce((acc, curr) => ({ ...acc, ...curr}), {} as any);
         const applicationInjector = this.injector;
         const sessionInjector = applicationInjector.getSessionInjector(request);
-        const moduleSessionInfo = sessionInjector.has(ModuleSessionInfo) ? sessionInjector.get(ModuleSessionInfo) : new ModuleSessionInfo<Config, any, Context>(this, request, importsContext);
+        const moduleSessionInfo = sessionInjector.has(ModuleSessionInfo) ? sessionInjector.get(ModuleSessionInfo) : new ModuleSessionInfo<Config, any, Context>(this, request);
         let moduleContext = {};
         const moduleContextDeclaration = this._options.context;
         if (moduleContextDeclaration) {
-          if (typeof moduleContextDeclaration === 'function') {
-            moduleContext = await (moduleContextDeclaration as any)(request, importsContext, moduleSessionInfo);
+          if (moduleContextDeclaration instanceof Function) {
+            moduleContext = await moduleContextDeclaration(request, { ...importsContext, injector }, moduleSessionInfo);
           } else {
-            moduleContext = moduleContextDeclaration;
+            moduleContext = await moduleContextDeclaration;
           }
         }
-        const builtResult = {
+        moduleNameContextMap.set(this.name, {
           ...importsContext,
-          ...moduleContext as any,
+          ...moduleContext,
           injector: sessionInjector,
-          request,
-        };
+        });
         const requestHooks$ = [
           ...applicationInjector.scopeSet,
           ...sessionInjector.scopeSet,
         ].map(serviceIdentifier => moduleSessionInfo.callRequestHook(serviceIdentifier),
         );
         await Promise.all(requestHooks$);
-        moduleNameContextMap.set(this.name, builtResult);
       }
-      return moduleNameContextMap.get(this.name);
+      const moduleContext = moduleNameContextMap.get(this.name);
+      if (excludeRequest) {
+        return moduleContext;
+      } else {
+        return {
+          ...moduleContext,
+          request,
+        };
+      }
     };
 
     if ('middleware' in this._options) {
@@ -652,6 +659,15 @@ export class GraphQLModule<Config = any, Request = any, Context = any> {
     }
   }
 
+  private static requestModuleNameContextMap = new WeakMap<any, Map<string, any>>();
+
+  getModuleNameContextMap(request: Request) {
+    if (!GraphQLModule.requestModuleNameContextMap.has(request)) {
+      GraphQLModule.requestModuleNameContextMap.set(request, new Map());
+    }
+    return GraphQLModule.requestModuleNameContextMap.get(request);
+  }
+
   /**
    * Build a GraphQL `context` object based on a network request.
    * It iterates over all modules by their dependency-based order, and executes
@@ -665,7 +681,7 @@ export class GraphQLModule<Config = any, Request = any, Context = any> {
    *
    * @param request - the network request from `connect`, `express`, etc...
    */
-  get context(): (request: Request) => Promise<ModuleContext<Context>> {
+  get context(): (request: Request, excludeRequest?: boolean) => Promise<ModuleContext<Context>> {
     if (!this._cache.contextBuilder) {
       this.buildSchemaAndInjector();
     }
@@ -848,8 +864,8 @@ export class GraphQLModule<Config = any, Request = any, Context = any> {
           const accContext = await accContextBuilder(request, currentContext, injector);
           const moduleContext = typeof currentContextBuilder === 'function' ? await currentContextBuilder(request, currentContext, injector) : (currentContextBuilder || {});
           return {
-            ...accContext as any,
-            ...moduleContext as any,
+            ...accContext,
+            ...moduleContext,
           };
         };
       },
diff --git a/packages/core/src/module-session-info.ts b/packages/core/src/module-session-info.ts
@@ -6,7 +6,6 @@ export class ModuleSessionInfo<Config = any, Request = any, Context = any> {
   constructor(
     private _module: GraphQLModule<Config, Request, Context>,
     private _request: Request,
-    private _context: Context,
   ) {
     this.injector.provide({
       provide: ModuleSessionInfo,
@@ -23,10 +22,10 @@ export class ModuleSessionInfo<Config = any, Request = any, Context = any> {
     return this.module.cache;
   }
   get context() {
-    return this._context;
+    return this.module.getModuleNameContextMap(this.request).get(this.module.name);
   }
   get injector() {
-    return this._module.injector.getSessionInjector(this.request);
+    return this.module.injector.getSessionInjector(this.request);
   }
   public async callRequestHook<T extends OnRequest<Config, Request, Context>>(
     serviceIdentifier: ServiceIdentifier<T>,
diff --git a/packages/core/tests/graphql-module.spec.ts b/packages/core/tests/graphql-module.spec.ts
@@ -68,7 +68,7 @@ describe('GraphQLModule', () => {
   });
 
   // C (with context building fn)
-  const cContextBuilder = jest.fn(() => ({ user: { id: 1 } }));
+  const cContextBuilder = () => ({ user: { id: 1 } });
   const typesC = [`type C { f: String}`, `type Query { c: C }`];
   const moduleC = new GraphQLModule({
     name: 'C',
@@ -142,6 +142,7 @@ describe('GraphQLModule', () => {
       document: testQuery,
       contextValue: context,
     });
+    expect(result.errors).toBeFalsy();
     expect(result.data.b.f).toBe('1');
   });
 
@@ -159,19 +160,6 @@ describe('GraphQLModule', () => {
     expect(injector.get(token)).toBe(provider);
   });
 
-  it('should inject implementation object into the context using the module name', async () => {
-    const schema = app.schema;
-    const context = await app.context({ req: {} });
-
-    const result = await execute({
-      schema,
-      document: testQuery,
-      contextValue: context,
-    });
-
-    expect(result.data.b.f).toBe('1');
-  });
-
   it('should put the correct providers to the injector', async () => {
 
     expect(app.injector.get(ProviderA) instanceof ProviderA).toBe(true);
@@ -1047,4 +1035,69 @@ describe('GraphQLModule', () => {
     expect(result.errors).toBeFalsy();
     expect(result.data['today']).toBe(today.getTime());
   });
+  describe('Apollo DataSources Intergration', () => {
+    it('Should pass props correctly to initialize method', async () => {
+      @Injectable({
+        scope: ProviderScope.Session,
+      })
+      class TestDataSourceAPI {
+        public initialize(initParams: ModuleSessionInfo) {
+          expect(initParams.context['myField']).toBe('some-value');
+          expect(initParams.module).toBe(moduleA);
+          expect(initParams.cache).toBe(moduleA.cache);
+        }
+      }
+      const testQuery = gql`
+        query {
+          a {
+            f
+          }
+        }
+      `;
+      const typesA = [`type A { f: String}`, `type Query { a: A }`];
+      const moduleA = new GraphQLModule({
+        name: 'A',
+        typeDefs: typesA,
+        resolvers: {
+          Query: { a: () => ({ f: 's' }) },
+        },
+        context: () => {
+          return {
+            myField: 'some-value',
+          };
+        },
+        providers: [TestDataSourceAPI],
+      });
+      const app = new GraphQLModule({ imports: [moduleA] });
+      await app.context({ req: {} });
+    });
+  });
+  it('should exclude network request', async () => {
+    const { schema, context } = new GraphQLModule({
+      context: {
+        request: { foo: 'BAR' },
+        // this request is not request that is internally passed by GraphQLModules
+        // this request must be passed instead of Network Request
+      },
+      typeDefs: gql`
+        type Query {
+          foo: String
+        }
+      `,
+      resolvers: {
+        Query: {
+          foo: (_, __, context) => {
+            return context.request.foo;
+          },
+        },
+      },
+    });
+    const result = await execute({
+      schema,
+      document: gql`query { foo }`,
+      contextValue: await context({ req: {} }),
+    });
+    expect(result.errors).toBeFalsy();
+    expect(result.data['foo']).toBe('BAR');
+  });
 });
diff --git a/packages/di/src/injector.ts b/packages/di/src/injector.ts
@@ -145,7 +145,7 @@ export class Injector {
         throw new ServiceIdentifierNotFoundError(serviceIdentifier, this._name);
       }
   }
-  static sessionNameSessionInjectorMapMap = new WeakMap<any, Map<string, Injector>>();
+  private static sessionNameSessionInjectorMapMap = new WeakMap<any, Map<string, Injector>>();
   public getSessionInjector<Session>(session: Session): Injector {
     if (!Injector.sessionNameSessionInjectorMapMap.has(session)) {
       Injector.sessionNameSessionInjectorMapMap.set(session, new Map());

Original file line number	Diff line number	Diff line change
`@@ -145,7 +145,7 @@ export class Injector {`
`145`	`145`	`throw new ServiceIdentifierNotFoundError(serviceIdentifier, this._name);`
`146`	`146`	`}`
`147`	`147`	`}`
`148`		`- static sessionNameSessionInjectorMapMap = new WeakMap<any, Map<string, Injector>>();`
	`148`	`+ private static sessionNameSessionInjectorMapMap = new WeakMap<any, Map<string, Injector>>();`
`149`	`149`	`public getSessionInjector<Session>(session: Session): Injector {`
`150`	`150`	`if (!Injector.sessionNameSessionInjectorMapMap.has(session)) {`
`151`	`151`	`Injector.sessionNameSessionInjectorMapMap.set(session, new Map());`