graphql-modules 3.0.0 → 3.1.0-alpha-20260116090824-8472185427836c94f78f09105670ec509014b5d7

package/README.md

@@ -4,7 +4,7 @@
 <!-- [![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)
+![CI](https://github.com/graphql-hive/graphql-modules/workflows/CI/badge.svg)
 [![Discord Chat](https://img.shields.io/discord/625400653321076807)](https://the-guild.dev/discord)
 [![GitHub license](https://img.shields.io/badge/license-MIT-lightgrey.svg?maxAge=2592000)]()
 

package/application/async-context.d.ts

@@ -0,0 +1,6 @@
+export interface AsyncContext {
+    getApplicationContext(): GraphQLModules.AppContext;
+    getModuleContext(moduleId: string): GraphQLModules.ModuleContext;
+}
+export declare function getAsyncContext(): AsyncContext | undefined;
+export declare function runWithAsyncContext<R, TArgs extends any[]>(asyncContext: AsyncContext, callback: (...args: TArgs) => R, ...args: TArgs): R;

package/application/context.d.ts

@@ -3,7 +3,10 @@ import { ResolvedProvider } from '../di/resolution';
 import type { InternalAppContext, ModulesMap } from './application';
 export type ExecutionContextBuilder<TContext extends {
     [key: string]: any;
-} = {}> = (context: TContext) => {
+} = {}> = (context: TContext) => ExecutionContextEnv & {
+    runWithContext<TReturn = any>(cb: (env: ExecutionContextEnv) => TReturn): TReturn;
+};
+export type ExecutionContextEnv = {
     context: InternalAppContext;
     ɵdestroy(): void;
     ɵinjector: Injector;

package/index.js

@@ -4,9 +4,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const schema = require('@graphql-tools/schema');
 const graphql = require('graphql');
+const module$1 = require('module');
 const wrap = require('@graphql-tools/wrap');
 const ramda = require('ramda');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+const module__default = /*#__PURE__*/_interopDefaultLegacy(module$1);
+
 const ERROR_ORIGINAL_ERROR = 'diOriginalError';
 function getOriginalError(error) {
     return error[ERROR_ORIGINAL_ERROR];
@@ -141,6 +146,7 @@ class InjectionToken {
 function isType(v) {
     return typeof v === 'function' && v !== Object;
 }
+exports.Scope = void 0;
 (function (Scope) {
     Scope[Scope["Singleton"] = 0] = "Singleton";
     Scope[Scope["Operation"] = 1] = "Operation";
@@ -837,6 +843,23 @@ function duplicatedGlobalTokenError(provider, modules) {
     ].join(' '));
 }
 
+let alc;
+if (typeof process !== 'undefined') {
+    // probably nodejs runtime
+    const require = module__default["default"].createRequire('file:///' /** path is not relevant since we're only loading a builtin */);
+    const hooks = require('async_hooks');
+    alc = new hooks.AsyncLocalStorage();
+}
+function getAsyncContext() {
+    return alc === null || alc === void 0 ? void 0 : alc.getStore();
+}
+function runWithAsyncContext(asyncContext, callback, ...args) {
+    if (!alc) {
+        return callback(...args);
+    }
+    return alc.run(asyncContext, callback, ...args);
+}
+
 /**
  * @api
  * `CONTEXT` is an InjectionToken representing the provided `GraphQLModules.GlobalContext`
@@ -882,11 +905,14 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
             },
         });
         appInjector.setExecutionContextGetter(function executionContextGetter() {
-            return appContext;
+            var _a;
+            return ((_a = getAsyncContext()) === null || _a === void 0 ? void 0 : _a.getApplicationContext()) || appContext;
         });
         function createModuleExecutionContextGetter(moduleId) {
             return function moduleExecutionContextGetter() {
-                return getModuleContext(moduleId, context);
+                var _a;
+                return (((_a = getAsyncContext()) === null || _a === void 0 ? void 0 : _a.getModuleContext(moduleId)) ||
+                    getModuleContext(moduleId, context));
             };
         }
         modulesMap.forEach((mod, moduleId) => {
@@ -956,7 +982,7 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                 return getModuleContext(moduleId, sharedContext).injector;
             },
         });
-        return {
+        const env = {
             ɵdestroy: once(() => {
                 providersToDestroy.forEach(([injector, keyId]) => {
                     // If provider was instantiated
@@ -970,6 +996,19 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
             ɵinjector: operationAppInjector,
             context: sharedContext,
         };
+        return {
+            ...env,
+            runWithContext(cb) {
+                return runWithAsyncContext({
+                    getApplicationContext() {
+                        return appContext;
+                    },
+                    getModuleContext(moduleId) {
+                        return getModuleContext(moduleId, context);
+                    },
+                }, cb, env);
+            },
+        };
     };
     return contextBuilder;
 }
@@ -979,31 +1018,34 @@ function executionCreator({ contextBuilder, }) {
         // Custom or original execute function
         const executeFn = (options === null || options === void 0 ? void 0 : options.execute) || graphql.execute;
         return (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) => {
-            var _a;
-            // Create an execution context
-            const { context, ɵdestroy: destroy } = (_a = options === null || options === void 0 ? void 0 : options.controller) !== null && _a !== void 0 ? _a : contextBuilder(isNotSchema(argsOrSchema)
+            function perform({ context, ɵdestroy: destroy, }) {
+                const executionArgs = isNotSchema(argsOrSchema)
+                    ? {
+                        ...argsOrSchema,
+                        contextValue: context,
+                    }
+                    : {
+                        schema: argsOrSchema,
+                        document: document,
+                        rootValue,
+                        contextValue: context,
+                        variableValues,
+                        operationName,
+                        fieldResolver,
+                        typeResolver,
+                    };
+                // 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(() => executeFn(executionArgs))
+                    .finally(destroy);
+            }
+            if (options === null || options === void 0 ? void 0 : options.controller) {
+                return perform(options.controller);
+            }
+            return contextBuilder(isNotSchema(argsOrSchema)
                 ? argsOrSchema.contextValue
-                : contextValue);
-            const executionArgs = isNotSchema(argsOrSchema)
-                ? {
-                    ...argsOrSchema,
-                    contextValue: context,
-                }
-                : {
-                    schema: argsOrSchema,
-                    document: document,
-                    rootValue,
-                    contextValue: context,
-                    variableValues,
-                    operationName,
-                    fieldResolver,
-                    typeResolver,
-                };
-            // 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(() => executeFn(executionArgs))
-                .finally(destroy);
+                : contextValue).runWithContext(perform);
         };
     };
     return createExecution;
@@ -1014,43 +1056,46 @@ function subscriptionCreator({ contextBuilder, }) {
         // Custom or original subscribe function
         const subscribeFn = (options === null || options === void 0 ? void 0 : options.subscribe) || graphql.subscribe;
         return (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, subscribeFieldResolver) => {
-            var _a;
-            // Create an subscription context
-            const { context, ɵdestroy: destroy } = (_a = options === null || options === void 0 ? void 0 : options.controller) !== null && _a !== void 0 ? _a : contextBuilder(isNotSchema(argsOrSchema)
+            function perform({ context, ɵdestroy: destroy, }) {
+                const subscriptionArgs = isNotSchema(argsOrSchema)
+                    ? {
+                        ...argsOrSchema,
+                        contextValue: context,
+                    }
+                    : {
+                        schema: argsOrSchema,
+                        document: document,
+                        rootValue,
+                        contextValue: context,
+                        variableValues,
+                        operationName,
+                        fieldResolver,
+                        subscribeFieldResolver,
+                    };
+                let isIterable = false;
+                // It's important to wrap the subscribeFn within a promise
+                // so we can easily control the end of subscription (with finally)
+                return Promise.resolve()
+                    .then(() => subscribeFn(subscriptionArgs))
+                    .then((sub) => {
+                    if (isAsyncIterable(sub)) {
+                        isIterable = true;
+                        return tapAsyncIterator(sub, destroy);
+                    }
+                    return sub;
+                })
+                    .finally(() => {
+                    if (!isIterable) {
+                        destroy();
+                    }
+                });
+            }
+            if (options === null || options === void 0 ? void 0 : options.controller) {
+                return perform(options.controller);
+            }
+            return contextBuilder(isNotSchema(argsOrSchema)
                 ? argsOrSchema.contextValue
-                : contextValue);
-            const subscriptionArgs = isNotSchema(argsOrSchema)
-                ? {
-                    ...argsOrSchema,
-                    contextValue: context,
-                }
-                : {
-                    schema: argsOrSchema,
-                    document: document,
-                    rootValue,
-                    contextValue: context,
-                    variableValues,
-                    operationName,
-                    fieldResolver,
-                    subscribeFieldResolver,
-                };
-            let isIterable = false;
-            // It's important to wrap the subscribeFn within a promise
-            // so we can easily control the end of subscription (with finally)
-            return Promise.resolve()
-                .then(() => subscribeFn(subscriptionArgs))
-                .then((sub) => {
-                if (isAsyncIterable(sub)) {
-                    isIterable = true;
-                    return tapAsyncIterator(sub, destroy);
-                }
-                return sub;
-            })
-                .finally(() => {
-                if (!isIterable) {
-                    destroy();
-                }
-            });
+                : contextValue).runWithContext(perform);
         };
     };
     return createSubscription;
@@ -1075,10 +1120,9 @@ function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }) {
     const createApolloSchema = () => {
         const sessions = {};
         const subscription = createSubscription();
-        function getSession(ctx) {
+        function getSession(ctx, { context, ɵdestroy: destroy }) {
             if (!ctx[CONTEXT_ID]) {
                 ctx[CONTEXT_ID] = uniqueId((id) => !sessions[id]);
-                const { context, ɵdestroy: destroy } = contextBuilder(ctx);
                 sessions[ctx[CONTEXT_ID]] = {
                     count: 0,
                     session: {
@@ -1110,20 +1154,22 @@ function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }) {
                         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);
+                // Create an execution context and run within it
+                return contextBuilder(input.context).runWithContext((env) => {
+                    const { context, destroy } = getSession(input.context, env);
+                    // 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);
+                });
             },
         });
     };
@@ -1545,6 +1591,12 @@ function createResolvers(config, metadata, app) {
                                 });
                                 resolvers[typeName][fieldName].subscribe = resolver;
                             }
+                            if (isDefined(obj[fieldName].extensions)) {
+                                // Do NOT add a resolve if one is not specified, it will cause
+                                // change in behavior in systems like `grafast`
+                                resolvers[typeName][fieldName].extensions =
+                                    obj[fieldName].extensions;
+                            }
                         }
                     }
                 }
@@ -1665,6 +1717,14 @@ function addObject({ typeName, fields, container, config, }) {
                     writeResolverMetadata(resolver.subscribe, config);
                     container[typeName][fieldName].subscribe = resolver.subscribe;
                 }
+                // extensions
+                if (isDefined(resolver.extensions)) {
+                    if (container[typeName][fieldName].extensions) {
+                        throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}" (extensions object)`, useLocation({ dirname: config.dirname, id: config.id }));
+                    }
+                    writeResolverMetadata(resolver.extensions, config);
+                    container[typeName][fieldName].extensions = resolver.extensions;
+                }
             }
         }
     }
@@ -1795,7 +1855,9 @@ function isResolveFn(value) {
     return typeof value === 'function';
 }
 function isResolveOptions(value) {
-    return isDefined(value.resolve) || isDefined(value.subscribe);
+    return (isDefined(value.resolve) ||
+        isDefined(value.subscribe) ||
+        isDefined(value.extensions));
 }
 function isScalarResolver(obj) {
     return obj instanceof graphql.GraphQLScalarType;

package/index.mjs

@@ -1,5 +1,6 @@
 import { makeExecutableSchema } from '@graphql-tools/schema';
-import { GraphQLSchema, execute as execute$1, subscribe, visit, Kind, GraphQLScalarType, concatAST, defaultFieldResolver, parse } from 'graphql';
+import { GraphQLSchema, execute as execute$1, subscribe, visit, Kind, concatAST, defaultFieldResolver, GraphQLScalarType, parse } from 'graphql';
+import module from 'module';
 import { wrapSchema } from '@graphql-tools/wrap';
 import { mergeDeepWith } from 'ramda';
 
@@ -834,6 +835,23 @@ function duplicatedGlobalTokenError(provider, modules) {
     ].join(' '));
 }
 
+let alc;
+if (typeof process !== 'undefined') {
+    // probably nodejs runtime
+    const require = module.createRequire('file:///' /** path is not relevant since we're only loading a builtin */);
+    const hooks = require('async_hooks');
+    alc = new hooks.AsyncLocalStorage();
+}
+function getAsyncContext() {
+    return alc === null || alc === void 0 ? void 0 : alc.getStore();
+}
+function runWithAsyncContext(asyncContext, callback, ...args) {
+    if (!alc) {
+        return callback(...args);
+    }
+    return alc.run(asyncContext, callback, ...args);
+}
+
 /**
  * @api
  * `CONTEXT` is an InjectionToken representing the provided `GraphQLModules.GlobalContext`
@@ -879,11 +897,14 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
             },
         });
         appInjector.setExecutionContextGetter(function executionContextGetter() {
-            return appContext;
+            var _a;
+            return ((_a = getAsyncContext()) === null || _a === void 0 ? void 0 : _a.getApplicationContext()) || appContext;
         });
         function createModuleExecutionContextGetter(moduleId) {
             return function moduleExecutionContextGetter() {
-                return getModuleContext(moduleId, context);
+                var _a;
+                return (((_a = getAsyncContext()) === null || _a === void 0 ? void 0 : _a.getModuleContext(moduleId)) ||
+                    getModuleContext(moduleId, context));
             };
         }
         modulesMap.forEach((mod, moduleId) => {
@@ -953,7 +974,7 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
                 return getModuleContext(moduleId, sharedContext).injector;
             },
         });
-        return {
+        const env = {
             ɵdestroy: once(() => {
                 providersToDestroy.forEach(([injector, keyId]) => {
                     // If provider was instantiated
@@ -967,6 +988,19 @@ function createContextBuilder({ appInjector, modulesMap, appLevelOperationProvid
             ɵinjector: operationAppInjector,
             context: sharedContext,
         };
+        return {
+            ...env,
+            runWithContext(cb) {
+                return runWithAsyncContext({
+                    getApplicationContext() {
+                        return appContext;
+                    },
+                    getModuleContext(moduleId) {
+                        return getModuleContext(moduleId, context);
+                    },
+                }, cb, env);
+            },
+        };
     };
     return contextBuilder;
 }
@@ -976,31 +1010,34 @@ function executionCreator({ contextBuilder, }) {
         // Custom or original execute function
         const executeFn = (options === null || options === void 0 ? void 0 : options.execute) || execute$1;
         return (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) => {
-            var _a;
-            // Create an execution context
-            const { context, ɵdestroy: destroy } = (_a = options === null || options === void 0 ? void 0 : options.controller) !== null && _a !== void 0 ? _a : contextBuilder(isNotSchema(argsOrSchema)
+            function perform({ context, ɵdestroy: destroy, }) {
+                const executionArgs = isNotSchema(argsOrSchema)
+                    ? {
+                        ...argsOrSchema,
+                        contextValue: context,
+                    }
+                    : {
+                        schema: argsOrSchema,
+                        document: document,
+                        rootValue,
+                        contextValue: context,
+                        variableValues,
+                        operationName,
+                        fieldResolver,
+                        typeResolver,
+                    };
+                // 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(() => executeFn(executionArgs))
+                    .finally(destroy);
+            }
+            if (options === null || options === void 0 ? void 0 : options.controller) {
+                return perform(options.controller);
+            }
+            return contextBuilder(isNotSchema(argsOrSchema)
                 ? argsOrSchema.contextValue
-                : contextValue);
-            const executionArgs = isNotSchema(argsOrSchema)
-                ? {
-                    ...argsOrSchema,
-                    contextValue: context,
-                }
-                : {
-                    schema: argsOrSchema,
-                    document: document,
-                    rootValue,
-                    contextValue: context,
-                    variableValues,
-                    operationName,
-                    fieldResolver,
-                    typeResolver,
-                };
-            // 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(() => executeFn(executionArgs))
-                .finally(destroy);
+                : contextValue).runWithContext(perform);
         };
     };
     return createExecution;
@@ -1011,43 +1048,46 @@ function subscriptionCreator({ contextBuilder, }) {
         // Custom or original subscribe function
         const subscribeFn = (options === null || options === void 0 ? void 0 : options.subscribe) || subscribe;
         return (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, subscribeFieldResolver) => {
-            var _a;
-            // Create an subscription context
-            const { context, ɵdestroy: destroy } = (_a = options === null || options === void 0 ? void 0 : options.controller) !== null && _a !== void 0 ? _a : contextBuilder(isNotSchema(argsOrSchema)
+            function perform({ context, ɵdestroy: destroy, }) {
+                const subscriptionArgs = isNotSchema(argsOrSchema)
+                    ? {
+                        ...argsOrSchema,
+                        contextValue: context,
+                    }
+                    : {
+                        schema: argsOrSchema,
+                        document: document,
+                        rootValue,
+                        contextValue: context,
+                        variableValues,
+                        operationName,
+                        fieldResolver,
+                        subscribeFieldResolver,
+                    };
+                let isIterable = false;
+                // It's important to wrap the subscribeFn within a promise
+                // so we can easily control the end of subscription (with finally)
+                return Promise.resolve()
+                    .then(() => subscribeFn(subscriptionArgs))
+                    .then((sub) => {
+                    if (isAsyncIterable(sub)) {
+                        isIterable = true;
+                        return tapAsyncIterator(sub, destroy);
+                    }
+                    return sub;
+                })
+                    .finally(() => {
+                    if (!isIterable) {
+                        destroy();
+                    }
+                });
+            }
+            if (options === null || options === void 0 ? void 0 : options.controller) {
+                return perform(options.controller);
+            }
+            return contextBuilder(isNotSchema(argsOrSchema)
                 ? argsOrSchema.contextValue
-                : contextValue);
-            const subscriptionArgs = isNotSchema(argsOrSchema)
-                ? {
-                    ...argsOrSchema,
-                    contextValue: context,
-                }
-                : {
-                    schema: argsOrSchema,
-                    document: document,
-                    rootValue,
-                    contextValue: context,
-                    variableValues,
-                    operationName,
-                    fieldResolver,
-                    subscribeFieldResolver,
-                };
-            let isIterable = false;
-            // It's important to wrap the subscribeFn within a promise
-            // so we can easily control the end of subscription (with finally)
-            return Promise.resolve()
-                .then(() => subscribeFn(subscriptionArgs))
-                .then((sub) => {
-                if (isAsyncIterable(sub)) {
-                    isIterable = true;
-                    return tapAsyncIterator(sub, destroy);
-                }
-                return sub;
-            })
-                .finally(() => {
-                if (!isIterable) {
-                    destroy();
-                }
-            });
+                : contextValue).runWithContext(perform);
         };
     };
     return createSubscription;
@@ -1072,10 +1112,9 @@ function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }) {
     const createApolloSchema = () => {
         const sessions = {};
         const subscription = createSubscription();
-        function getSession(ctx) {
+        function getSession(ctx, { context, ɵdestroy: destroy }) {
             if (!ctx[CONTEXT_ID]) {
                 ctx[CONTEXT_ID] = uniqueId((id) => !sessions[id]);
-                const { context, ɵdestroy: destroy } = contextBuilder(ctx);
                 sessions[ctx[CONTEXT_ID]] = {
                     count: 0,
                     session: {
@@ -1107,20 +1146,22 @@ function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }) {
                         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);
+                // Create an execution context and run within it
+                return contextBuilder(input.context).runWithContext((env) => {
+                    const { context, destroy } = getSession(input.context, env);
+                    // 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);
+                });
             },
         });
     };
@@ -1542,6 +1583,12 @@ function createResolvers(config, metadata, app) {
                                 });
                                 resolvers[typeName][fieldName].subscribe = resolver;
                             }
+                            if (isDefined(obj[fieldName].extensions)) {
+                                // Do NOT add a resolve if one is not specified, it will cause
+                                // change in behavior in systems like `grafast`
+                                resolvers[typeName][fieldName].extensions =
+                                    obj[fieldName].extensions;
+                            }
                         }
                     }
                 }
@@ -1662,6 +1709,14 @@ function addObject({ typeName, fields, container, config, }) {
                     writeResolverMetadata(resolver.subscribe, config);
                     container[typeName][fieldName].subscribe = resolver.subscribe;
                 }
+                // extensions
+                if (isDefined(resolver.extensions)) {
+                    if (container[typeName][fieldName].extensions) {
+                        throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}" (extensions object)`, useLocation({ dirname: config.dirname, id: config.id }));
+                    }
+                    writeResolverMetadata(resolver.extensions, config);
+                    container[typeName][fieldName].extensions = resolver.extensions;
+                }
             }
         }
     }
@@ -1792,7 +1847,9 @@ function isResolveFn(value) {
     return typeof value === 'function';
 }
 function isResolveOptions(value) {
-    return isDefined(value.resolve) || isDefined(value.subscribe);
+    return (isDefined(value.resolve) ||
+        isDefined(value.subscribe) ||
+        isDefined(value.extensions));
 }
 function isScalarResolver(obj) {
     return obj instanceof GraphQLScalarType;

package/module/resolvers.d.ts

@@ -1,3 +1,4 @@
+import { GraphQLFieldExtensions } from 'graphql';
 import { ModuleConfig } from './types';
 import { ModuleMetadata } from './metadata';
 import { ResolveFn, ID } from './../shared/types';
@@ -8,5 +9,5 @@ interface ResolverMetadata {
 export declare function createResolvers(config: ModuleConfig, metadata: ModuleMetadata, app: {
     middlewareMap: MiddlewareMap;
 }): Record<string, any>;
-export declare function readResolverMetadata(resolver: ResolveFn): ResolverMetadata;
+export declare function readResolverMetadata(resolver: ResolveFn | GraphQLFieldExtensions<any, any, any>): ResolverMetadata;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphql-modules",
-  "version": "3.0.0",
+  "version": "3.1.0-alpha-20260116090824-8472185427836c94f78f09105670ec509014b5d7",
   "description": "Create reusable, maintainable, testable and extendable GraphQL modules",
   "sideEffects": false,
   "peerDependencies": {