graphql-modules 3.1.2-alpha-20260121024117-e03d9c26de1cfd3971986f82b995963e1cc77056 → 3.1.2-alpha-20260121024633-8af430e29a180a1d00c50c4bf74d342b3518267c

package/cjs/application/apollo.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apolloExecutorCreator = apolloExecutorCreator;
+exports.apolloSchemaCreator = apolloSchemaCreator;
+const wrap_1 = require("@graphql-tools/wrap");
+const graphql_1 = require("graphql");
+const utils_1 = require("../shared/utils");
+const CONTEXT_ID = Symbol.for('context-id');
+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,
+            });
+        };
+    };
+}
+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] = (0, utils_1.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 (0, wrap_1.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(() => (0, graphql_1.execute)({
+                        schema,
+                        document: input.document,
+                        contextValue: context,
+                        variableValues: input.variables,
+                        rootValue: input.rootValue,
+                        operationName: input.operationName,
+                    }))
+                        .finally(destroy);
+                });
+            },
+        });
+    };
+    return createApolloSchema;
+}

package/cjs/application/application.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApplication = createApplication;
+const schema_1 = require("@graphql-tools/schema");
+const di_1 = require("../di");
+const errors_1 = require("../shared/errors");
+const utils_1 = require("../shared/utils");
+const di_2 = require("./di");
+const context_1 = require("./context");
+const execution_1 = require("./execution");
+const subscription_1 = require("./subscription");
+const apollo_1 = require("./apollo");
+const operation_controller_1 = require("./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
+ *   ]
+ * })
+ * ```
+ */
+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 = di_1.ReflectiveInjector.resolve((0, di_1.onlySingletonProviders)(providers));
+        const appInjector = di_1.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 = di_1.ReflectiveInjector.resolve((0, di_1.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 = (0, di_2.createGlobalProvidersMap)({
+            modules,
+            scope: di_1.Scope.Singleton,
+        });
+        const operationGlobalProvidersMap = (0, di_2.createGlobalProvidersMap)({
+            modules,
+            scope: di_1.Scope.Operation,
+        });
+        (0, di_2.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 = (0, utils_1.flatten)(modules.map((mod) => mod.typeDefs));
+        const resolvers = modules.map((mod) => mod.resolvers).filter(utils_1.isDefined);
+        const schema = (applicationConfig.schemaBuilder || schema_1.makeExecutableSchema)({
+            typeDefs,
+            resolvers,
+        });
+        const contextBuilder = (0, context_1.createContextBuilder)({
+            appInjector,
+            appLevelOperationProviders: appOperationProviders,
+            modulesMap: modulesMap,
+            singletonGlobalProvidersMap,
+            operationGlobalProvidersMap,
+        });
+        const createOperationController = (0, operation_controller_1.operationControllerCreator)({
+            contextBuilder,
+        });
+        const createSubscription = (0, subscription_1.subscriptionCreator)({ contextBuilder });
+        const createExecution = (0, execution_1.executionCreator)({ contextBuilder });
+        const createSchemaForApollo = (0, apollo_1.apolloSchemaCreator)({
+            createSubscription,
+            contextBuilder,
+            schema,
+        });
+        const createApolloExecutor = (0, apollo_1.apolloExecutorCreator)({
+            createExecution,
+        });
+        (0, di_2.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 errors_1.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 errors_1.ModuleNonUniqueIdError(`Modules with non-unique ids: ${collisions.join(', ')}`, `All modules should have unique ids, please locate and fix them.`);
+    }
+}

package/cjs/application/context.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContextBuilder = createContextBuilder;
+const tslib_1 = require("tslib");
+const di_1 = require("../di");
+const utils_1 = require("../shared/utils");
+const _async_context_1 = tslib_1.__importDefault(require("#async-context"));
+const di_2 = require("./di");
+const tokens_1 = require("./tokens");
+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;
+        (0, di_2.attachGlobalProvidersMap)({
+            injector: appInjector,
+            globalProvidersMap: singletonGlobalProvidersMap,
+            moduleInjectorGetter(moduleId) {
+                return modulesMap.get(moduleId).injector;
+            },
+        });
+        appInjector.setExecutionContextGetter(function executionContextGetter() {
+            var _a;
+            return (((_a = _async_context_1.default.getAsyncContext()) === null || _a === void 0 ? void 0 : _a.getApplicationContext()) || appContext);
+        });
+        function createModuleExecutionContextGetter(moduleId) {
+            return function moduleExecutionContextGetter() {
+                var _a;
+                return (((_a = _async_context_1.default.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 = di_1.ReflectiveInjector.createFromResolved({
+            name: 'App (Operation Scope)',
+            providers: appLevelOperationProviders.concat(di_1.ReflectiveInjector.resolve([
+                {
+                    provide: tokens_1.CONTEXT,
+                    useValue: context,
+                },
+            ])),
+            parent: appInjector,
+        });
+        // Create a context for application-level ExecutionContext
+        appContext = (0, utils_1.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 = di_1.ReflectiveInjector.createFromResolved({
+                    name: `Module "${moduleId}" (Operation Scope)`,
+                    providers: providers.concat(di_1.ReflectiveInjector.resolve([
+                        {
+                            provide: tokens_1.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] = (0, utils_1.merge)(ctx, {
+                    injector: operationModuleInjector,
+                    moduleId,
+                });
+            }
+            return contextCache[moduleId];
+        }
+        const sharedContext = (0, utils_1.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,
+        });
+        (0, di_2.attachGlobalProvidersMap)({
+            injector: operationAppInjector,
+            globalProvidersMap: operationGlobalProvidersMap,
+            moduleInjectorGetter(moduleId) {
+                return getModuleContext(moduleId, sharedContext).injector;
+            },
+        });
+        const env = {
+            ɵdestroy: (0, utils_1.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_1.default.runWithAsyncContext({
+                    getApplicationContext() {
+                        return appContext;
+                    },
+                    getModuleContext(moduleId) {
+                        return getModuleContext(moduleId, context);
+                    },
+                }, cb, env);
+            },
+        };
+    };
+    return contextBuilder;
+}

package/cjs/application/di.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instantiateSingletonProviders = instantiateSingletonProviders;
+exports.createGlobalProvidersMap = createGlobalProvidersMap;
+exports.attachGlobalProvidersMap = attachGlobalProvidersMap;
+exports.duplicatedGlobalTokenError = duplicatedGlobalTokenError;
+const di_1 = require("../di");
+function instantiateSingletonProviders({ appInjector, modulesMap, }) {
+    appInjector.instantiateAll();
+    modulesMap.forEach((mod) => {
+        mod.injector.instantiateAll();
+    });
+}
+function createGlobalProvidersMap({ modules, scope, }) {
+    const globalProvidersMap = {};
+    const propType = scope === di_1.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;
+}
+function attachGlobalProvidersMap({ injector, globalProvidersMap, moduleInjectorGetter, }) {
+    injector._globalProvidersMap = {
+        has(key) {
+            return typeof globalProvidersMap[key] === 'string';
+        },
+        get(key) {
+            return moduleInjectorGetter(globalProvidersMap[key]);
+        },
+    };
+}
+function duplicatedGlobalTokenError(provider, modules) {
+    return Error([
+        `Failed to define '${provider.key.displayName}' token as global.`,
+        `Token provided by two modules: '${modules.join("', '")}'`,
+    ].join(' '));
+}

package/cjs/application/execution.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executionCreator = executionCreator;
+const graphql_1 = require("graphql");
+const utils_1 = require("../shared/utils");
+function executionCreator({ contextBuilder, }) {
+    const createExecution = (options) => {
+        // Custom or original execute function
+        const executeFn = (options === null || options === void 0 ? void 0 : options.execute) || graphql_1.execute;
+        return (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) => {
+            function perform({ context, ɵdestroy: destroy, }) {
+                const executionArgs = (0, utils_1.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((0, utils_1.isNotSchema)(argsOrSchema)
+                ? argsOrSchema.contextValue
+                : contextValue).runWithContext(perform);
+        };
+    };
+    return createExecution;
+}

package/cjs/application/operation-controller.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationControllerCreator = operationControllerCreator;
+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/cjs/application/subscription.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscriptionCreator = subscriptionCreator;
+const graphql_1 = require("graphql");
+const utils_1 = require("../shared/utils");
+function subscriptionCreator({ contextBuilder, }) {
+    const createSubscription = (options) => {
+        // Custom or original subscribe function
+        const subscribeFn = (options === null || options === void 0 ? void 0 : options.subscribe) || graphql_1.subscribe;
+        return (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, subscribeFieldResolver) => {
+            function perform({ context, ɵdestroy: destroy, }) {
+                const subscriptionArgs = (0, utils_1.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 ((0, utils_1.isAsyncIterable)(sub)) {
+                        isIterable = true;
+                        return (0, utils_1.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((0, utils_1.isNotSchema)(argsOrSchema)
+                ? argsOrSchema.contextValue
+                : contextValue).runWithContext(perform);
+        };
+    };
+    return createSubscription;
+}

package/cjs/application/tokens.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTEXT = void 0;
+const di_1 = require("../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) {}
+ * }
+ * ```
+ */
+exports.CONTEXT = new di_1.InjectionToken('context');

