graphql-modules 3.0.0-alpha-20220929080337-2b91100e → 3.0.0-alpha-20231018162945-f59bbaea

package/application/apollo.d.ts

@@ -1,5 +1,4 @@
-import { DocumentNode, GraphQLSchema } from 'graphql';
-import { ExecutionContextBuilder } from './context';
+import { DocumentNode, ExecutionResult, GraphQLSchema } from 'graphql';
 import { Application } from './types';
 export interface ApolloRequestContext {
     document: DocumentNode;
@@ -12,11 +11,20 @@ export interface ApolloRequestContext {
         } | null;
     };
 }
-export declare function apolloExecutorCreator({ createExecution, }: {
+export interface ApolloGatewayLoadResult {
+    executor: ApolloExecutor;
+}
+export type ApolloExecutor = (requestContext: ApolloRequestContext) => Promise<ExecutionResult>;
+export interface ApolloGatewayInterface {
+    onSchemaLoadOrUpdate(callback: (schemaContext: {
+        apiSchema: GraphQLSchema;
+        coreSupergraphSdl: string;
+    }) => void): () => void;
+    load(): Promise<ApolloGatewayLoadResult>;
+    stop(): Promise<void>;
+}
+export declare function apolloGatewayCreator({ schema, typeDefs, createExecution, }: {
+    schema: Application['schema'];
+    typeDefs: Application['typeDefs'];
     createExecution: Application['createExecution'];
-}): Application['createApolloExecutor'];
-export declare function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }: {
-    createSubscription: Application['createSubscription'];
-    contextBuilder: ExecutionContextBuilder;
-    schema: GraphQLSchema;
-}): () => GraphQLSchema;
+}): Application['createApolloGateway'];

package/application/application.d.ts

@@ -1,7 +1,7 @@
 import { ResolvedModule } from '../module/factory';
 import { ID } from '../shared/types';
 import { ApplicationConfig, Application } from './types';
-export declare type ModulesMap = Map<ID, ResolvedModule>;
+export type ModulesMap = Map<ID, ResolvedModule>;
 /**
  * @internal
  */
