Added mockModule and mockApplication to testkit + custom GraphQLSchem…

…a builder (#1512) * Added testkit.mockModule * Added testkit.mockApplication * Custom schema builder * fail when modules have non-unique ids * Support TypedDocumentNode Co-authored-by: Kamil Kisiela <kamil.kisiela@gmail.com>
Urigo · Jan 7, 2021 · f38ff90 · f38ff90
1 parent c5bb142
commit f38ff90
Show file tree

Hide file tree

Showing 19 changed files with 699 additions and 99 deletions.
diff --git a/.changeset/flat-teachers-grow.md b/.changeset/flat-teachers-grow.md
@@ -0,0 +1,5 @@
+---
+'graphql-modules': minor
+---
+
+Introduce testkit.mockApplication
diff --git a/.changeset/selfish-yaks-speak.md b/.changeset/selfish-yaks-speak.md
@@ -0,0 +1,5 @@
+---
+'graphql-modules': minor
+---
+
+Custom GraphQLSchema builder
diff --git a/.changeset/witty-apricots-joke.md b/.changeset/witty-apricots-joke.md
@@ -0,0 +1,5 @@
+---
+'graphql-modules': minor
+---
+
+Introduce testkit.mockModule
diff --git a/packages/graphql-modules/package.json b/packages/graphql-modules/package.json
@@ -1,5 +1,13 @@
 {
   "name": "graphql-modules",
+  "description": "Create reusable, maintainable, testable and extendable GraphQL modules",
+  "keywords": [
+    "graphql",
+    "graphql-modules",
+    "server",
+    "typescript",
+    "the-guild"
+  ],
   "version": "1.1.0",
   "author": "Kamil Kisiela",
   "license": "MIT",
@@ -19,6 +27,7 @@
   "dependencies": {
     "@graphql-tools/schema": "^7.0.0",
     "@graphql-tools/wrap": "^7.0.0",
+    "@graphql-typed-document-node/core": "^3.1.0",
     "ramda": "^0.27.1"
   },
   "publishConfig": {

diff --git a/packages/graphql-modules/src/application/application.ts b/packages/graphql-modules/src/application/application.ts
@@ -7,7 +7,10 @@ import {
 } from '../di';
 import { ResolvedModule } from '../module/factory';
 import { ID } from '../shared/types';
-import { ModuleDuplicatedError } from '../shared/errors';
+import {
+  ModuleDuplicatedError,
+  ModuleNonUniqueIdError,
+} from '../shared/errors';
 import { flatten, isDefined } from '../shared/utils';
 import { ApplicationConfig, Application } from './types';
 import {
@@ -19,6 +22,7 @@ import { createContextBuilder } from './context';
 import { executionCreator } from './execution';
 import { subscriptionCreator } from './subscription';
 import { apolloSchemaCreator, apolloExecutorCreator } from './apollo';
+import { Module } from '../module/types';
 
 export type ModulesMap = Map<ID, ResolvedModule>;
 
@@ -53,92 +57,107 @@ export interface InternalAppContext {
  * })
  * ```
  */
-export function createApplication(config: ApplicationConfig): Application {
-  const providers =
-    config.providers && typeof config.providers === 'function'
-      ? config.providers()
-      : config.providers;
-  // Creates an Injector with singleton classes at application level
-  const appSingletonProviders = ReflectiveInjector.resolve(
-    onlySingletonProviders(providers)
-  );
-  const appInjector = ReflectiveInjector.createFromResolved({
-    name: 'App (Singleton Scope)',
-    providers: appSingletonProviders,
-  });
-  // Filter Operation-scoped providers, and keep it here
-  // so we don't do it over and over again
-  const appOperationProviders = ReflectiveInjector.resolve(
-    onlyOperationProviders(providers)
-  );
-  const middlewareMap = config.middlewares || {};
-
-  // Create all modules
-  const modules = config.modules.map((mod) =>
-    mod.factory({
+export function createApplication(
+  applicationConfig: ApplicationConfig
+): Application {
+  function applicationFactory(cfg?: ApplicationConfig): Application {
+    const config = cfg || applicationConfig;
+    const providers =
+      config.providers && typeof config.providers === 'function'
+        ? config.providers()
+        : config.providers;
+    // Creates an Injector with singleton classes at application level
+    const appSingletonProviders = ReflectiveInjector.resolve(
+      onlySingletonProviders(providers)
+    );
+    const appInjector = ReflectiveInjector.createFromResolved({
+      name: 'App (Singleton Scope)',
+      providers: appSingletonProviders,
+    });
+    // Filter Operation-scoped providers, and keep it here
+    // so we don't do it over and over again
+    const appOperationProviders = ReflectiveInjector.resolve(
+      onlyOperationProviders(providers)
+    );
+    const middlewareMap = config.middlewares || {};
+
+    // Validations
+    ensureModuleUniqueIds(config.modules);
+
+    // Create all modules
+    const modules = config.modules.map((mod) =>
+      mod.factory({
+        injector: appInjector,
+        middlewares: middlewareMap,
+      })
+    );
+    const modulesMap = createModulesMap(modules);
+    const singletonGlobalProvidersMap = createGlobalProvidersMap({
+      modules,
+      scope: Scope.Singleton,
+    });
+    const operationGlobalProvidersMap = createGlobalProvidersMap({
+      modules,
+      scope: Scope.Operation,
+    });
+
+    attachGlobalProvidersMap({
+      injector: appInjector,
+      globalProvidersMap: singletonGlobalProvidersMap,
+      moduleInjectorGetter(moduleId) {
+        return modulesMap.get(moduleId)!.injector;
+      },
+    });
+
+    // Creating a schema, flattening the typedefs and resolvers
+    // is not expensive since it happens only once
+    const typeDefs = flatten(modules.map((mod) => mod.typeDefs));
+    const resolvers = modules.map((mod) => mod.resolvers).filter(isDefined);
+    const schema = (applicationConfig.schemaBuilder || makeExecutableSchema)({
+      typeDefs,
+      resolvers,
+    });
+
+    const contextBuilder = createContextBuilder({
+      appInjector,
+      appLevelOperationProviders: appOperationProviders,
+      modulesMap: modulesMap,
+      singletonGlobalProvidersMap,
+      operationGlobalProvidersMap,
+    });
+
+    const createSubscription = subscriptionCreator({ contextBuilder });
+    const createExecution = executionCreator({ contextBuilder });
+    const createSchemaForApollo = apolloSchemaCreator({
+      createSubscription,
+      contextBuilder,
+      schema,
+    });
+    const createApolloExecutor = apolloExecutorCreator({
+      createExecution,
+      schema,
+    });
+
+    instantiateSingletonProviders({
+      appInjector,
+      modulesMap,
+    });
+
+    return {
+      typeDefs,
+      resolvers,
+      schema,
       injector: appInjector,
-      middlewares: middlewareMap,
-    })
-  );
-  const modulesMap = createModulesMap(modules);
-  const singletonGlobalProvidersMap = createGlobalProvidersMap({
-    modules,
-    scope: Scope.Singleton,
-  });
-  const operationGlobalProvidersMap = createGlobalProvidersMap({
-    modules,
-    scope: Scope.Operation,
-  });
-
-  attachGlobalProvidersMap({
-    injector: appInjector,
-    globalProvidersMap: singletonGlobalProvidersMap,
-    moduleInjectorGetter(moduleId) {
-      return modulesMap.get(moduleId)!.injector;
-    },
-  });
-
-  // Creating a schema, flattening the typedefs and resolvers
-  // is not expensive since it happens only once
-  const typeDefs = flatten(modules.map((mod) => mod.typeDefs));
-  const resolvers = modules.map((mod) => mod.resolvers).filter(isDefined);
-  const schema = makeExecutableSchema({ typeDefs, resolvers });
-
-  const contextBuilder = createContextBuilder({
-    appInjector,
-    appLevelOperationProviders: appOperationProviders,
-    modulesMap: modulesMap,
-    singletonGlobalProvidersMap,
-    operationGlobalProvidersMap,
-  });
-
-  const createSubscription = subscriptionCreator({ contextBuilder });
-  const createExecution = executionCreator({ contextBuilder });
-  const createSchemaForApollo = apolloSchemaCreator({
-    createSubscription,
-    contextBuilder,
-    schema,
-  });
-  const createApolloExecutor = apolloExecutorCreator({
-    createExecution,
-    schema,
-  });
-
-  instantiateSingletonProviders({
-    appInjector,
-    modulesMap,
-  });
-
-  return {
-    typeDefs,
-    resolvers,
-    schema,
-    injector: appInjector,
-    createSubscription,
-    createExecution,
-    createSchemaForApollo,
-    createApolloExecutor,
-  };
+      createSubscription,
+      createExecution,
+      createSchemaForApollo,
+      createApolloExecutor,
+      ɵfactory: applicationFactory,
+      ɵconfig: config,
+    };
+  }
+
+  return applicationFactory();
 }
 
 function createModulesMap(modules: ResolvedModule[]): ModulesMap {
@@ -170,3 +189,16 @@ function createModulesMap(modules: ResolvedModule[]): ModulesMap {
 
   return modulesMap;
 }
+
+function ensureModuleUniqueIds(modules: Module[]) {
+  const collisions = modules
+    .filter((mod, i, all) => i !== all.findIndex((m) => m.id === mod.id))
+    .map((m) => m.id);
+
+  if (collisions.length) {
+    throw new ModuleNonUniqueIdError(
+      `Modules with non-unique ids: ${collisions.join(', ')}`,
+      `All modules should have unique ids, please locate and fix them.`
+    );
+  }
+}
diff --git a/packages/graphql-modules/src/application/types.ts b/packages/graphql-modules/src/application/types.ts
@@ -6,7 +6,7 @@ import {
   ExecutionResult,
 } from 'graphql';
 import { Provider, Injector } from '../di';
-import { Resolvers, Module } from '../module/types';
+import { Resolvers, Module, MockedModule } from '../module/types';
 import { Single, ValueOrPromise } from '../shared/types';
 import { MiddlewareMap } from '../shared/middleware';
 import { ApolloRequestContext } from './apollo';
@@ -17,11 +17,16 @@ export type ApolloExecutor = (
   requestContext: ApolloRequestContext
 ) => ValueOrPromise<ExecutionResult>;
 
+export interface MockedApplication extends Application {
+  replaceModule(mockedModule: MockedModule): MockedApplication;
+  addProviders(providers: ApplicationConfig['providers']): MockedApplication;
+}
+
 /**
  * @api
  * A return type of `createApplication` function.
  */
-export type Application = {
+export interface Application {
   /**
    * A list of type definitions defined by modules.
    */
@@ -56,7 +61,15 @@ export type Application = {
    * Experimental
    */
   createApolloExecutor(): ApolloExecutor;
-};
+  /**
+   * @internal
+   */
+  ɵfactory(config?: ApplicationConfig | undefined): Application;
+  /**
+   * @internal
+   */
+  ɵconfig: ApplicationConfig;
+}
 
 /**
  * @api
@@ -75,4 +88,23 @@ export interface ApplicationConfig {
    * A map of middlewares - read the ["Middlewares"](./advanced/middlewares) chapter.
    */
   middlewares?: MiddlewareMap;
+  /**
+   * Creates a GraphQLSchema object out of typeDefs and resolvers
+   *
+   * @example
+   *
+   * ```typescript
+   * import { createApplication } from 'graphql-modules';
+   * import { makeExecutableSchema } from '@graphql-tools/schema';
+   *
+   * const app = createApplication({
+   *   modules: [],
+   *   schemaBuilder: makeExecutableSchema
+   * })
+   * ```
+   */
+  schemaBuilder?(input: {
+    typeDefs: DocumentNode[];
+    resolvers: Record<string, any>[];
+  }): GraphQLSchema;
 }
diff --git a/packages/graphql-modules/src/module/types.ts b/packages/graphql-modules/src/module/types.ts
@@ -50,3 +50,10 @@ export interface Module {
   singletonProviders: ResolvedProvider[];
   config: ModuleConfig;
 }
+
+export interface MockedModule extends Module {
+  /**
+   * @internal
+   */
+  ɵoriginalModule: Module;
+}
diff --git a/packages/graphql-modules/src/shared/errors.ts b/packages/graphql-modules/src/shared/errors.ts
@@ -1,5 +1,13 @@
 import { ID } from './types';
 
+export class ModuleNonUniqueIdError extends ExtendableBuiltin(Error) {
+  constructor(message: string, ...rest: string[]) {
+    super(composeMessage(message, ...rest));
+    this.name = this.constructor.name;
+    this.message = composeMessage(message, ...rest);
+  }
+}
+
 export class ModuleDuplicatedError extends ExtendableBuiltin(Error) {
   constructor(message: string, ...rest: string[]) {
     super(composeMessage(message, ...rest));

diff --git a/packages/graphql-modules/src/shared/utils.ts b/packages/graphql-modules/src/shared/utils.ts
@@ -84,6 +84,18 @@ export function once(cb: () => void) {
   };
 }
 
+export function share<T, A>(factory: (arg?: A) => T): (arg?: A) => T {
+  let cached: T | null = null;
+
+  return (arg?: A) => {
+    if (!cached) {
+      cached = factory(arg);
+    }
+
+    return cached;
+  };
+}
+
 export function uniqueId(isNotUsed: (id: string) => boolean) {
   let id: string;