graphql-modules 3.0.0-alpha-20231018163544-36199b68 → 3.0.0-alpha-20250219090434-d6cc8940d97c7ef3dba3f59c56376d7cbab77c83

package/README.md

@@ -1,4 +1,7 @@
-[![modules](https://user-images.githubusercontent.com/25294569/64067074-ed185b80-cc2a-11e9-8f4d-5f1e19feaa0a.gif)](https://graphql-modules.com/)
+[![GraphQLConf 2024 Banner: September 10-12, San Francisco. Hosted by the GraphQL Foundation](https://github.com/user-attachments/assets/bdb8cd5d-5186-4ece-b06b-b00a499b7868)](https://graphql.org/conf/2024/?utm_source=github&utm_medium=graphql_modules&utm_campaign=readme)
+
+<!-- Uncomment when we remove GraphQL Conf banner -->
+<!-- [![modules](https://user-images.githubusercontent.com/25294569/64067074-ed185b80-cc2a-11e9-8f4d-5f1e19feaa0a.gif)](https://graphql-modules.com/) -->
 
 [![npm version](https://badge.fury.io/js/graphql-modules.svg)](https://www.npmjs.com/package/graphql-modules)
 ![CI](https://github.com/Urigo/graphql-modules/workflows/CI/badge.svg)

package/application/apollo.d.ts

@@ -1,4 +1,5 @@
-import { DocumentNode, ExecutionResult, GraphQLSchema } from 'graphql';
+import { DocumentNode, GraphQLSchema } from 'graphql';
+import { ExecutionContextBuilder } from './context';
 import { Application } from './types';
 export interface ApolloRequestContext {
     document: DocumentNode;
@@ -11,20 +12,11 @@ export interface ApolloRequestContext {
         } | null;
     };
 }
-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'];
+export declare function apolloExecutorCreator({ createExecution, }: {
     createExecution: Application['createExecution'];
-}): Application['createApolloGateway'];
+}): Application['createApolloExecutor'];
+export declare function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }: {
+    createSubscription: Application['createSubscription'];
+    contextBuilder: ExecutionContextBuilder;
+    schema: GraphQLSchema;
+}): () => GraphQLSchema;

package/application/execution.d.ts

@@ -3,6 +3,6 @@ import { ExecutionContextBuilder } from './context';
 export declare function executionCreator({ contextBuilder, }: {
     contextBuilder: ExecutionContextBuilder;
 }): (options?: {
-    execute?: typeof execute | undefined;
-    controller?: import("./types").OperationController | undefined;
-} | undefined) => typeof execute;
+    execute?: typeof execute;
+    controller?: import("./types").OperationController;
+}) => typeof execute;

package/application/subscription.d.ts

@@ -3,6 +3,6 @@ import { ExecutionContextBuilder } from './context';
 export declare function subscriptionCreator({ contextBuilder, }: {
     contextBuilder: ExecutionContextBuilder;
 }): (options?: {
-    subscribe?: typeof subscribe | undefined;
-    controller?: import("./types").OperationController | undefined;
-} | undefined) => typeof subscribe;
+    subscribe?: typeof subscribe;
+    controller?: import("./types").OperationController;
+}) => typeof subscribe;

package/application/types.d.ts

@@ -2,7 +2,7 @@ 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 { ApolloGatewayInterface, ApolloRequestContext } from './apollo';
+import type { ApolloRequestContext } from './apollo';
 import type { Single } from '../shared/types';
 import type { InternalAppContext } from './application';
 type Execution = typeof execute;
@@ -56,9 +56,16 @@ export interface Application {
         execute?: typeof execute;
         controller?: OperationController;
     }): Execution;
-    createApolloGateway(options?: {
+    /**
+     * @deprecated Use `createApolloExecutor`, `createExecution` and `createSubscription` methods instead.
+     */
+    createSchemaForApollo(): GraphQLSchema;
+    /**
+     * Experimental
+     */
+    createApolloExecutor(options?: {
         controller?: OperationController;
-    }): ApolloGatewayInterface;
+    }): ApolloExecutor;
     /**
      * @internal
      */

