YES

Author: kamilkisiela

.eslintignore

@@ -0,0 +1,2 @@
+**/*.spec.ts
+**/dist

.eslintrc.yml

@@ -0,0 +1,17 @@
+env:
+  browser: true
+  es2021: true
+parser: '@typescript-eslint/parser'
+parserOptions:
+  ecmaVersion: 12
+  sourceType: module
+plugins:
+  - '@typescript-eslint'
+rules: 
+  no-debugger: error
+  no-console: error
+  no-await-in-loop: error
+  getter-return: error
+  no-func-assign: error
+  no-unsafe-negation: error
+  no-unreachable: error

package.json

@@ -14,6 +14,7 @@
     "release": "changeset publish",
     "release:canary": "(node scripts/canary-release.js && yarn build && yarn changeset publish --tag alpha) || echo Skipping Canary...",
     "format": "prettier --write \"packages/**/*.{js,json,css,md,ts,tsx}\"",
+    "lint": "eslint \"packages/**\"",
     "benchmark:basic": "NODE_ENV=production ts-node --project tsconfig.app.json benchmark/basic.case.ts",
     "deploy-website": "cd website && yarn && yarn build && mkdir graphql-modules && mv build/* graphql-modules && mv graphql-modules build"
   },
@@ -24,20 +25,23 @@
     "@types/jest": "26.0.14",
     "@types/node": "14.11.1",
     "@types/ramda": "0.27.17",
+    "@typescript-eslint/eslint-plugin": "4.1.1",
+    "@typescript-eslint/parser": "4.1.1",
     "apollo-server": "2.17.0",
     "apollo-server-express": "2.17.0",
     "artillery": "1.6.1",
     "benchmark": "2.1.4",
     "bob-the-bundler": "1.1.0",
     "dataloader": "2.0.0",
+    "eslint": "7.9.0",
     "express": "4.17.1",
     "express-graphql": "0.11.0",
     "graphql": "15.3.0",
     "graphql-subscriptions": "1.1.0",
     "husky": "4.3.0",
     "jest": "26.4.2",
+    "lint-staged": "10.4.0",
     "prettier": "2.1.2",
-    "pretty-quick": "3.0.2",
     "reflect-metadata": "0.1.13",
     "subscriptions-transport-ws": "0.9.18",
     "ts-jest": "26.4.0",
@@ -51,7 +55,11 @@
   },
   "husky": {
     "hooks": {
-      "pre-commit": "pretty-quick --staged"
+      "pre-commit": "lint-staged"
     }
+  },
+  "lint-staged": {
+    "*.ts": "eslint",
+    "*{js,json,css,md,ts,tsx}": "prettier --write"
   }
 }

packages/graphql-modules/src/application/application.ts

@@ -27,7 +27,6 @@ import tapAsyncIterator, {
 } from '../shared/utils';
 import { CONTEXT } from './tokens';
 import { ApplicationConfig, Application } from './types';
