graphql-modules 3.1.2-alpha-20260121023952-c6236f99446644c787494ddb1a9a973180bab70e → 3.1.2-alpha-20260121024633-8af430e29a180a1d00c50c4bf74d342b3518267c

package/esm/application/apollo.js

@@ -0,0 +1,77 @@
+import { wrapSchema } from '@graphql-tools/wrap';
+import { execute } from 'graphql';
+import { uniqueId } from '../shared/utils';
+const CONTEXT_ID = Symbol.for('context-id');
+export function apolloExecutorCreator({ createExecution, }) {
+    return function createApolloExecutor(options) {
+        const executor = createExecution(options);
+        return async function executorAdapter(requestContext) {
+            return executor({
+                schema: requestContext.schema,
+                document: requestContext.document,
+                operationName: requestContext.operationName,
+                variableValues: requestContext.request.variables,
+                contextValue: requestContext.context,
+            });
+        };
+    };
+}
+export function apolloSchemaCreator({ createSubscription, contextBuilder, schema, }) {
+    const createApolloSchema = () => {
+        const sessions = {};
+        const subscription = createSubscription();
+        function getSession(ctx, { context, ɵdestroy: destroy }) {
+            if (!ctx[CONTEXT_ID]) {
+                ctx[CONTEXT_ID] = uniqueId((id) => !sessions[id]);
+                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 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({
+                        schema,
+                        document: input.document,
+                        contextValue: context,
+                        variableValues: input.variables,
+                        rootValue: input.rootValue,
+                        operationName: input.operationName,
+                    }))
+                        .finally(destroy);
+                });
+            },
+        });
+    };
+    return createApolloSchema;
+}

package/esm/application/application.js

@@ -0,0 +1,146 @@
+import { makeExecutableSchema } from '@graphql-tools/schema';
+import { ReflectiveInjector, onlySingletonProviders, onlyOperationProviders, Scope, } from '../di';
+import { ModuleDuplicatedError, ModuleNonUniqueIdError, } from '../shared/errors';
+import { flatten, isDefined } from '../shared/utils';
+import { createGlobalProvidersMap, attachGlobalProvidersMap, instantiateSingletonProviders, } from './di';
+import { createContextBuilder } from './context';
+import { executionCreator } from './execution';
+import { subscriptionCreator } from './subscription';
+import { apolloSchemaCreator, apolloExecutorCreator } from './apollo';
+import { operationControllerCreator } from './operation-controller';
+/**
+ * @api
+ * Creates Application out of Modules. Accepts `ApplicationConfig`.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createApplication } from 'graphql-modules';
+ * import { usersModule } from './users';
+ * import { postsModule } from './posts';
+ * import { commentsModule } from './comments';
+ *
+ * const app = createApplication({
+ *   modules: [
+ *     usersModule,
+ *     postsModule,
+ *     commentsModule
+ *   ]
+ * })
+ * ```
+ */
+export function createApplication(applicationConfig) {
+    function applicationFactory(cfg) {
+        const config = cfg || applicationConfig;
+        const providers = config.providers && typeof config.providers === 'function'
+            ? config.providers()
+            : config.providers;
+        // Creates an Injector with singleton classes at application level
+        const appSingletonProviders = ReflectiveInjector.resolve(onlySingletonProviders(providers));
+        const appInjector = ReflectiveInjector.createFromResolved({
+            name: 'App (Singleton Scope)',
+            providers: appSingletonProviders,
+        });
+        // Filter Operation-scoped providers, and keep it here
+        // so we don't do it over and over again
+        const appOperationProviders = ReflectiveInjector.resolve(onlyOperationProviders(providers));
+        const middlewareMap = config.middlewares || {};
+        // Validations
+        ensureModuleUniqueIds(config.modules);
+        // Create all modules
+        const modules = config.modules.map((mod) => mod.factory({
+            injector: appInjector,
+            middlewares: middlewareMap,
+        }));
+        const modulesMap = createModulesMap(modules);
+        const singletonGlobalProvidersMap = createGlobalProvidersMap({
+            modules,
+            scope: Scope.Singleton,
+        });
+        const operationGlobalProvidersMap = createGlobalProvidersMap({
+            modules,
+            scope: Scope.Operation,
+        });
+        attachGlobalProvidersMap({
+            injector: appInjector,
+            globalProvidersMap: singletonGlobalProvidersMap,
+            moduleInjectorGetter(moduleId) {
+                return modulesMap.get(moduleId).injector;
+            },
+        });
+        // Creating a schema, flattening the typedefs and resolvers
+        // is not expensive since it happens only once
+        const typeDefs = flatten(modules.map((mod) => mod.typeDefs));
+        const resolvers = modules.map((mod) => mod.resolvers).filter(isDefined);
+        const schema = (applicationConfig.schemaBuilder || makeExecutableSchema)({
+            typeDefs,
+            resolvers,
+        });
+        const contextBuilder = createContextBuilder({
+            appInjector,
+            appLevelOperationProviders: appOperationProviders,
+            modulesMap: modulesMap,
+            singletonGlobalProvidersMap,
+            operationGlobalProvidersMap,
+        });
+        const createOperationController = operationControllerCreator({
+            contextBuilder,
+        });
+        const createSubscription = subscriptionCreator({ contextBuilder });
+        const createExecution = executionCreator({ contextBuilder });
+        const createSchemaForApollo = apolloSchemaCreator({
+            createSubscription,
+            contextBuilder,
+            schema,
+        });
+        const createApolloExecutor = apolloExecutorCreator({
+            createExecution,
+        });
+        instantiateSingletonProviders({
+            appInjector,
+            modulesMap,
+        });
+        return {
+            typeDefs,
+            resolvers,
+            schema,
+            injector: appInjector,
+            createOperationController,
+            createSubscription,
+            createExecution,
+            createSchemaForApollo,
+            createApolloExecutor,
+            ɵfactory: applicationFactory,
+            ɵconfig: config,
+        };
+    }
+    return applicationFactory();
+}
+function createModulesMap(modules) {
+    var _a;
+    const modulesMap = new Map();
+    for (const module of modules) {
+        if (modulesMap.has(module.id)) {
+            const location = module.metadata.dirname;
+            const existingLocation = (_a = modulesMap.get(module.id)) === null || _a === void 0 ? void 0 : _a.metadata.dirname;
+            const info = [];
+            if (existingLocation) {
+                info.push(`Already registered module located at: ${existingLocation}`);
+            }
+            if (location) {
+                info.push(`Duplicated module located at: ${location}`);
+            }
+            throw new ModuleDuplicatedError(`Module "${module.id}" already exists`, ...info);
+        }
+        modulesMap.set(module.id, module);
+    }
+    return modulesMap;
+}
+function ensureModuleUniqueIds(modules) {
+    const collisions = modules
+        .filter((mod, i, all) => i !== all.findIndex((m) => m.id === mod.id))
+        .map((m) => m.id);
+    if (collisions.length) {
+        throw new ModuleNonUniqueIdError(`Modules with non-unique ids: ${collisions.join(', ')}`, `All modules should have unique ids, please locate and fix them.`);
+    }
+}