package/di/injector.d.ts

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

package/di/providers.d.ts

@@ -24,7 +24,7 @@ export interface FactoryProvider<T> extends BaseProvider<T> {
     deps?: any[];
 }
 export interface BaseProvider<T> extends ProviderOptions {
-    provide: Type<T> | InjectionToken<T>;
+    provide: Type<T> | InjectionToken<T> | AbstractType<T>;
 }
 export interface TypeProvider<T> extends Type<T> {
 }

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,85 +174,6 @@ 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';
@@ -262,7 +183,6 @@ 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 = {
@@ -812,9 +732,9 @@ function tapAsyncIterator(iterable, doneCallback) {
                 throw error;
             }
         },
-        async return() {
+        async return(value) {
             try {
-                const result = await iterator.return();
+                const result = await iterator.return(value);
                 return mapResult(result);
             }
             catch (error) {
@@ -822,7 +742,7 @@ function tapAsyncIterator(iterable, doneCallback) {
                 throw error;
             }
         },
-        async throw(error) {
+        throw(error) {
             doneCallback();
             return iterator.throw(error);
         },
@@ -849,6 +769,11 @@ 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;
 }
@@ -956,24 +881,17 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                 return modulesMap.get(moduleId).injector;
             },
         });
-        appInjector.setExecutionContextGetter(executionContext$2.getApplicationContext);
+        appInjector.setExecutionContextGetter(function executionContextGetter() {
+            return appContext;
+        });
         function createModuleExecutionContextGetter(moduleId) {
             return function moduleExecutionContextGetter() {
-                return executionContext$2.getModuleContext(moduleId);
+                return getModuleContext(moduleId, context);
             };
         }
         modulesMap.forEach((mod, moduleId) => {
             mod.injector.setExecutionContextGetter(createModuleExecutionContextGetter(moduleId));
         });
-        const executionContextPicker = {
-            getApplicationContext() {
-                return appContext;
-            },
-            getModuleContext(moduleId) {
-                return getModuleContext(moduleId, context);
-            },
-        };
-        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
@@ -1047,7 +965,6 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                         injector._getObjByKeyId(keyId).onDestroy();
                     }
                 });
-                destroyExecutionContext();
                 contextCache = {};
             }),
             ɵinjector: operationAppInjector,
@@ -1139,33 +1056,78 @@ function subscriptionCreator({ contextBuilder, }) {
     return createSubscription;
 }
 
-function apolloGatewayCreator({ schema, typeDefs, createExecution, }) {
-    return function createApolloGateway(options) {
+const CONTEXT_ID = Symbol.for('context-id');
+function apolloExecutorCreator({ createExecution, }) {
+    return function createApolloExecutor(options) {
         const executor = createExecution(options);
-        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,
-                        });
+        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];
+                            }
+                        },
                     },
                 };
+            }
+            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) {
@@ -1262,9 +1224,12 @@ function createApplication(applicationConfig) {
         });
         const createSubscription = subscriptionCreator({ contextBuilder });
         const createExecution = executionCreator({ contextBuilder });