-import { GlobalProviderMap, ResolvedProvider } from '../di/resolution';
 
 type ExecutionContextBuilder<
   TContext extends {
@@ -104,29 +103,29 @@ export function createApplication(config: ApplicationConfig): Application {
   );
   const moduleMap = createModuleMap(modules);
 
-  const singletonGlobalProviders: GlobalProviderMap = new Map();
-
-  function addToMap(
-    provider: ResolvedProvider,
-    registry: GlobalProviderMap,
-    injector: ReflectiveInjector
-  ) {
-    if (provider.factory.isGlobal) {
-      if (registry.has(provider.key.id)) {
-        throw new Error('Collision');
-      }
-
-      registry.set(provider.key.id, injector);
-    }
-  }
+  const singletonGlobalProvidersMap: {
+    /**
+     * Provider key -> Module ID
+     */
+    [key: string]: string;
+  } = {};
 
   modules.forEach((mod) => {
     mod.singletonProviders.forEach((provider) => {
-      addToMap(provider, singletonGlobalProviders, mod.injector);
+      if (provider.factory.isGlobal) {
+        singletonGlobalProvidersMap[provider.key.id] = mod.id;
+      }
     });
   });
 
-  appInjector._globalProvidersMap = singletonGlobalProviders;
+  appInjector._globalProvidersMap = {
+    has(key) {
+      return typeof singletonGlobalProvidersMap[key] === 'string';
+    },
+    get(key) {
+      return moduleMap.get(singletonGlobalProvidersMap[key])!.injector;
+    },
+  };
 
   // Creating a schema, flattening the typedefs and resolvers
   // is not expensive since it happens only once
@@ -167,6 +166,29 @@ export function createApplication(config: ApplicationConfig): Application {
       () => appContext
     );
 
+    // It's very important to recreate a Singleton Injector
+    // and add an execution context getter function
+    // We do this so Singleton provider can access the ExecutionContext via Proxy
+    const proxyModuleMap = new Map<string, ReflectiveInjector>();
+
+    moduleMap.forEach((mod, moduleId) => {
+      const singletonModuleInjector = mod.injector;
+      const singletonModuleProxyInjector = ReflectiveInjector.createWithExecutionContext(
+        singletonModuleInjector,
+        () => contextCache[moduleId]
+      );
+      proxyModuleMap.set(moduleId, singletonModuleProxyInjector);
+    });
+
+    singletonAppProxyInjector._globalProvidersMap = {
+      has(key) {
+        return typeof singletonGlobalProvidersMap[key] === 'string';
+      },
+      get(key) {
+        return proxyModuleMap.get(singletonGlobalProvidersMap[key])!;
+      },
+    };
+
     // As the name of the Injector says, it's an Operation scoped Injector
     // Application level
     // Operation scoped - means it's created and destroyed on every GraphQL Operation
@@ -213,18 +235,6 @@ export function createApplication(config: ApplicationConfig): Application {
           if (!contextCache[moduleId]) {
             // We're interested in operation-scoped providers only
             const providers = moduleMap.get(moduleId)?.operationProviders!;
-            // Module-level Singleton Injector
-            const singletonModuleInjector = moduleMap.get(moduleId)!.injector;
-
-            (singletonModuleInjector as any)._parent = singletonAppProxyInjector;
-
-            // It's very important to recreate a Singleton Injector
-            // and add an execution context getter function
-            // We do this so Singleton provider can access the ExecutionContext via Proxy
-            const singletonModuleProxyInjector = ReflectiveInjector.createWithExecutionContext(
-              singletonModuleInjector,
-              () => contextCache[moduleId]
-            );
 
             // Create module-level Operation-scoped Injector
             const operationModuleInjector = ReflectiveInjector.createFromResolved(
@@ -241,7 +251,7 @@ export function createApplication(config: ApplicationConfig): Application {
                   ])
                 ),
                 // This injector has a priority
-                parent: singletonModuleProxyInjector,
+                parent: proxyModuleMap.get(moduleId),
                 // over this one
                 fallbackParent: operationAppInjector,
               }
@@ -257,6 +267,11 @@ export function createApplication(config: ApplicationConfig): Application {
             };
           }
 
+          // HEY HEY HEY: changing `parent` of singleton injector may be incorret
+          // what if we get two operations and we're in the middle of two async actions?
+          (moduleMap.get(moduleId)!
+            .injector as any)._parent = singletonAppProxyInjector;
+
           return contextCache[moduleId];
         },
       },

packages/graphql-modules/src/di/injector.ts

@@ -165,7 +165,6 @@ export class ReflectiveInjector implements Injector {
   }
 
   get(token: any, notFoundValue: any = _THROW_IF_NOT_FOUND): any {
-    debugger;
     return this._getByKey(Key.get(token), notFoundValue);
   }
 

packages/graphql-modules/src/di/resolution.ts

@@ -20,7 +20,10 @@ export type NormalizedProvider<T = any> =
 
 const _EMPTY_LIST: any[] = [];
 