package/esm/application/context.js

@@ -0,0 +1,140 @@
+import { ReflectiveInjector } from '../di';
+import { once, merge } from '../shared/utils';
+import async_context from '#async-context';
+import { attachGlobalProvidersMap } from './di';
+import { CONTEXT } from './tokens';
+export function createContextBuilder({ appInjector, modulesMap, appLevelOperationProviders, singletonGlobalProvidersMap, operationGlobalProvidersMap, }) {
+    // This is very critical. It creates an execution context.
+    // It has to run on every operation.
+    const contextBuilder = (context) => {
+        // Cache for context per module
+        let contextCache = {};
+        // A list of providers with OnDestroy hooks
+        // It's a tuple because we want to know which Injector controls the provider
+        // and we want to know if the provider was even instantiated.
+        let providersToDestroy = [];
+        function registerProvidersToDestroy(injector) {
+            injector._providers.forEach((provider) => {
+                if (provider.factory.hasOnDestroyHook) {
+                    // keep provider key's id (it doesn't change over time)
+                    // and related injector
+                    providersToDestroy.push([injector, provider.key.id]);
+                }
+            });
+        }
+        let appContext;
+        attachGlobalProvidersMap({
+            injector: appInjector,
+            globalProvidersMap: singletonGlobalProvidersMap,
+            moduleInjectorGetter(moduleId) {
+                return modulesMap.get(moduleId).injector;
+            },
+        });
+        appInjector.setExecutionContextGetter(function executionContextGetter() {
+            var _a;
+            return (((_a = async_context.getAsyncContext()) === null || _a === void 0 ? void 0 : _a.getApplicationContext()) || appContext);
+        });
+        function createModuleExecutionContextGetter(moduleId) {
+            return function moduleExecutionContextGetter() {
+                var _a;
+                return (((_a = async_context.getAsyncContext()) === null || _a === void 0 ? void 0 : _a.getModuleContext(moduleId)) ||
+                    getModuleContext(moduleId, context));
+            };
+        }
+        modulesMap.forEach((mod, moduleId) => {
+            mod.injector.setExecutionContextGetter(createModuleExecutionContextGetter(moduleId));
+        });
+        // 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
+        const operationAppInjector = ReflectiveInjector.createFromResolved({
+            name: 'App (Operation Scope)',
+            providers: appLevelOperationProviders.concat(ReflectiveInjector.resolve([
+                {
+                    provide: CONTEXT,
+                    useValue: context,
+                },
+            ])),
+            parent: appInjector,
+        });
+        // Create a context for application-level ExecutionContext
+        appContext = merge(context, {
+            injector: operationAppInjector,
+        });
+        // Track Providers with OnDestroy hooks
+        registerProvidersToDestroy(operationAppInjector);
+        function getModuleContext(moduleId, ctx) {
+            var _a;
+            // Reuse a context or create if not available
+            if (!contextCache[moduleId]) {
+                // We're interested in operation-scoped providers only
+                const providers = (_a = modulesMap.get(moduleId)) === null || _a === void 0 ? void 0 : _a.operationProviders;
+                // Create module-level Operation-scoped Injector
+                const operationModuleInjector = ReflectiveInjector.createFromResolved({
+                    name: `Module "${moduleId}" (Operation Scope)`,
+                    providers: providers.concat(ReflectiveInjector.resolve([
+                        {
+                            provide: CONTEXT,
+                            useFactory() {
+                                return contextCache[moduleId];
+                            },
+                        },
+                    ])),
+                    // This injector has a priority
+                    parent: modulesMap.get(moduleId).injector,
+                    // over this one
+                    fallbackParent: operationAppInjector,
+                });
+                // Same as on application level, we need to collect providers with OnDestroy hooks
+                registerProvidersToDestroy(operationModuleInjector);
+                contextCache[moduleId] = merge(ctx, {
+                    injector: operationModuleInjector,
+                    moduleId,
+                });
+            }
+            return contextCache[moduleId];
+        }
+        const sharedContext = merge(
+        // We want to pass the received context
+        context || {}, {
+            // Here's something very crutial
+            // It's a function that is used in module's context creation
+            ɵgetModuleContext: getModuleContext,
+        });
+        attachGlobalProvidersMap({
+            injector: operationAppInjector,
+            globalProvidersMap: operationGlobalProvidersMap,
+            moduleInjectorGetter(moduleId) {
+                return getModuleContext(moduleId, sharedContext).injector;
+            },
+        });
+        const env = {
+            ɵdestroy: once(() => {
+                providersToDestroy.forEach(([injector, keyId]) => {
+                    // If provider was instantiated
+                    if (injector._isObjectDefinedByKeyId(keyId)) {
+                        // call its OnDestroy hook
+                        injector._getObjByKeyId(keyId).onDestroy();
+                    }
+                });
+                contextCache = {};
+            }),
+            ɵinjector: operationAppInjector,
+            context: sharedContext,
+        };
+        return {
+            ...env,
+            runWithContext(cb) {
+                return async_context.runWithAsyncContext({
+                    getApplicationContext() {
+                        return appContext;
+                    },
+                    getModuleContext(moduleId) {
+                        return getModuleContext(moduleId, context);
+                    },
+                }, cb, env);
+            },
+        };
+    };
+    return contextBuilder;
+}