-        const createApolloGateway = apolloGatewayCreator({
+        const createSchemaForApollo = apolloSchemaCreator({
+            createSubscription,
+            contextBuilder,
             schema: schema$1,
-            typeDefs,
+        });
+        const createApolloExecutor = apolloExecutorCreator({
             createExecution,
         });
         instantiateSingletonProviders({
@@ -1279,7 +1244,8 @@ function createApplication(applicationConfig) {
             createOperationController,
             createSubscription,
             createExecution,
-            createApolloGateway,
+            createSchemaForApollo,
+            createApolloExecutor,
             ɵfactory: applicationFactory,
             ɵconfig: config,
         };
@@ -1597,7 +1563,11 @@ function wrapResolver({ resolver, config, path, middlewareMap, isTypeResolver, i
         const wrappedResolver = (root, context, info) => {
             const ctx = {
                 root,
-                context: context.ɵgetModuleContext(config.id, context),
+                context: isReferenceResolver
+                    ? context.ɵgetModuleContext(config.id, context)
+                    : // We mark the context object as possibly undefined,
+                        // because graphql-jit for some reason doesn't pass it for isTypeOf or resolveType methods
+                        context === null || context === void 0 ? void 0 : context.ɵgetModuleContext(config.id, context),
                 info,
             };
             return resolver(ctx.root, ctx.context, ctx.info);
@@ -1872,31 +1842,41 @@ function ensureDocumentNode(config, typeDefs) {
  */
 const MODULE_ID = new InjectionToken('module-id');
 
+function lazy(getter) {
+    let called = false;
+    let computedValue;
+    return {
+        get value() {
+            if (!called) {
+                called = true;
+                computedValue = getter();
+            }
+            return computedValue;
+        },
+    };
+}
 function moduleFactory(config) {
     const typeDefs = createTypeDefs(config);
     const metadata = metadataFactory(typeDefs, config);
-    const providers = typeof config.providers === 'function'
+    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 singletonProviders = ReflectiveInjector.resolve(onlySingletonProviders(providers));
+    const operationProviders = lazy(() => ReflectiveInjector.resolve(onlyOperationProviders(providers.value)));
+    const singletonProviders = lazy(() => ReflectiveInjector.resolve(onlySingletonProviders(providers.value)));
     const mod = {
         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 = 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({
                 name: `Module "${config.id}" (Singleton Scope)`,
@@ -1983,8 +1963,11 @@ function mockApplication(app) {
             createExecution(options) {
                 return sharedFactory().createExecution(options);
             },
-            createApolloGateway() {
-                return sharedFactory().createApolloGateway();
+            createSchemaForApollo() {
+                return sharedFactory().createSchemaForApollo();
+            },
+            createApolloExecutor() {
+                return sharedFactory().createApolloExecutor();
             },
             get ɵfactory() {
                 return sharedFactory().ɵfactory;

package/index.mjs

@@ -1,6 +1,6 @@
 import { makeExecutableSchema } from '@graphql-tools/schema';
-import { createHook, executionAsyncId, AsyncLocalStorage } from 'async_hooks';
-import { GraphQLSchema, execute as execute$1, subscribe, print, concatAST, visit, Kind, GraphQLScalarType, defaultFieldResolver, parse } from 'graphql';
+import { GraphQLSchema, execute as execute$1, subscribe, visit, Kind, GraphQLScalarType, concatAST, defaultFieldResolver, parse } from 'graphql';
+import { wrapSchema } from '@graphql-tools/wrap';
 import { mergeDeepWith } from 'ramda';
 
 const ERROR_ORIGINAL_ERROR = 'diOriginalError';
@@ -171,85 +171,6 @@ 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';
@@ -259,7 +180,6 @@ 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 = {
@@ -809,9 +729,9 @@ function tapAsyncIterator(iterable, doneCallback) {
                 throw error;
             }
         },
-        async return() {
+        async return(value) {
             try {
-                const result = await iterator.return();
+                const result = await iterator.return(value);
                 return mapResult(result);
             }
             catch (error) {
@@ -819,7 +739,7 @@ function tapAsyncIterator(iterable, doneCallback) {
                 throw error;
             }
         },
-        async throw(error) {
+        throw(error) {
             doneCallback();
             return iterator.throw(error);
         },
@@ -846,6 +766,11 @@ 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;
 }
@@ -953,24 +878,17 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                 return modulesMap.get(moduleId).injector;
             },
         });
-        appInjector.setExecutionContextGetter(executionContext$2.getApplicationContext);
+        appInjector.setExecutionContextGetter(function executionContextGetter() {
+            return appContext;
+        });
         function createModuleExecutionContextGetter(moduleId) {
             return function moduleExecutionContextGetter() {
-                return executionContext$2.getModuleContext(moduleId);
+                return getModuleContext(moduleId, context);
             };
         }
         modulesMap.forEach((mod, moduleId) => {
             mod.injector.setExecutionContextGetter(createModuleExecutionContextGetter(moduleId));
         });
-        const executionContextPicker = {
-            getApplicationContext() {
-                return appContext;
-            },
-            getModuleContext(moduleId) {
-                return getModuleContext(moduleId, context);
-            },
-        };
-        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
@@ -1044,7 +962,6 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                         injector._getObjByKeyId(keyId).onDestroy();
                     }
                 });
-                destroyExecutionContext();
                 contextCache = {};
             }),
             ɵinjector: operationAppInjector,
@@ -1136,33 +1053,78 @@ function subscriptionCreator({ contextBuilder, }) {
     return createSubscription;
 }
 
-function apolloGatewayCreator({ schema, typeDefs, createExecution, }) {
-    return function createApolloGateway(options) {
+const CONTEXT_ID = Symbol.for('context-id');
+function apolloExecutorCreator({ createExecution, }) {
+    return function createApolloExecutor(options) {
         const executor = createExecution(options);
-        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,
-                        });
+        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];
+                            }
+                        },
                     },
                 };
+            }
+            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) {
@@ -1259,9 +1221,12 @@ function createApplication(applicationConfig) {
         });
         const createSubscription = subscriptionCreator({ contextBuilder });
         const createExecution = executionCreator({ contextBuilder });
-        const createApolloGateway = apolloGatewayCreator({
+        const createSchemaForApollo = apolloSchemaCreator({
+            createSubscription,
+            contextBuilder,
             schema,
-            typeDefs,
+        });
+        const createApolloExecutor = apolloExecutorCreator({
             createExecution,
         });
         instantiateSingletonProviders({
@@ -1276,7 +1241,8 @@ function createApplication(applicationConfig) {
             createOperationController,
             createSubscription,
             createExecution,
-            createApolloGateway,
+            createSchemaForApollo,
+            createApolloExecutor,
             ɵfactory: applicationFactory,
             ɵconfig: config,
         };
@@ -1594,7 +1560,11 @@ function wrapResolver({ resolver, config, path, middlewareMap, isTypeResolver, i
         const wrappedResolver = (root, context, info) => {
             const ctx = {
                 root,
-                context: context.ɵgetModuleContext(config.id, context),
+                context: isReferenceResolver
+                    ? context.ɵgetModuleContext(config.id, context)
+                    : // We mark the context object as possibly undefined,
+                        // because graphql-jit for some reason doesn't pass it for isTypeOf or resolveType methods
+                        context === null || context === void 0 ? void 0 : context.ɵgetModuleContext(config.id, context),
                 info,
             };
             return resolver(ctx.root, ctx.context, ctx.info);
@@ -1869,31 +1839,41 @@ function ensureDocumentNode(config, typeDefs) {
  */
 const MODULE_ID = new InjectionToken('module-id');
 
+function lazy(getter) {
+    let called = false;
+    let computedValue;
+    return {
+        get value() {
+            if (!called) {
+                called = true;
+                computedValue = getter();
+            }
+            return computedValue;
+        },
+    };
+}
 function moduleFactory(config) {
     const typeDefs = createTypeDefs(config);
     const metadata = metadataFactory(typeDefs, config);
-    const providers = typeof config.providers === 'function'
+    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 singletonProviders = ReflectiveInjector.resolve(onlySingletonProviders(providers));
+    const operationProviders = lazy(() => ReflectiveInjector.resolve(onlyOperationProviders(providers.value)));
+    const singletonProviders = lazy(() => ReflectiveInjector.resolve(onlySingletonProviders(providers.value)));
     const mod = {
         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 = 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({
                 name: `Module "${config.id}" (Singleton Scope)`,
@@ -1980,8 +1960,11 @@ function mockApplication(app) {
             createExecution(options) {
                 return sharedFactory().createExecution(options);
             },
-            createApolloGateway() {
-                return sharedFactory().createApolloGateway();
+            createSchemaForApollo() {
+                return sharedFactory().createSchemaForApollo();
+            },
+            createApolloExecutor() {
+                return sharedFactory().createApolloExecutor();
             },
             get ɵfactory() {
                 return sharedFactory().ɵfactory;

package/module/types.d.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>>;
 /**
@@ -39,12 +38,9 @@ export interface ModuleConfig {
 }
 export interface Module {
     id: ID;
-    providers?: Provider[];
     typeDefs: DocumentNode[];
     metadata: ModuleMetadata;
     factory: ModuleFactory;
-    operationProviders: ResolvedProvider[];
-    singletonProviders: ResolvedProvider[];
     config: ModuleConfig;
 }
 export interface MockedModule extends Module {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-modules",
-  "version": "3.0.0-alpha-20231018163544-36199b68",
+  "version": "3.0.0-alpha-20250219090434-d6cc8940d97c7ef3dba3f59c56376d7cbab77c83",
   "description": "Create reusable, maintainable, testable and extendable GraphQL modules",
   "sideEffects": false,
   "peerDependencies": {
@@ -8,8 +8,9 @@
   },
   "dependencies": {
     "@graphql-tools/schema": "^10.0.0",
+    "@graphql-tools/wrap": "^10.0.0",
     "@graphql-typed-document-node/core": "^3.1.0",
-    "ramda": "^0.29.0"
+    "ramda": "^0.30.0"
   },
   "keywords": [
     "graphql",

package/shared/middleware.d.ts

@@ -16,6 +16,6 @@ export type MiddlewareMap = {
         [field: string]: Middleware[];
     };
 };
-export declare function createMiddleware(path: string[], middlewareMap?: MiddlewareMap): (context: MiddlewareContext, next: Next<any>) => Promise<any>;
+export declare function createMiddleware(path: string[], middlewareMap?: MiddlewareMap): (context: MiddlewareContext, next: Next) => Promise<any>;
 export declare function mergeMiddlewareMaps(app: MiddlewareMap, mod: MiddlewareMap): MiddlewareMap;
 export declare function validateMiddlewareMap(middlewareMap: MiddlewareMap, metadata: ModuleMetadata): void;

package/shared/utils.d.ts

@@ -4,7 +4,7 @@ export declare function isNil<T>(val: T | null | undefined): val is null | undef
 export declare function isObject(val: any): boolean;
 export declare function isPrimitive(val: any): val is number | string | boolean | symbol | bigint;
 export declare function isAsyncIterable(obj: any): obj is AsyncIterableIterator<any>;
-export declare function tapAsyncIterator<T>(iterable: AsyncIterable<T>, doneCallback: () => void): AsyncGenerator<T>;
+export declare function tapAsyncIterator<T, TAsyncIterableIterator extends AsyncIterableIterator<T>>(iterable: TAsyncIterableIterator, doneCallback: () => void): TAsyncIterableIterator;
 export declare function once(cb: () => void): () => void;
 export declare function share<T, A>(factory: (arg?: A) => T): (arg?: A) => T;
 export declare function uniqueId(isNotUsed: (id: string) => boolean): string;

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

@@ -1,10 +0,0 @@
-/// <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

@@ -1,9 +0,0 @@
-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,8 +0,0 @@
-import * as Hooks from './execution-context-hooks';
-export type { ExecutionContextPicker } from './execution-context.interface';
-export declare const executionContext: {
-    create(picker: import("./execution-context.interface").ExecutionContextPicker): () => void;
-    getModuleContext: (moduleId: string) => GraphQLModules.ModuleContext;
-    getApplicationContext: () => GraphQLModules.AppContext;
-};
-export declare const enableExecutionContext: typeof Hooks.enableExecutionContext;

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

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