graphql-modules 3.0.0-alpha-20231106133212-0b04b56e → 3.0.0

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const schema = require('@graphql-tools/schema');
 const graphql = require('graphql');
+const wrap = require('@graphql-tools/wrap');
 const ramda = require('ramda');
 
 const ERROR_ORIGINAL_ERROR = 'diOriginalError';
@@ -731,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) {
@@ -741,7 +742,7 @@ function tapAsyncIterator(iterable, doneCallback) {
                 throw error;
             }
         },
-        async throw(error) {
+        throw(error) {
             doneCallback();
             return iterator.throw(error);
         },
@@ -768,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;
 }
@@ -1050,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) {
@@ -1173,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({
@@ -1190,7 +1244,8 @@ function createApplication(applicationConfig) {
             createOperationController,
             createSubscription,
             createExecution,
-            createApolloGateway,
+            createSchemaForApollo,
+            createApolloExecutor,
             ɵfactory: applicationFactory,
             ɵconfig: config,
         };
@@ -1787,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)`,
@@ -1898,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,5 +1,6 @@
 import { makeExecutableSchema } from '@graphql-tools/schema';
-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';
@@ -728,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) {
@@ -738,7 +739,7 @@ function tapAsyncIterator(iterable, doneCallback) {
                 throw error;
             }
         },
-        async throw(error) {
+        throw(error) {
             doneCallback();
             return iterator.throw(error);
         },
@@ -765,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;
 }
@@ -1047,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) {
@@ -1170,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({
@@ -1187,7 +1241,8 @@ function createApplication(applicationConfig) {
             createOperationController,
             createSubscription,
             createExecution,
-            createApolloGateway,
+            createSchemaForApollo,
+            createApolloExecutor,
             ɵfactory: applicationFactory,
             ɵconfig: config,
         };
@@ -1784,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)`,
@@ -1895,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-20231106133212-0b04b56e",
+  "version": "3.0.0",
   "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;