package/esm/application/di.js

@@ -0,0 +1,42 @@
+import { Scope } from '../di';
+export function instantiateSingletonProviders({ appInjector, modulesMap, }) {
+    appInjector.instantiateAll();
+    modulesMap.forEach((mod) => {
+        mod.injector.instantiateAll();
+    });
+}
+export function createGlobalProvidersMap({ modules, scope, }) {
+    const globalProvidersMap = {};
+    const propType = scope === Scope.Singleton ? 'singletonProviders' : 'operationProviders';
+    modules.forEach((mod) => {
+        mod[propType].forEach((provider) => {
+            if (provider.factory.isGlobal) {
+                const key = provider.key.id;
+                if (globalProvidersMap[key]) {
+                    throw duplicatedGlobalTokenError(provider, [
+                        mod.id,
+                        globalProvidersMap[key],
+                    ]);
+                }
+                globalProvidersMap[key] = mod.id;
+            }
+        });
+    });
+    return globalProvidersMap;
+}
+export function attachGlobalProvidersMap({ injector, globalProvidersMap, moduleInjectorGetter, }) {
+    injector._globalProvidersMap = {
+        has(key) {
+            return typeof globalProvidersMap[key] === 'string';
+        },
+        get(key) {
+            return moduleInjectorGetter(globalProvidersMap[key]);
+        },
+    };
+}
+export function duplicatedGlobalTokenError(provider, modules) {
+    return Error([
+        `Failed to define '${provider.key.displayName}' token as global.`,
+        `Token provided by two modules: '${modules.join("', '")}'`,
+    ].join(' '));
+}

package/esm/application/execution.js

