Lazy module providers (#2563)

BREAKING Providers of each module are now resolved of upon application creation.

This makes Dependency Injection less strict and not dependent on the order of module imports (hello circular imports).

BREAKING Removed providers, operationProviders and singletonProviders from the Module interface (unlikely you were using them).

Author: kamilkisiela

Diff for: .changeset/orange-geese-hide.md

@@ -0,0 +1,9 @@
+---
+'graphql-modules': major
+---
+
+**BREAKING** Providers of each module are now resolved of upon application creation.
+
+This makes Dependency Injection less strict and not dependent on the order of module imports (hello circular imports).
+
+**BREAKING** Removed `providers`, `operationProviders` and `singletonProviders` from the `Module` interface (unlikely you were using them).

Diff for: packages/graphql-modules/src/module/factory.ts

@@ -24,38 +24,52 @@ export type ModuleFactory = (app: {
   middlewares: MiddlewareMap;
 }) => ResolvedModule;
 
+function lazy<T>(getter: () => T) {
+  let called = false;
+  let computedValue: T;
+
+  return {
+    get value() {
+      if (!called) {
+        called = true;
+        computedValue = getter();
+      }
+
+      return computedValue;
+    },
+  };
+}
+
 export function moduleFactory(config: ModuleConfig): Module {
   const typeDefs = createTypeDefs(config);
   const metadata = metadataFactory(typeDefs, config);
-  const providers =
+  const providers = lazy(() =>
     typeof config.providers === 'function'
       ? config.providers()
-      : config.providers;
+      : config.providers
+  );
 
   // Filter providers and keep them this way
   // so we don't do this filtering multiple times.
   // Providers don't change over time, so it's safe to do it.
-  const operationProviders = ReflectiveInjector.resolve(
-    onlyOperationProviders(providers)
+  const operationProviders = lazy(() =>
+    ReflectiveInjector.resolve(onlyOperationProviders(providers.value))
   );
-  const singletonProviders = ReflectiveInjector.resolve(
-    onlySingletonProviders(providers)
+  const singletonProviders = lazy(() =>
+    ReflectiveInjector.resolve(onlySingletonProviders(providers.value))
   );
 
   const mod: Module = {
     id: config.id,
     config,
     metadata,
     typeDefs,
-    providers,
-    operationProviders,
-    singletonProviders,
     // Factory is called once on application creation,
     // before we even handle GraphQL Operation
     factory(app) {
       const resolvedModule: Partial<ResolvedModule> = mod;
-      resolvedModule.singletonProviders = singletonProviders;
-      resolvedModule.operationProviders = operationProviders;
+      resolvedModule.singletonProviders = singletonProviders.value;
+      resolvedModule.operationProviders = operationProviders.value;
 
       // Create a  module-level Singleton injector
       const injector = ReflectiveInjector.createFromResolved({

Diff for: packages/graphql-modules/src/module/types.ts

@@ -4,7 +4,6 @@ import { ID, Plural } from '../shared/types';
 import { ModuleMetadata } from './metadata';
 import { Provider } from '../di';
 import { MiddlewareMap } from '../shared/middleware';
-import { ResolvedProvider } from '../di/resolution';
 
 export type TypeDefs = Plural<DocumentNode>;
 export type Resolvers = Plural<Record<string, any>>;
@@ -42,12 +41,9 @@ export interface ModuleConfig {
 
 export interface Module {
   id: ID;
-  providers?: Provider[];
   typeDefs: DocumentNode[];
   metadata: ModuleMetadata;
   factory: ModuleFactory;
-  operationProviders: ResolvedProvider[];
-  singletonProviders: ResolvedProvider[];
   config: ModuleConfig;
 }