package/cjs/di/decorators.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injectable = Injectable;
+exports.Optional = Optional;
+exports.Inject = Inject;
+exports.ExecutionContext = ExecutionContext;
+const providers_1 = require("./providers");
+const metadata_1 = require("./metadata");
+function ensureReflect() {
+    if (!(Reflect && Reflect.getOwnMetadata)) {
+        throw 'reflect-metadata shim is required when using class decorators';
+    }
+}
+function Injectable(options) {
+    return (target) => {
+        var _a;
+        ensureReflect();
+        const params = (Reflect.getMetadata('design:paramtypes', target) || []).map((param) => ((0, providers_1.isType)(param) ? param : null));
+        const existingMeta = (0, metadata_1.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[metadata_1.INJECTABLE] = meta;
+        return target;
+    };
+}
+function Optional() {
+    return (target, _, index) => {
+        ensureReflect();
+        (0, metadata_1.ensureInjectableMetadata)(target);
+        const meta = (0, metadata_1.readInjectableMetadata)(target);
+        meta.params[index] = {
+            ...meta.params[index],
+            optional: true,
+        };
+    };
+}
+function Inject(type) {
+    return (target, _, index) => {
+        ensureReflect();
+        (0, metadata_1.ensureInjectableMetadata)(target);
+        const meta = (0, metadata_1.readInjectableMetadata)(target);
+        meta.params[index] = {
+            type,
+            optional: false,
+        };
+    };
+}
+function ExecutionContext() {
+    return (obj, propertyKey) => {
+        ensureReflect();
+        const target = obj.constructor;
+        (0, metadata_1.ensureInjectableMetadata)(target);
+        const meta = (0, metadata_1.readInjectableMetadata)(target);
+        if (!meta.options) {
+            meta.options = {};
+        }
+        if (!meta.options.executionContextIn) {
+            meta.options.executionContextIn = [];
+        }
+        meta.options.executionContextIn.push(propertyKey);
+    };
+}