-export type GlobalProviderMap = Map<Key['id'], ReflectiveInjector>;
+export type GlobalProviderMap = {
+  has(key: Key['id']): boolean;
+  get(key: Key['id']): ReflectiveInjector;
+};
 
 export class ResolvedProvider {
   constructor(public key: Key, public factory: ResolvedFactory) {}

packages/graphql-modules/src/di/utils.ts

@@ -11,6 +11,7 @@ export function getOriginalError(error: Error): Error {
 }
 
 function defaultErrorLogger(console: Console, ...values: any[]) {
+  // eslint-disable-next-line no-console
   (<any>console.error)(...values);
 }
 

packages/graphql-modules/tests/index.spec.ts

@@ -125,7 +125,7 @@ test('basic', async () => {
       Events,
       {
         provide: Test,
-        useValue: 'local',
+        useValue: 'mod',
       },
     ],
     typeDefs: gql`
@@ -198,7 +198,7 @@ test('basic', async () => {
       Logger,
       {
         provide: Test,
-        useValue: 'global',
+        useValue: 'app',
       },
     ],
   });
@@ -235,8 +235,8 @@ test('basic', async () => {
   });
 
   // Child Injector has priority over Parent Injector
-  expect(spies.posts.test).toHaveBeenCalledWith('local');
-  expect(spies.comments.test).toHaveBeenCalledWith('global');
+  expect(spies.posts.test).toHaveBeenCalledWith('mod');
+  expect(spies.comments.test).toHaveBeenCalledWith('app');
 
   // Value of MODULE_ID according to module's resolver
   expect(spies.posts.moduleId).toHaveBeenCalledWith('posts');

packages/graphql-modules/tests/providers.spec.ts

@@ -4,6 +4,7 @@ import {
   createModule,
   Injectable,
   Inject,
+  InjectionToken,
   CONTEXT,
   Scope,
   gql,
@@ -615,3 +616,119 @@ test('Global Token provided by one module should be accessible by other modules
     bar: 'ipsum',
   });
 });
+
+test('Global Token (module) should use other local tokens (singleton)', async () => {
+  const LogLevel = new InjectionToken<string>('log-level');
+  const logger = jest.fn();
+
+  @Injectable({
+    scope: Scope.Singleton,
+    global: true,
+  })
+  class Data {
+    constructor(@Inject(LogLevel) private logLevel: string) {}
+
+    lorem() {
+      logger(this.logLevel);
+      return 'ipsum';
+    }
+  }
+
+  @Injectable({
+    scope: Scope.Singleton,
+  })
+  class AppData {
+    constructor(private data: Data) {}
+
+    ispum() {
+      return this.data.lorem();
+    }
+  }
+
+  const fooModule = createModule({
+    id: 'foo',
+    providers: [Data, { provide: LogLevel, useValue: 'info' }],
+    typeDefs: gql`
+      type Query {
+        foo: String!
+      }
+    `,
+    resolvers: {
+      Query: {
+        foo(
+          _parent: {},
+          _args: {},
+          { injector }: GraphQLModules.ModuleContext
+        ) {
+          return injector.get(Data).lorem();
+        },
+      },
+    },
+  });
+
+  const barModule = createModule({
+    id: 'bar',
+    providers: [
+      {
+        provide: LogLevel,
+        useValue: 'error',
+      },
+    ],
+    typeDefs: gql`
+      extend type Query {
+        bar: String!
+      }
+    `,
+    resolvers: {
+      Query: {
+        bar(
+          _parent: {},
+          _args: {},
+          { injector }: GraphQLModules.ModuleContext
+        ) {
+          return injector.get(Data).lorem();
+        },
+      },
+    },
+  });
+
+  const app = createApplication({
+    modules: [fooModule, barModule],
+    providers: [
+      AppData,
+      {
+        provide: LogLevel,
+        useValue: 'verbose',
+      },
+    ],
+  });
+
+  const schema = makeExecutableSchema({
+    typeDefs: app.typeDefs,
+    resolvers: app.resolvers,
+  });
+
+  const contextValue = { request: {}, response: {} };
+  const document = parse(/* GraphQL */ `
+    {
+      foo
+      bar
+    }
+  `);
+
+  const result = await app.createExecution()({
+    schema,
+    contextValue,
+    document,
+  });
+
+  expect(result.errors).toBeUndefined();
+  expect(result.data).toEqual({
+    foo: 'ipsum',
+    bar: 'ipsum',
+  });
+
+  expect(logger).toHaveBeenCalledTimes(2);
+  expect(logger).toHaveBeenNthCalledWith(1, 'info');
+  expect(logger).toHaveBeenNthCalledWith(2, 'info');
+});