graphql-modules 3.1.2-alpha-20260121024117-e03d9c26de1cfd3971986f82b995963e1cc77056 → 3.1.2-alpha-20260121025807-95ab4fb1994c3cf68c88a7cf234efd8f99f92ed1

package/cjs/testing/test-module.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockModule = mockModule;
+exports.testModule = testModule;
+const graphql_1 = require("graphql");
+const factory_1 = require("../module/factory");
+const application_1 = require("../application/application");
+const module_1 = require("../module/module");
+function mockModule(testedModule, overrideConfig) {
+    const sourceProviders = typeof testedModule.config.providers === 'function'
+        ? testedModule.config.providers()
+        : testedModule.config.providers;
+    const overrideProviders = typeof overrideConfig.providers === 'function'
+        ? overrideConfig.providers()
+        : overrideConfig.providers;
+    const newModule = (0, module_1.createModule)({
+        ...testedModule.config,
+        providers: [...(sourceProviders || []), ...(overrideProviders || [])],
+    });
+    newModule['ɵoriginalModule'] = testedModule;
+    return newModule;
+}
+function testModule(testedModule, config) {
+    var _a;
+    const mod = transformModule(testedModule, config);
+    const modules = [mod].concat((_a = config === null || config === void 0 ? void 0 : config.modules) !== null && _a !== void 0 ? _a : []);
+    return (0, application_1.createApplication)({
+        ...(config || {}),
+        modules,
+        providers: config === null || config === void 0 ? void 0 : config.providers,
+        middlewares: config === null || config === void 0 ? void 0 : config.middlewares,
+    });
+}
+function transformModule(mod, config) {
+    const transforms = [];
+    if (config === null || config === void 0 ? void 0 : config.replaceExtensions) {
+        transforms.push((m) => (0, factory_1.moduleFactory)({
+            ...m.config,
+            typeDefs: replaceExtensions(m.typeDefs),
+        }));
+    }
+    if (config === null || config === void 0 ? void 0 : config.typeDefs) {
+        transforms.push((m) => (0, factory_1.moduleFactory)({
+            ...m.config,
+            typeDefs: m.typeDefs.concat(config.typeDefs),
+        }));
+    }
+    if (config === null || config === void 0 ? void 0 : config.inheritTypeDefs) {
+        transforms.push((m) => (0, factory_1.moduleFactory)({
+            ...m.config,
+            typeDefs: inheritTypeDefs(m.typeDefs, config.inheritTypeDefs),
+        }));
+    }
+    if (config === null || config === void 0 ? void 0 : config.resolvers) {
+        transforms.push((m) => {
+            const resolvers = m.config.resolvers
+                ? Array.isArray(m.config.resolvers)
+                    ? m.config.resolvers
+                    : [m.config.resolvers]
+                : [];
+            return (0, factory_1.moduleFactory)({
+                ...m.config,
+                resolvers: resolvers.concat(config.resolvers),
+            });
+        });
+    }
+    if (config === null || config === void 0 ? void 0 : config.providers) {
+        transforms.push((m) => {
+            const sourceProviders = typeof m.config.providers === 'function'
+                ? m.config.providers()
+                : m.config.providers;
+            const overrideProviders = typeof config.providers === 'function'
+                ? config.providers()
+                : config.providers;
+            return (0, factory_1.moduleFactory)({
+                ...m.config,
+                providers: [...(sourceProviders || []), ...(overrideProviders || [])],
+            });
+        });
+    }
+    if (transforms) {
+        return transforms.reduce((m, transform) => transform(m), mod);
+    }
+    return mod;
+}
+function inheritTypeDefs(originalTypeDefs, modules) {
+    const original = (0, graphql_1.concatAST)(originalTypeDefs);
+    const typeDefs = treeshakeTypesDefs(original, modules.reduce((typeDefs, externalMod) => typeDefs.concat(externalMod.typeDefs), []));
+    return typeDefs;
+}
+function replaceExtensions(typeDefs) {
+    const types = [];
+    const extensions = [];
+    // List all object types
+    typeDefs.forEach((doc) => {
+        (0, graphql_1.visit)(doc, {
+            ObjectTypeDefinition(node) {
+                types.push(node.name.value);
+            },
+        });
+    });
+    // turn object type extensions into object types
+    return typeDefs.map((doc) => {
+        return (0, graphql_1.visit)(doc, {
+            ObjectTypeExtension(node) {
+                // only if object type doesn't exist
+                if (extensions.includes(node.name.value) ||
+                    types.includes(node.name.value)) {
+                    return node;
+                }
+                return {
+                    ...node,
+                    kind: graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+                };
+            },
+        });
+    });
+}
+function treeshakeTypesDefs(originalSource, sources) {
+    const namedTypes = originalSource.definitions.filter(isNamedTypeDefinition);
+    const typesToVisit = namedTypes.map((def) => def.name.value);
+    const rootFields = namedTypes.reduce((acc, node) => {
+        const typeName = node.name.value;
+        if (isRootType(typeName) && hasFields(node)) {
+            if (!acc[typeName]) {
+                acc[typeName] = [];
+            }
+            node.fields.forEach((field) => {
+                acc[typeName].push(field.name.value);
+            });
+        }
+        return acc;
+    }, {});
+    const schema = (0, graphql_1.concatAST)([originalSource].concat(sources));
+    const involvedTypes = new Set(visitTypes(schema, typesToVisit, rootFields));
+    return {
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions: schema.definitions.filter((def) => {
+            var _a, _b;
+            if (isNamedTypeDefinition(def)) {
+                const typeName = def.name.value;
+                if (!involvedTypes.has(def.name.value)) {
+                    return false;
+                }
+                if ((_a = rootFields[typeName]) === null || _a === void 0 ? void 0 : _a.length) {
+                    const rootType = def;
+                    if ((_b = rootType.fields) === null || _b === void 0 ? void 0 : _b.every((field) => !rootFields[typeName].includes(field.name.value))) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }),
+    };
+}
+function isNamedTypeDefinition(def) {
+    return (!!def &&
+        def.kind !== graphql_1.Kind.SCHEMA_DEFINITION &&
+        def.kind !== graphql_1.Kind.SCHEMA_EXTENSION);
+}
+function visitTypes(schema, types, rootFields) {
+    const visitedTypes = [];
+    const scalars = schema.definitions
+        .filter((def) => def.kind === graphql_1.Kind.SCALAR_TYPE_DEFINITION ||
+        def.kind === graphql_1.Kind.SCALAR_TYPE_EXTENSION)
+        .map((def) => def.name.value);
+    for (const typeName of types) {
+        collectType(typeName);
+    }
+    return visitedTypes;
+    function collectField(field, parentTypeName) {
+        var _a;
+        if (parentTypeName &&
+            isRootType(parentTypeName) &&
+            ((_a = rootFields[parentTypeName]) === null || _a === void 0 ? void 0 : _a.length) &&
+            !rootFields[parentTypeName].includes(field.name.value)) {
+            return;
+        }
+        collectType(resolveType(field.type));
+        if (field.arguments) {
+            field.arguments.forEach((arg) => {
+                collectType(resolveType(arg.type));
+            });
+        }
+        if (field.directives) {
+            field.directives.forEach((directive) => {
+                collectType(directive.name.value);
+            });
+        }
+    }
+    function collectType(typeName) {
+        if (visitedTypes.includes(typeName)) {
+            return;
+        }
+        if (isScalar(typeName)) {
+            visitedTypes.push(typeName);
+            return;
+        }
+        const types = findTypes(typeName);
+        visitedTypes.push(typeName);
+        types.forEach((type) => {
+            if (hasFields(type)) {
+                type.fields.forEach((field) => {
+                    collectField(field, typeName);
+                });
+            }
+            if (hasTypes(type)) {
+                type.types.forEach((t) => {
+                    collectType(resolveType(t));
+                });
+            }
+            if (hasInterfaces(type)) {
+                type.interfaces.forEach((i) => {
+                    collectType(resolveType(i));
+                });
+            }
+        });
+    }
+    function resolveType(type) {
+        if (type.kind === 'ListType') {
+            return resolveType(type.type);
+        }
+        if (type.kind === 'NonNullType') {
+            return resolveType(type.type);
+        }
+        return type.name.value;
+    }
+    function isScalar(name) {
+        return scalars
+            .concat(['String', 'Boolean', 'Int', 'ID', 'Float'])
+            .includes(name);
+    }
+    function findTypes(typeName) {
+        const types = schema.definitions.filter((def) => isNamedTypeDefinition(def) && def.name.value === typeName);
+        if (!types.length) {
+            throw new Error(`Missing type "${typeName}"`);
+        }
+        return types;
+    }
+}
+function hasInterfaces(def) {
+    return (hasPropValue(def, 'interfaces') &&
+        [
+            graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+            graphql_1.Kind.OBJECT_TYPE_EXTENSION,
+            graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
+            graphql_1.Kind.INTERFACE_TYPE_EXTENSION,
+        ].includes(def.kind));
+}
+function hasTypes(def) {
+    return ([graphql_1.Kind.UNION_TYPE_DEFINITION, graphql_1.Kind.UNION_TYPE_EXTENSION].includes(def.kind) && hasPropValue(def, 'types'));
+}
+function hasFields(def) {
+    return ([
+        graphql_1.Kind.OBJECT_TYPE_DEFINITION,
+        graphql_1.Kind.OBJECT_TYPE_EXTENSION,
+        graphql_1.Kind.INTERFACE_TYPE_DEFINITION,
+        graphql_1.Kind.INTERFACE_TYPE_EXTENSION,
+        graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+    ].includes(def.kind) && hasPropValue(def, 'fields'));
+}
+function hasPropValue(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop) && obj[prop];
+}
+function isRootType(typeName) {
+    return (typeName === 'Query' ||
+        typeName === 'Mutation' ||
+        typeName === 'Subscription');
+}

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(' '));
+}