@@ -0,0 +1,39 @@
+import { execute, } from 'graphql';
+import { isNotSchema } from '../shared/utils';
+export function executionCreator({ contextBuilder, }) {
+    const createExecution = (options) => {
+        // Custom or original execute function
+        const executeFn = (options === null || options === void 0 ? void 0 : options.execute) || execute;
+        return (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) => {
+            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).runWithContext(perform);
+        };
+    };
+    return createExecution;
+}

package/esm/application/operation-controller.js

@@ -0,0 +1,13 @@
+export function operationControllerCreator(options) {
+    const { contextBuilder } = options;
+    return (input) => {
+        const operation = contextBuilder(input.context);
+        const ɵdestroy = input.autoDestroy ? operation.ɵdestroy : () => { };
+        return {
+            context: operation.context,
+            injector: operation.ɵinjector,
+            destroy: operation.ɵdestroy,
+            ɵdestroy,
+        };
+    };
+}

package/esm/application/subscription.js

@@ -0,0 +1,51 @@
+import { subscribe, } from 'graphql';
+import { tapAsyncIterator, isAsyncIterable, isNotSchema, } from '../shared/utils';
+export function subscriptionCreator({ contextBuilder, }) {
+    const createSubscription = (options) => {
+        // 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) => {
+            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).runWithContext(perform);
+        };
+    };
+    return createSubscription;
+}

package/esm/application/tokens.js

@@ -0,0 +1,17 @@
+import { InjectionToken } from '../di';
+/**
+ * @api
+ * `CONTEXT` is an InjectionToken representing the provided `GraphQLModules.GlobalContext`
+ *
+ * @example
+ *
+ * ```typescript
+ * import { CONTEXT, Inject, Injectable } from 'graphql-modules';
+ *
+ * (A)Injectable()
+ * export class Data {
+ *   constructor((A)Inject(CONTEXT) private context: GraphQLModules.GlobalContext) {}
+ * }
+ * ```
+ */
+export const CONTEXT = new InjectionToken('context');

package/esm/di/decorators.js

@@ -0,0 +1,72 @@
+import { isType } from './providers';
+import { INJECTABLE, readInjectableMetadata, ensureInjectableMetadata, } from './metadata';
+function ensureReflect() {
+    if (!(Reflect && Reflect.getOwnMetadata)) {
+        throw 'reflect-metadata shim is required when using class decorators';
+    }
+}
+export function Injectable(options) {
+    return (target) => {
+        var _a;
+        ensureReflect();
+        const params = (Reflect.getMetadata('design:paramtypes', target) || []).map((param) => (isType(param) ? param : null));
+        const existingMeta = readInjectableMetadata(target);
+        const meta = {
+            params: ((_a = existingMeta === null || existingMeta === void 0 ? void 0 : existingMeta.params) === null || _a === void 0 ? void 0 : _a.length) > 0 && params.length === 0
+                ? existingMeta === null || existingMeta === void 0 ? void 0 : existingMeta.params
+                : params.map((param, i) => {
+                    var _a;
+                    const existingParam = (_a = existingMeta === null || existingMeta === void 0 ? void 0 : existingMeta.params) === null || _a === void 0 ? void 0 : _a[i];
+                    return {
+                        type: (existingParam === null || existingParam === void 0 ? void 0 : existingParam.type) || param,
+                        optional: typeof (existingParam === null || existingParam === void 0 ? void 0 : existingParam.optional) === 'boolean'
+                            ? existingParam.optional
+                            : false,
+                    };
+                }),
+            options: {
+                ...((existingMeta === null || existingMeta === void 0 ? void 0 : existingMeta.options) || {}),
+                ...(options || {}),
+            },
+        };
+        target[INJECTABLE] = meta;
+        return target;
+    };
+}
+export function Optional() {
+    return (target, _, index) => {
+        ensureReflect();
+        ensureInjectableMetadata(target);
+        const meta = readInjectableMetadata(target);
+        meta.params[index] = {
+            ...meta.params[index],
+            optional: true,
+        };
+    };
+}
+export function Inject(type) {
+    return (target, _, index) => {
+        ensureReflect();
+        ensureInjectableMetadata(target);
+        const meta = readInjectableMetadata(target);
+        meta.params[index] = {
+            type,
+            optional: false,
+        };
+    };
+}
+export function ExecutionContext() {
+    return (obj, propertyKey) => {
+        ensureReflect();
+        const target = obj.constructor;
+        ensureInjectableMetadata(target);
+        const meta = readInjectableMetadata(target);
+        if (!meta.options) {
+            meta.options = {};
+        }
+        if (!meta.options.executionContextIn) {
+            meta.options.executionContextIn = [];
+        }
+        meta.options.executionContextIn.push(propertyKey);
+    };
+}