@@ -16,7 +16,6 @@ export interface InternalAppContext {
  *
  * ```typescript
  * import { createApplication } from 'graphql-modules';
- * import { createHook, executionAsyncId } from 'async_hooks';
  * import { usersModule } from './users';
  * import { postsModule } from './posts';
  * import { commentsModule } from './comments';
@@ -26,8 +25,7 @@ export interface InternalAppContext {
  *     usersModule,
  *     postsModule,
  *     commentsModule
- *   ],
- *   executionContext: { createHook, executionAsyncId },
+ *   ]
  * })
  * ```
  */

package/application/context.d.ts

@@ -1,7 +1,7 @@
 import { Injector, ReflectiveInjector } from '../di';
 import { ResolvedProvider } from '../di/resolution';
 import type { InternalAppContext, ModulesMap } from './application';
-export declare type ExecutionContextBuilder<TContext extends {
+export type ExecutionContextBuilder<TContext extends {
     [key: string]: any;
 } = {}> = (context: TContext) => {
     context: InternalAppContext;

package/application/execution-context-async-local-storage.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { AsyncLocalStorage } from 'async_hooks';
+import { type ExecutionContextPicker } from './execution-context.interface';
+export declare const executionContext: {
+    create(picker: ExecutionContextPicker): () => void;
+    getModuleContext: ExecutionContextPicker['getModuleContext'];
+    getApplicationContext: ExecutionContextPicker['getApplicationContext'];
+};
+export declare function enableExecutionContext(): void;
+export declare function getExecutionContextStore(): AsyncLocalStorage<ExecutionContextPicker> | undefined;

package/application/execution-context-hooks.d.ts

@@ -0,0 +1,9 @@
+import { type ExecutionContextPicker } from './execution-context.interface';
+export declare const executionContext: {
+    create(picker: ExecutionContextPicker): () => void;
+    getModuleContext: ExecutionContextPicker['getModuleContext'];
+    getApplicationContext: ExecutionContextPicker['getApplicationContext'];
+};
+export declare function enableExecutionContext(): void;
+export declare function getExecutionContextStore(): Map<number, ExecutionContextPicker>;
+export declare function getExecutionContextDependencyStore(): Map<number, Set<number>>;

package/application/execution-context.d.ts

@@ -1,20 +1,8 @@
-export interface ExecutionContextConfig {
-    executionAsyncId: () => number;
-    createHook(config: {
-        init(asyncId: number, _: string, triggerAsyncId: number): void;
-        destroy(asyncId: number): void;
-    }): void;
-}
-export interface ExecutionContextPicker {
-    getModuleContext(moduleId: string): GraphQLModules.ModuleContext;
-    getApplicationContext(): GraphQLModules.AppContext;
-}
+import * as Hooks from './execution-context-hooks';
+export type { ExecutionContextPicker } from './execution-context.interface';
 export declare const executionContext: {
-    create(picker: ExecutionContextPicker): () => void;
-    getModuleContext: ExecutionContextPicker['getModuleContext'];
-    getApplicationContext: ExecutionContextPicker['getApplicationContext'];
+    create(picker: import("./execution-context.interface").ExecutionContextPicker): () => void;
+    getModuleContext: (moduleId: string) => GraphQLModules.ModuleContext;
+    getApplicationContext: () => GraphQLModules.AppContext;
 };
-export declare function enableExecutionContext(config: ExecutionContextConfig): void;
-export declare function assertExecutionContext(): void | never;
-export declare function getExecutionContextStore(): Map<number, ExecutionContextPicker>;
-export declare function getExecutionContextDependencyStore(): Map<number, Set<number>>;
+export declare const enableExecutionContext: typeof Hooks.enableExecutionContext;

package/application/execution-context.interface.d.ts

@@ -0,0 +1,4 @@
+export interface ExecutionContextPicker {
+    getModuleContext(moduleId: string): GraphQLModules.ModuleContext;
+    getApplicationContext(): GraphQLModules.AppContext;
+}

package/application/types.d.ts

@@ -2,13 +2,12 @@ import { execute, subscribe, DocumentNode, GraphQLSchema, ExecutionResult } from
 import type { Provider, Injector } from '../di';
 import type { Resolvers, Module, MockedModule } from '../module/types';
 import type { MiddlewareMap } from '../shared/middleware';
-import type { ExecutionContextConfig } from './execution-context';
-import type { ApolloRequestContext } from './apollo';
+import type { ApolloGatewayInterface, ApolloRequestContext } from './apollo';
 import type { Single } from '../shared/types';
 import type { InternalAppContext } from './application';
-declare type Execution = typeof execute;
-declare type Subscription = typeof subscribe;
-export declare type ApolloExecutor = (requestContext: ApolloRequestContext) => Promise<ExecutionResult>;
+type Execution = typeof execute;
+type Subscription = typeof subscribe;
+export type ApolloExecutor = (requestContext: ApolloRequestContext) => Promise<ExecutionResult>;
 export interface MockedApplication extends Application {
     replaceModule(mockedModule: MockedModule): MockedApplication;
     addProviders(providers: ApplicationConfig['providers']): MockedApplication;
@@ -57,16 +56,9 @@ export interface Application {
         execute?: typeof execute;
         controller?: OperationController;
     }): Execution;
-    /**
-     * @deprecated Use `createApolloExecutor`, `createExecution` and `createSubscription` methods instead.
-     */
-    createSchemaForApollo(): GraphQLSchema;
-    /**
-     * Experimental
-     */
-    createApolloExecutor(options?: {
+    createApolloGateway(options?: {
         controller?: OperationController;
-    }): ApolloExecutor;
+    }): ApolloGatewayInterface;
     /**
      * @internal
      */
@@ -127,20 +119,5 @@ export interface ApplicationConfig {
         typeDefs: DocumentNode[];
         resolvers: Record<string, any>[];
     }): GraphQLSchema;
-    /**
-     * Enables ExecutionContext
-     *
-     * @example
-     *
-     * ```typescript
-     * import { createHook, executionAsyncId } from 'async_hooks';
-     *
-     * const app = createApplication({
-     *  modules: [],
-     *  executionContext: { createHook, executionAsyncId }
-     * });
-     * ```
-     */
-    executionContext: ExecutionContextConfig | false;
 }
 export {};

package/di/decorators.d.ts

@@ -1,9 +1,11 @@
 import { Type, ProviderOptions, InjectionToken } from './providers';
 import { Injector } from './injector';
 export declare function Injectable(options?: ProviderOptions): ClassDecorator;
+type ParameterDecorator = (target: Object, propertyKey: string | symbol | undefined, parameterIndex: number) => void;
 export declare function Optional(): ParameterDecorator;
 export declare function Inject(type: Type<any> | InjectionToken<any>): ParameterDecorator;
-export declare type ExecutionContext = {
+export type ExecutionContext = {
     injector: Injector;
 } & GraphQLModules.ModuleContext;
 export declare function ExecutionContext(): PropertyDecorator;
+export {};

package/di/forward-ref.d.ts

@@ -1,5 +1,5 @@
 import { Type } from './providers';
-export declare type ForwardRefFn<T> = () => T;
+export type ForwardRefFn<T> = () => T;
 /**
  * Useful in "circular dependencies of modules" situation
  */

package/di/injector.d.ts

@@ -2,7 +2,7 @@ import { Type, InjectionToken, Provider } from './providers';
 import { ResolvedProvider, GlobalProviderMap } from './resolution';
 import { Key } from './registry';
 import { ExecutionContext } from './decorators';
-declare type ExecutionContextGetter = () => ExecutionContext | never;
+type ExecutionContextGetter = () => ExecutionContext | never;
 export declare abstract class Injector {
     abstract get<T>(token: Type<T> | InjectionToken<T>, notFoundValue?: any): T;
 }

package/di/providers.d.ts

@@ -18,7 +18,7 @@ export interface ValueProvider<T> extends BaseProvider<T> {
 export interface ClassProvider<T> extends BaseProvider<T> {
     useClass: Type<T>;
 }
-export declare type Factory<T> = (...args: any[]) => T;
+export type Factory<T> = (...args: any[]) => T;
 export interface FactoryProvider<T> extends BaseProvider<T> {
     useFactory: Factory<T>;
     deps?: any[];
@@ -28,7 +28,7 @@ export interface BaseProvider<T> extends ProviderOptions {
 }
 export interface TypeProvider<T> extends Type<T> {
 }
-export declare type Provider<T = any> = TypeProvider<T> | ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
+export type Provider<T = any> = TypeProvider<T> | ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
 export interface ProviderOptions {
     scope?: Scope;
     executionContextIn?: Array<string | symbol>;

package/di/resolution.d.ts

@@ -1,8 +1,8 @@
 import { Provider, ValueProvider, ClassProvider, FactoryProvider } from './providers';
 import { Key } from './registry';
 import { ReflectiveInjector } from './injector';
-export declare type NormalizedProvider<T = any> = ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
-export declare type GlobalProviderMap = {
+export type NormalizedProvider<T = any> = ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
+export type GlobalProviderMap = {
     has(key: Key['id']): boolean;
     get(key: Key['id']): ReflectiveInjector;
 };

package/index.js

@@ -3,8 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const schema = require('@graphql-tools/schema');
+const async_hooks = require('async_hooks');
 const graphql = require('graphql');
-const wrap = require('@graphql-tools/wrap');
 const ramda = require('ramda');
 
 const ERROR_ORIGINAL_ERROR = 'diOriginalError';
@@ -174,6 +174,85 @@ function isFactoryProvider(provider) {
     return typeof provider.useFactory !== 'undefined';
 }
 
+const executionContextStore = new Map();
+const executionContextDependencyStore = new Map();
+const executionContextHook = async_hooks.createHook({
+    init(asyncId, _, triggerAsyncId) {
+        var _a;
+        // Store same context data for child async resources
+        const ctx = executionContextStore.get(triggerAsyncId);
+        if (ctx) {
+            const dependencies = (_a = executionContextDependencyStore.get(triggerAsyncId)) !== null && _a !== void 0 ? _a : executionContextDependencyStore
+                .set(triggerAsyncId, new Set())
+                .get(triggerAsyncId);
+            dependencies.add(asyncId);
+            executionContextStore.set(asyncId, ctx);
+        }
+    },
+    destroy(asyncId) {
+        if (executionContextStore.has(asyncId)) {
+            executionContextStore.delete(asyncId);
+        }
+    },
+});
+function destroyContextAndItsChildren(id) {
+    if (executionContextStore.has(id)) {
+        executionContextStore.delete(id);
+    }
+    const deps = executionContextDependencyStore.get(id);
+    if (deps) {
+        for (const dep of deps) {
+            destroyContextAndItsChildren(dep);
+        }
+        executionContextDependencyStore.delete(id);
+    }
+}
+const executionContext = {
+    create(picker) {
+        const id = async_hooks.executionAsyncId();
+        executionContextStore.set(id, picker);
+        return function destroyContext() {
+            destroyContextAndItsChildren(id);
+        };
+    },
+    getModuleContext(moduleId) {
+        const picker = executionContextStore.get(async_hooks.executionAsyncId());
+        return picker.getModuleContext(moduleId);
+    },
+    getApplicationContext() {
+        const picker = executionContextStore.get(async_hooks.executionAsyncId());
+        return picker.getApplicationContext();
+    },
+};
+function enableExecutionContext() {
+    {
+        executionContextHook.enable();
+    }
+}
+
+const executionContextStore$1 = async_hooks.AsyncLocalStorage
+    ? new async_hooks.AsyncLocalStorage()
+    : undefined;
+const executionContext$1 = {
+    create(picker) {
+        executionContextStore$1.enterWith(picker);
+        return function destroyContext() { };
+    },
+    getModuleContext(moduleId) {
+        return executionContextStore$1.getStore().getModuleContext(moduleId);
+    },
+    getApplicationContext() {
+        return executionContextStore$1.getStore().getApplicationContext();
+    },
+};
+
+const executionContext$2 = async_hooks.AsyncLocalStorage
+    ? executionContext$1
+    : executionContext;
+const enableExecutionContext$1 = async_hooks.AsyncLocalStorage
+    ? () => undefined
+    : enableExecutionContext;
+
 function ensureReflect() {
     if (!(Reflect && Reflect.getOwnMetadata)) {
         throw 'reflect-metadata shim is required when using class decorators';
@@ -183,6 +262,7 @@ function Injectable(options) {
     return (target) => {
         var _a;
         ensureReflect();
+        enableExecutionContext$1();
         const params = (Reflect.getMetadata('design:paramtypes', target) || []).map((param) => (isType(param) ? param : null));
         const existingMeta = readInjectableMetadata(target);
         const meta = {
@@ -769,11 +849,6 @@ function share(factory) {
         return cached;
     };
 }
-function uniqueId(isNotUsed) {
-    let id;
-    while (!isNotUsed((id = Math.random().toString(16).substr(2)))) { }
-    return id;
-}
 function isNotSchema(obj) {
     return obj instanceof graphql.GraphQLSchema === false;
 }
@@ -854,77 +929,6 @@ function duplicatedGlobalTokenError(provider, modules) {
  */
 const CONTEXT = new InjectionToken('context');
 
-const executionContextStore = new Map();
-const executionContextDependencyStore = new Map();
-let executionAsyncId = () => 0;
-function destroyContextAndItsChildren(id) {
-    if (executionContextStore.has(id)) {
-        executionContextStore.delete(id);
-    }
-    const deps = executionContextDependencyStore.get(id);
-    if (deps) {
-        for (const dep of deps) {
-            destroyContextAndItsChildren(dep);
-        }
-        executionContextDependencyStore.delete(id);
-    }
-}
-let executionContextEnabled = false;
-const executionContext = {
-    create(picker) {
-        if (!executionContextEnabled) {
-            return function destroyContextNoop() {
-                // noop
-            };
-        }
-        const id = executionAsyncId();
-        executionContextStore.set(id, picker);
-        return function destroyContext() {
-            destroyContextAndItsChildren(id);
-        };
-    },
-    getModuleContext(moduleId) {
-        assertExecutionContext();
-        const picker = executionContextStore.get(executionAsyncId());
-        return picker.getModuleContext(moduleId);
-    },
-    getApplicationContext() {
-        assertExecutionContext();
-        const picker = executionContextStore.get(executionAsyncId());
-        return picker.getApplicationContext();
-    },
-};
-function enableExecutionContext(config) {
-    if (!executionContextEnabled) {
-        config.createHook({
-            init(asyncId, _, triggerAsyncId) {
-                var _a;
-                // Store same context data for child async resources
-                const ctx = executionContextStore.get(triggerAsyncId);
-                if (ctx) {
-                    const dependencies = (_a = executionContextDependencyStore.get(triggerAsyncId)) !== null && _a !== void 0 ? _a : executionContextDependencyStore
-                        .set(triggerAsyncId, new Set())
-                        .get(triggerAsyncId);
-                    dependencies.add(asyncId);
-                    executionContextStore.set(asyncId, ctx);
-                }
-            },
-            destroy(asyncId) {
-                if (executionContextStore.has(asyncId)) {
-                    executionContextStore.delete(asyncId);
-                }
-            },
-        });
-        executionAsyncId = config.executionAsyncId;
-        executionContextEnabled = true;
-    }
-}
-function assertExecutionContext() {
-    if (!executionContextEnabled) {
-        throw new Error('Execution Context is not enabled. Please set `executionContext` option in `createApplication`');
-    }
-}
-
 function createContextBuilder({ appInjector, modulesMap, appLevelOperationProviders, singletonGlobalProvidersMap, operationGlobalProvidersMap, }) {
     // This is very critical. It creates an execution context.
     // It has to run on every operation.
@@ -952,10 +956,10 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                 return modulesMap.get(moduleId).injector;
             },
         });
-        appInjector.setExecutionContextGetter(executionContext.getApplicationContext);
+        appInjector.setExecutionContextGetter(executionContext$2.getApplicationContext);
         function createModuleExecutionContextGetter(moduleId) {
             return function moduleExecutionContextGetter() {
-                return executionContext.getModuleContext(moduleId);
+                return executionContext$2.getModuleContext(moduleId);
             };
         }
         modulesMap.forEach((mod, moduleId) => {
@@ -969,7 +973,7 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                 return getModuleContext(moduleId, context);
             },
         };
-        const destroyExecutionContext = executionContext.create(executionContextPicker);
+        const destroyExecutionContext = executionContext$2.create(executionContextPicker);
         // 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
@@ -1135,78 +1139,33 @@ function subscriptionCreator({ contextBuilder, }) {
     return createSubscription;
 }
 
-const CONTEXT_ID = Symbol.for('context-id');
-function apolloExecutorCreator({ createExecution, }) {
-    return function createApolloExecutor(options) {
+function apolloGatewayCreator({ schema, typeDefs, createExecution, }) {
+    return function createApolloGateway(options) {
         const executor = createExecution(options);
-        return async function executorAdapter(requestContext) {
-            return executor({
-                schema: requestContext.schema,
-                document: requestContext.document,
-                operationName: requestContext.operationName,
-                variableValues: requestContext.request.variables,
-                contextValue: requestContext.context,
-            });
-        };
-    };
-}
-function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }) {
-    const createApolloSchema = () => {
-        const sessions = {};
-        const subscription = createSubscription();
-        function getSession(ctx) {
-            if (!ctx[CONTEXT_ID]) {
-                ctx[CONTEXT_ID] = uniqueId((id) => !sessions[id]);
-                const { context, ɵdestroy: destroy } = contextBuilder(ctx);
-                sessions[ctx[CONTEXT_ID]] = {
-                    count: 0,
-                    session: {
-                        context,
-                        destroy() {
-                            if (--sessions[ctx[CONTEXT_ID]].count === 0) {
-                                destroy();
-                                delete sessions[ctx[CONTEXT_ID]];
-                                delete ctx[CONTEXT_ID];
-                            }
-                        },
+        return {
+            onSchemaLoadOrUpdate(callback) {
+                callback({
+                    apiSchema: schema,
+                    coreSupergraphSdl: graphql.print(graphql.concatAST(typeDefs)),
+                });
+                return () => { };
+            },
+            async load() {
+                return {
+                    async executor(requestContext) {
+                        return executor({
+                            schema: requestContext.schema,
+                            document: requestContext.document,
+                            operationName: requestContext.operationName,
+                            variableValues: requestContext.request.variables,
+                            contextValue: requestContext.context,
+                        });
                     },
                 };
-            }
-            sessions[ctx[CONTEXT_ID]].count++;
-            return sessions[ctx[CONTEXT_ID]].session;
-        }
-        return wrap.wrapSchema({
-            schema,
-            batch: true,
-            executor(input) {
-                if (input.operationType === 'subscription') {
-                    return subscription({
-                        schema,
-                        document: input.document,
-                        variableValues: input.variables,
-                        contextValue: input.context,
-                        rootValue: input.rootValue,
-                        operationName: input.operationName,
-                    });
-                }
-                // Create an execution context
-                const { context, destroy } = getSession(input.context);
-                // It's important to wrap the executeFn within a promise
-                // so we can easily control the end of execution (with finally)
-                return Promise.resolve()
-                    .then(() => graphql.execute({
-                    schema,
-                    document: input.document,
-                    contextValue: context,
-                    variableValues: input.variables,
-                    rootValue: input.rootValue,
-                    operationName: input.operationName,
-                }))
-                    .finally(destroy);
             },
-        });
+            async stop() { },
+        };
     };
-    return createApolloSchema;
 }
 
 function operationControllerCreator(options) {
@@ -1231,7 +1190,6 @@ function operationControllerCreator(options) {
  *
  * ```typescript
  * import { createApplication } from 'graphql-modules';
- * import { createHook, executionAsyncId } from 'async_hooks';
  * import { usersModule } from './users';
  * import { postsModule } from './posts';
  * import { commentsModule } from './comments';
@@ -1241,17 +1199,13 @@ function operationControllerCreator(options) {
  *     usersModule,
  *     postsModule,
  *     commentsModule
- *   ],
- *   executionContext: { createHook, executionAsyncId },
+ *   ]
  * })
  * ```
  */
 function createApplication(applicationConfig) {
     function applicationFactory(cfg) {
         const config = cfg || applicationConfig;
-        if (config.executionContext) {
-            enableExecutionContext(config.executionContext);
-        }
         const providers = config.providers && typeof config.providers === 'function'
             ? config.providers()
             : config.providers;
@@ -1308,12 +1262,9 @@ function createApplication(applicationConfig) {
         });
         const createSubscription = subscriptionCreator({ contextBuilder });
         const createExecution = executionCreator({ contextBuilder });
-        const createSchemaForApollo = apolloSchemaCreator({
-            createSubscription,
-            contextBuilder,
+        const createApolloGateway = apolloGatewayCreator({
             schema: schema$1,
-        });
-        const createApolloExecutor = apolloExecutorCreator({
+            typeDefs,
             createExecution,
         });
         instantiateSingletonProviders({
@@ -1328,8 +1279,7 @@ function createApplication(applicationConfig) {
             createOperationController,
             createSubscription,
             createExecution,
-            createSchemaForApollo,
-            createApolloExecutor,
+            createApolloGateway,
             ɵfactory: applicationFactory,
             ɵconfig: config,
         };
@@ -2033,11 +1983,8 @@ function mockApplication(app) {
             createExecution(options) {
                 return sharedFactory().createExecution(options);
             },
-            createSchemaForApollo() {
-                return sharedFactory().createSchemaForApollo();
-            },
-            createApolloExecutor() {
-                return sharedFactory().createApolloExecutor();
+            createApolloGateway() {
+                return sharedFactory().createApolloGateway();
             },
             get ɵfactory() {
                 return sharedFactory().ɵfactory;
@@ -2093,7 +2040,6 @@ function testModule(testedModule, config) {
         modules,
         providers: config === null || config === void 0 ? void 0 : config.providers,
         middlewares: config === null || config === void 0 ? void 0 : config.middlewares,
-        executionContext: false,
     });
 }
 function transformModule(mod, config) {

package/index.mjs

@@ -1,6 +1,6 @@
 import { makeExecutableSchema } from '@graphql-tools/schema';
-import { GraphQLSchema, execute as execute$1, subscribe, visit, Kind, GraphQLScalarType, concatAST, defaultFieldResolver, parse } from 'graphql';
-import { wrapSchema } from '@graphql-tools/wrap';
+import { createHook, executionAsyncId, AsyncLocalStorage } from 'async_hooks';
+import { GraphQLSchema, execute as execute$1, subscribe, print, concatAST, visit, Kind, GraphQLScalarType, defaultFieldResolver, parse } from 'graphql';
 import { mergeDeepWith } from 'ramda';
 
 const ERROR_ORIGINAL_ERROR = 'diOriginalError';
@@ -171,6 +171,85 @@ function isFactoryProvider(provider) {
     return typeof provider.useFactory !== 'undefined';
 }
 
+const executionContextStore = new Map();
+const executionContextDependencyStore = new Map();
+const executionContextHook = createHook({
+    init(asyncId, _, triggerAsyncId) {
+        var _a;
+        // Store same context data for child async resources
+        const ctx = executionContextStore.get(triggerAsyncId);
+        if (ctx) {
+            const dependencies = (_a = executionContextDependencyStore.get(triggerAsyncId)) !== null && _a !== void 0 ? _a : executionContextDependencyStore
+                .set(triggerAsyncId, new Set())
+                .get(triggerAsyncId);
+            dependencies.add(asyncId);
+            executionContextStore.set(asyncId, ctx);
+        }
+    },
+    destroy(asyncId) {
+        if (executionContextStore.has(asyncId)) {
+            executionContextStore.delete(asyncId);
+        }
+    },
+});
+function destroyContextAndItsChildren(id) {
+    if (executionContextStore.has(id)) {
+        executionContextStore.delete(id);
+    }
+    const deps = executionContextDependencyStore.get(id);
+    if (deps) {
+        for (const dep of deps) {
+            destroyContextAndItsChildren(dep);
+        }
+        executionContextDependencyStore.delete(id);
+    }
+}
+const executionContext = {
+    create(picker) {
+        const id = executionAsyncId();
+        executionContextStore.set(id, picker);
+        return function destroyContext() {
+            destroyContextAndItsChildren(id);
+        };
+    },
+    getModuleContext(moduleId) {
+        const picker = executionContextStore.get(executionAsyncId());
+        return picker.getModuleContext(moduleId);
+    },
+    getApplicationContext() {
+        const picker = executionContextStore.get(executionAsyncId());
+        return picker.getApplicationContext();
+    },
+};
+function enableExecutionContext() {
+    {
+        executionContextHook.enable();
+    }
+}
+
+const executionContextStore$1 = AsyncLocalStorage
+    ? new AsyncLocalStorage()
+    : undefined;
+const executionContext$1 = {
+    create(picker) {
+        executionContextStore$1.enterWith(picker);
+        return function destroyContext() { };
+    },
+    getModuleContext(moduleId) {
+        return executionContextStore$1.getStore().getModuleContext(moduleId);
+    },
+    getApplicationContext() {
+        return executionContextStore$1.getStore().getApplicationContext();
+    },
+};
+
+const executionContext$2 = AsyncLocalStorage
+    ? executionContext$1
+    : executionContext;
+const enableExecutionContext$1 = AsyncLocalStorage
+    ? () => undefined
+    : enableExecutionContext;
+
 function ensureReflect() {
     if (!(Reflect && Reflect.getOwnMetadata)) {
         throw 'reflect-metadata shim is required when using class decorators';
@@ -180,6 +259,7 @@ function Injectable(options) {
     return (target) => {
         var _a;
         ensureReflect();
+        enableExecutionContext$1();
         const params = (Reflect.getMetadata('design:paramtypes', target) || []).map((param) => (isType(param) ? param : null));
         const existingMeta = readInjectableMetadata(target);
         const meta = {
@@ -766,11 +846,6 @@ function share(factory) {
         return cached;
     };
 }
-function uniqueId(isNotUsed) {
-    let id;
-    while (!isNotUsed((id = Math.random().toString(16).substr(2)))) { }
-    return id;
-}
 function isNotSchema(obj) {
     return obj instanceof GraphQLSchema === false;
 }
@@ -851,77 +926,6 @@ function duplicatedGlobalTokenError(provider, modules) {
  */
 const CONTEXT = new InjectionToken('context');
 
-const executionContextStore = new Map();
-const executionContextDependencyStore = new Map();
-let executionAsyncId = () => 0;
-function destroyContextAndItsChildren(id) {
-    if (executionContextStore.has(id)) {
-        executionContextStore.delete(id);
-    }
-    const deps = executionContextDependencyStore.get(id);
-    if (deps) {
-        for (const dep of deps) {
-            destroyContextAndItsChildren(dep);
-        }
-        executionContextDependencyStore.delete(id);
-    }
-}
-let executionContextEnabled = false;
-const executionContext = {
-    create(picker) {
-        if (!executionContextEnabled) {
-            return function destroyContextNoop() {
-                // noop
-            };
-        }
-        const id = executionAsyncId();
-        executionContextStore.set(id, picker);
-        return function destroyContext() {
-            destroyContextAndItsChildren(id);
-        };
-    },
-    getModuleContext(moduleId) {
-        assertExecutionContext();
-        const picker = executionContextStore.get(executionAsyncId());
-        return picker.getModuleContext(moduleId);
-    },
-    getApplicationContext() {
-        assertExecutionContext();
-        const picker = executionContextStore.get(executionAsyncId());
-        return picker.getApplicationContext();
-    },
-};
-function enableExecutionContext(config) {
-    if (!executionContextEnabled) {
-        config.createHook({
-            init(asyncId, _, triggerAsyncId) {
-                var _a;
-                // Store same context data for child async resources
-                const ctx = executionContextStore.get(triggerAsyncId);
-                if (ctx) {
-                    const dependencies = (_a = executionContextDependencyStore.get(triggerAsyncId)) !== null && _a !== void 0 ? _a : executionContextDependencyStore
-                        .set(triggerAsyncId, new Set())
-                        .get(triggerAsyncId);
-                    dependencies.add(asyncId);
-                    executionContextStore.set(asyncId, ctx);
-                }
-            },
-            destroy(asyncId) {
-                if (executionContextStore.has(asyncId)) {
-                    executionContextStore.delete(asyncId);
-                }
-            },
-        });
-        executionAsyncId = config.executionAsyncId;
-        executionContextEnabled = true;
-    }
-}
-function assertExecutionContext() {
-    if (!executionContextEnabled) {
-        throw new Error('Execution Context is not enabled. Please set `executionContext` option in `createApplication`');
-    }
-}
-
 function createContextBuilder({ appInjector, modulesMap, appLevelOperationProviders, singletonGlobalProvidersMap, operationGlobalProvidersMap, }) {
     // This is very critical. It creates an execution context.
     // It has to run on every operation.
@@ -949,10 +953,10 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                 return modulesMap.get(moduleId).injector;
             },
         });
-        appInjector.setExecutionContextGetter(executionContext.getApplicationContext);
+        appInjector.setExecutionContextGetter(executionContext$2.getApplicationContext);
         function createModuleExecutionContextGetter(moduleId) {
             return function moduleExecutionContextGetter() {
-                return executionContext.getModuleContext(moduleId);
+                return executionContext$2.getModuleContext(moduleId);
             };
         }
         modulesMap.forEach((mod, moduleId) => {
@@ -966,7 +970,7 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                 return getModuleContext(moduleId, context);
             },
         };
-        const destroyExecutionContext = executionContext.create(executionContextPicker);
+        const destroyExecutionContext = executionContext$2.create(executionContextPicker);
         // 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
@@ -1132,78 +1136,33 @@ function subscriptionCreator({ contextBuilder, }) {
     return createSubscription;
 }
 
-const CONTEXT_ID = Symbol.for('context-id');
-function apolloExecutorCreator({ createExecution, }) {
-    return function createApolloExecutor(options) {
+function apolloGatewayCreator({ schema, typeDefs, createExecution, }) {
+    return function createApolloGateway(options) {
         const executor = createExecution(options);
-        return async function executorAdapter(requestContext) {
-            return executor({
-                schema: requestContext.schema,
-                document: requestContext.document,
-                operationName: requestContext.operationName,
-                variableValues: requestContext.request.variables,
-                contextValue: requestContext.context,
-            });
-        };
-    };
-}
-function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }) {
-    const createApolloSchema = () => {
-        const sessions = {};
-        const subscription = createSubscription();
-        function getSession(ctx) {
-            if (!ctx[CONTEXT_ID]) {
-                ctx[CONTEXT_ID] = uniqueId((id) => !sessions[id]);
-                const { context, ɵdestroy: destroy } = contextBuilder(ctx);
-                sessions[ctx[CONTEXT_ID]] = {
-                    count: 0,
-                    session: {
-                        context,
-                        destroy() {
-                            if (--sessions[ctx[CONTEXT_ID]].count === 0) {
-                                destroy();
-                                delete sessions[ctx[CONTEXT_ID]];
-                                delete ctx[CONTEXT_ID];
-                            }
-                        },
+        return {
+            onSchemaLoadOrUpdate(callback) {
+                callback({
+                    apiSchema: schema,
+                    coreSupergraphSdl: print(concatAST(typeDefs)),
+                });
+                return () => { };
+            },
+            async load() {
+                return {
+                    async executor(requestContext) {
+                        return executor({
+                            schema: requestContext.schema,
+                            document: requestContext.document,
+                            operationName: requestContext.operationName,
+                            variableValues: requestContext.request.variables,
+                            contextValue: requestContext.context,
+                        });
                     },
                 };
-            }
-            sessions[ctx[CONTEXT_ID]].count++;
-            return sessions[ctx[CONTEXT_ID]].session;
-        }
-        return wrapSchema({
-            schema,
-            batch: true,
-            executor(input) {
-                if (input.operationType === 'subscription') {
-                    return subscription({
-                        schema,
-                        document: input.document,
-                        variableValues: input.variables,
-                        contextValue: input.context,
-                        rootValue: input.rootValue,
-                        operationName: input.operationName,
-                    });
-                }
-                // Create an execution context
-                const { context, destroy } = getSession(input.context);
-                // It's important to wrap the executeFn within a promise
-                // so we can easily control the end of execution (with finally)
-                return Promise.resolve()
-                    .then(() => execute$1({
-                    schema,
-                    document: input.document,
-                    contextValue: context,
-                    variableValues: input.variables,
-                    rootValue: input.rootValue,
-                    operationName: input.operationName,
-                }))
-                    .finally(destroy);
             },
-        });
+            async stop() { },
+        };
     };
-    return createApolloSchema;
 }
 
 function operationControllerCreator(options) {
@@ -1228,7 +1187,6 @@ function operationControllerCreator(options) {
  *
  * ```typescript
  * import { createApplication } from 'graphql-modules';
- * import { createHook, executionAsyncId } from 'async_hooks';
  * import { usersModule } from './users';
  * import { postsModule } from './posts';
  * import { commentsModule } from './comments';
@@ -1238,17 +1196,13 @@ function operationControllerCreator(options) {
  *     usersModule,
  *     postsModule,
  *     commentsModule
- *   ],
- *   executionContext: { createHook, executionAsyncId },
+ *   ]
  * })
  * ```
  */
 function createApplication(applicationConfig) {
     function applicationFactory(cfg) {
         const config = cfg || applicationConfig;
-        if (config.executionContext) {
-            enableExecutionContext(config.executionContext);
-        }
         const providers = config.providers && typeof config.providers === 'function'
             ? config.providers()
             : config.providers;
@@ -1305,12 +1259,9 @@ function createApplication(applicationConfig) {
         });
         const createSubscription = subscriptionCreator({ contextBuilder });
         const createExecution = executionCreator({ contextBuilder });
-        const createSchemaForApollo = apolloSchemaCreator({
-            createSubscription,
-            contextBuilder,
+        const createApolloGateway = apolloGatewayCreator({
             schema,
-        });
-        const createApolloExecutor = apolloExecutorCreator({
+            typeDefs,
             createExecution,
         });
         instantiateSingletonProviders({
@@ -1325,8 +1276,7 @@ function createApplication(applicationConfig) {
             createOperationController,
             createSubscription,
             createExecution,
-            createSchemaForApollo,
-            createApolloExecutor,
+            createApolloGateway,
             ɵfactory: applicationFactory,
             ɵconfig: config,
         };
@@ -2030,11 +1980,8 @@ function mockApplication(app) {
             createExecution(options) {
                 return sharedFactory().createExecution(options);
             },
-            createSchemaForApollo() {
-                return sharedFactory().createSchemaForApollo();
-            },
-            createApolloExecutor() {
-                return sharedFactory().createApolloExecutor();
+            createApolloGateway() {
+                return sharedFactory().createApolloGateway();
             },
             get ɵfactory() {
                 return sharedFactory().ɵfactory;
@@ -2090,7 +2037,6 @@ function testModule(testedModule, config) {
         modules,
         providers: config === null || config === void 0 ? void 0 : config.providers,
         middlewares: config === null || config === void 0 ? void 0 : config.middlewares,
-        executionContext: false,
     });
 }
 function transformModule(mod, config) {

package/module/factory.d.ts

@@ -3,13 +3,13 @@ import { ReflectiveInjector } from '../di';
 import { ResolvedProvider } from './../di/resolution';
 import { MiddlewareMap } from '../shared/middleware';
 import { Single } from '../shared/types';
-export declare type ResolvedModule = {
+export type ResolvedModule = {
     injector: ReflectiveInjector;
     singletonProviders: Array<ResolvedProvider>;
     operationProviders: Array<ResolvedProvider>;
     resolvers?: Single<Resolvers>;
 } & Omit<Module, 'factory'>;
-export declare type ModuleFactory = (app: {
+export type ModuleFactory = (app: {
     injector: ReflectiveInjector;
     middlewares: MiddlewareMap;
 }) => ResolvedModule;

package/module/metadata.d.ts

@@ -1,7 +1,7 @@
 import { DocumentNode } from 'graphql';
 import { ModuleConfig } from './types';
 import { ID } from '../shared/types';
-export declare type Registry = Record<string, string[]>;
+export type Registry = Record<string, string[]>;
 export interface ModuleMetadata {
     id: ID;
     typeDefs: DocumentNode[];

package/module/types.d.ts

@@ -5,8 +5,8 @@ import { ModuleMetadata } from './metadata';
 import { Provider } from '../di';
 import { MiddlewareMap } from '../shared/middleware';
 import { ResolvedProvider } from '../di/resolution';
-export declare type TypeDefs = Plural<DocumentNode>;
-export declare type Resolvers = Plural<Record<string, any>>;
+export type TypeDefs = Plural<DocumentNode>;
+export type Resolvers = Plural<Record<string, any>>;
 /**
  * @api
  * Module's configuration object. Represents the first argument of `createModule` function.

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "graphql-modules",
-  "version": "3.0.0-alpha-20220929080337-2b91100e",
+  "version": "3.0.0-alpha-20231018162945-f59bbaea",
   "description": "Create reusable, maintainable, testable and extendable GraphQL modules",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
-    "@graphql-tools/schema": "^9.0.0",
-    "@graphql-tools/wrap": "^9.0.0",
+    "@graphql-tools/schema": "^10.0.0",
     "@graphql-typed-document-node/core": "^3.1.0",
-    "ramda": "^0.28.0"
+    "ramda": "^0.29.0"
   },
   "keywords": [
     "graphql",

package/shared/middleware.d.ts

@@ -1,7 +1,7 @@
 import { GraphQLResolveInfo } from 'graphql';
 import { ModuleMetadata } from './../module/metadata';
-export declare type Next<T = any> = () => Promise<T>;
-export declare type Middleware<TContext = MiddlewareContext> = (context: TContext, next: Next) => Promise<any>;
+export type Next<T = any> = () => Promise<T>;
+export type Middleware<TContext = MiddlewareContext> = (context: TContext, next: Next) => Promise<any>;
 export declare function compose<TContext>(middleware: Array<Middleware<TContext>>): (context: TContext, next: Next) => Promise<any>;
 export interface MiddlewareContext {
     root: any;
@@ -11,7 +11,7 @@ export interface MiddlewareContext {
     context: GraphQLModules.ModuleContext;
     info: GraphQLResolveInfo;
 }
-export declare type MiddlewareMap = {
+export type MiddlewareMap = {
     [type: string]: {
         [field: string]: Middleware[];
     };

package/shared/types.d.ts

@@ -1,13 +1,13 @@
 import { GraphQLFieldResolver, GraphQLTypeResolver } from 'graphql';
 import { Injector } from '../di';
-export declare type ID = string;
-export declare type Nil = undefined | null;
-export declare type Maybe<T> = T | Nil;
-export declare type Plural<T> = T | T[];
-export declare type Single<T> = T extends Array<infer R> ? R : T;
-export declare type ValueOrPromise<T> = T | Promise<T>;
-export declare type ResolveFn<TContext = GraphQLModules.Context> = GraphQLFieldResolver<any, TContext, Record<string, any>>;
-export declare type ResolveTypeFn<TContext = GraphQLModules.Context> = GraphQLTypeResolver<any, TContext>;
+export type ID = string;
+export type Nil = undefined | null;
+export type Maybe<T> = T | Nil;
+export type Plural<T> = T | T[];
+export type Single<T> = T extends Array<infer R> ? R : T;
+export type ValueOrPromise<T> = T | Promise<T>;
+export type ResolveFn<TContext = GraphQLModules.Context> = GraphQLFieldResolver<any, TContext, Record<string, any>>;
+export type ResolveTypeFn<TContext = GraphQLModules.Context> = GraphQLTypeResolver<any, TContext>;
 declare global {
     namespace GraphQLModules {
         type ModuleContext = {

package/testing/test-module.d.ts

@@ -1,10 +1,10 @@
 import { ApplicationConfig } from '../application/types';
 import { MockedModule, Module, ModuleConfig } from '../module/types';
-declare type TestModuleConfig = {
+type TestModuleConfig = {
     replaceExtensions?: boolean;
     inheritTypeDefs?: Module[];
 } & Partial<Pick<ApplicationConfig, 'providers' | 'modules' | 'middlewares' | 'schemaBuilder'>> & Partial<Pick<ModuleConfig, 'typeDefs' | 'resolvers'>>;
-declare type MockModuleConfig = Partial<Pick<ModuleConfig, 'providers'>>;
+type MockModuleConfig = Partial<Pick<ModuleConfig, 'providers'>>;
 export declare function mockModule(testedModule: Module, overrideConfig: MockModuleConfig): MockedModule;
 export declare function testModule(testedModule: Module, config?: TestModuleConfig): import("../application/types").Application;
 export {};