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

package/esm/di/resolution.js

@@ -0,0 +1,159 @@
+import { Type, isClassProvider, isFactoryProvider, } from './providers';
+import { invalidProviderError, noAnnotationError } from './errors';
+import { Key } from './registry';
+import { resolveForwardRef } from './forward-ref';
+import { readInjectableMetadata } from './metadata';
+const _EMPTY_LIST = [];
+export class ResolvedProvider {
+    constructor(key, factory) {
+        this.key = key;
+        this.factory = factory;
+    }
+}
+export class ResolvedFactory {
+    constructor(
+    /**
+     * Factory function which can return an instance of an object represented by a key.
+     */
+    factory, 
+    /**
+     * Arguments (dependencies) to the `factory` function.
+     */
+    dependencies, 
+    /**
+     * Methods invoked within ExecutionContext.
+     */
+    executionContextIn, 
+    /**
+     * Has onDestroy hook
+     */
+    hasOnDestroyHook, 
+    /**
+     * Is Global
+     */
+    isGlobal) {
+        this.factory = factory;
+        this.dependencies = dependencies;
+        this.executionContextIn = executionContextIn;
+        this.hasOnDestroyHook = hasOnDestroyHook;
+        this.isGlobal = isGlobal;
+    }
+}
+export class Dependency {
+    constructor(key, optional) {
+        this.key = key;
+        this.optional = optional;
+    }
+    static fromKey(key) {
+        return new Dependency(key, false);
+    }
+}
+export function resolveProviders(providers) {
+    const normalized = normalizeProviders(providers, []);
+    const resolved = normalized.map(resolveProvider);
+    const resolvedProviderMap = mergeResolvedProviders(resolved, new Map());
+    return Array.from(resolvedProviderMap.values());
+}
+function resolveProvider(provider) {
+    return new ResolvedProvider(Key.get(provider.provide), resolveFactory(provider));
+}
+function mergeResolvedProviders(providers, normalizedProvidersMap) {
+    for (let i = 0; i < providers.length; i++) {
+        const provider = providers[i];
+        normalizedProvidersMap.set(provider.key.id, provider);
+    }
+    return normalizedProvidersMap;
+}
+function normalizeProviders(providers, res) {
+    providers.forEach((token) => {
+        if (token instanceof Type) {
+            res.push({ provide: token, useClass: token });
+        }
+        else if (token &&
+            typeof token === 'object' &&
+            token.provide !== undefined) {
+            res.push(token);
+        }
+        else if (token instanceof Array) {
+            normalizeProviders(token, res);
+        }
+        else {
+            throw invalidProviderError(token);
+        }
+    });
+    return res;
+}
+function resolveFactory(provider) {
+    let factoryFn;
+    let resolvedDeps = _EMPTY_LIST;
+    let executionContextIn = _EMPTY_LIST;
+    let hasOnDestroyHook = false;
+    let isGlobal;
+    if (isClassProvider(provider)) {
+        const useClass = resolveForwardRef(provider.useClass);
+        factoryFn = makeFactory(useClass);
+        resolvedDeps = dependenciesFor(useClass);
+        executionContextIn = executionContextInFor(useClass);
+        isGlobal = globalFor(useClass);
+        hasOnDestroyHook = typeof useClass.prototype.onDestroy === 'function';
+    }
+    else if (isFactoryProvider(provider)) {
+        factoryFn = provider.useFactory;
+        resolvedDeps = constructDependencies(provider.useFactory, provider.deps || []);
+        isGlobal = provider.global;
+        if (provider.executionContextIn) {
+            executionContextIn = provider.executionContextIn;
+        }
+    }
+    else {
+        factoryFn = () => provider.useValue;
+        resolvedDeps = _EMPTY_LIST;
+        isGlobal = provider.global;
+    }
+    return new ResolvedFactory(factoryFn, resolvedDeps, executionContextIn, hasOnDestroyHook, isGlobal !== null && isGlobal !== void 0 ? isGlobal : false);
+}
+function dependenciesFor(type) {
+    const { params } = readInjectableMetadata(type, true);
+    if (!params) {
+        return [];
+    }
+    if (params.some((p) => p.type == null)) {
+        throw noAnnotationError(type, params);
+    }
+    return params.map((p) => extractToken(p, params));
+}
+function executionContextInFor(type) {
+    const { options } = readInjectableMetadata(type, true);
+    if ((options === null || options === void 0 ? void 0 : options.executionContextIn) &&
+        options.executionContextIn !== _EMPTY_LIST) {
+        return options === null || options === void 0 ? void 0 : options.executionContextIn;
+    }
+    return [];
+}
+function globalFor(type) {
+    var _a;
+    const { options } = readInjectableMetadata(type);
+    return (_a = options === null || options === void 0 ? void 0 : options.global) !== null && _a !== void 0 ? _a : false;
+}
+function constructDependencies(typeOrFunc, dependencies) {
+    if (!dependencies) {
+        return dependenciesFor(typeOrFunc);
+    }
+    else {
+        const params = dependencies.map((d) => ({ type: d, optional: false }));
+        return params.map((t) => extractToken(t, params));
+    }
+}
+function extractToken(param, params) {
+    const token = resolveForwardRef(param.type);
+    if (token) {
+        return createDependency(token, param.optional);
+    }
+    throw noAnnotationError(param.type, params);
+}
+function createDependency(token, optional) {
+    return new Dependency(Key.get(token), optional);
+}
+function makeFactory(t) {
+    return (...args) => new t(...args);
+}

package/esm/di/utils.js

@@ -0,0 +1,36 @@
+export const ERROR_TYPE = 'diType';
+export const ERROR_ORIGINAL_ERROR = 'diOriginalError';
+export const ERROR_LOGGER = 'diErrorLogger';
+export function getType(error) {
+    return error[ERROR_TYPE];
+}
+export function getOriginalError(error) {
+    return error[ERROR_ORIGINAL_ERROR];
+}
+function defaultErrorLogger(console, ...values) {
+    // eslint-disable-next-line no-console
+    console.error(...values);
+}
+export function getErrorLogger(error) {
+    return error[ERROR_LOGGER] || defaultErrorLogger;
+}
+export function wrappedError(message, originalError) {
+    const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
+    const error = Error(msg);
+    error[ERROR_ORIGINAL_ERROR] = originalError;
+    return error;
+}
+export function stringify(token) {
+    if (typeof token === 'string') {
+        return token;
+    }
+    if (token == null) {
+        return '' + token;
+    }
+    if (token.name) {
+        return `${token.name}`;
+    }
+    const res = token.toString();
+    const newLineIndex = res.indexOf('\n');
+    return newLineIndex === -1 ? res : res.substring(0, newLineIndex);
+}

package/esm/index.js

@@ -0,0 +1,16 @@
+// application
+export { createApplication } from './application/application';
+export * from './application/tokens';
+export * from './application/types';
+// modules
+export { createModule } from './module/module';
+export * from './module/types';
+export * from './module/metadata';
+export * from './module/tokens';
+// di
+export { Injector, Inject, Injectable, Optional, ExecutionContext, forwardRef, InjectionToken, Scope, } from './di';
+import './shared/types';
+export { gql } from './shared/gql';
+export * from './shared/di';
+// testing
+export * from './testing';

package/esm/module/factory.js

@@ -0,0 +1,68 @@
+import { metadataFactory } from './metadata';
+import { createResolvers } from './resolvers';
+import { createTypeDefs } from './type-defs';
+import { MODULE_ID } from './tokens';
+import { ReflectiveInjector, onlySingletonProviders, onlyOperationProviders, } from '../di';
+import { resolveProviders } from './../di/resolution';
+function lazy(getter) {
+    let called = false;
+    let computedValue;
+    return {
+        get value() {
+            if (!called) {
+                called = true;
+                computedValue = getter();
+            }
+            return computedValue;
+        },
+    };
+}
+export function moduleFactory(config) {
+    const typeDefs = createTypeDefs(config);
+    const metadata = metadataFactory(typeDefs, config);
+    const providers = lazy(() => typeof config.providers === 'function'
+        ? 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 = lazy(() => ReflectiveInjector.resolve(onlyOperationProviders(providers.value)));
+    const singletonProviders = lazy(() => ReflectiveInjector.resolve(onlySingletonProviders(providers.value)));
+    const mod = {
+        id: config.id,
+        config,
+        metadata,
+        typeDefs,
+        // Factory is called once on application creation,
+        // before we even handle GraphQL Operation
+        factory(app) {
+            const resolvedModule = mod;
+            resolvedModule.singletonProviders = singletonProviders.value;
+            resolvedModule.operationProviders = operationProviders.value;
+            // Create a  module-level Singleton injector
+            const injector = ReflectiveInjector.createFromResolved({
+                name: `Module "${config.id}" (Singleton Scope)`,
+                providers: resolvedModule.singletonProviders.concat(resolveProviders([
+                    {
+                        // with module's id, useful in Logging and stuff
+                        provide: MODULE_ID,
+                        useValue: config.id,
+                    },
+                ])),
+                parent: app.injector,
+            });
+            // We attach injector property to existing `mod` object
+            // because we want to keep references
+            // that are later on used in testing utils
+            resolvedModule.injector = injector;
+            // Create resolvers object based on module's config
+            // It involves wrapping a resolver with middlewares
+            // and other things like validation
+            resolvedModule.resolvers = createResolvers(config, metadata, {
+                middlewareMap: app.middlewares,
+            });
+            return resolvedModule;
+        },
+    };
+    return mod;
+}

package/esm/module/metadata.js

@@ -0,0 +1,107 @@
+import { visit, Kind, } from 'graphql';
+export function metadataFactory(typeDefs, config) {
+    const implemented = {};
+    const extended = {};
+    function collectObjectDefinition(node) {
+        if (!implemented[node.name.value]) {
+            implemented[node.name.value] = [];
+        }
+        if (node.fields && node.fields.length > 0) {
+            implemented[node.name.value].push(...node.fields.map((field) => field.name.value));
+        }
+        if (node.kind === Kind.OBJECT_TYPE_DEFINITION) {
+            implemented[node.name.value].push('__isTypeOf');
+        }
+        if (node.kind === Kind.OBJECT_TYPE_DEFINITION) {
+            implemented[node.name.value].push('__resolveReference');
+            implemented[node.name.value].push('__resolveObject');
+        }
+        if (node.kind === Kind.INTERFACE_TYPE_DEFINITION) {
+            implemented[node.name.value].push('__resolveType');
+        }
+    }
+    function collectObjectExtension(node) {
+        if (node.fields) {
+            if (!extended[node.name.value]) {
+                extended[node.name.value] = [];
+            }
+            node.fields.forEach((field) => {
+                extended[node.name.value].push(field.name.value);
+            });
+        }
+    }
+    for (const doc of typeDefs) {
+        visit(doc, {
+            // Object
+            ObjectTypeDefinition(node) {
+                collectObjectDefinition(node);
+            },
+            ObjectTypeExtension(node) {
+                collectObjectExtension(node);
+            },
+            // Interface
+            InterfaceTypeDefinition(node) {
+                collectObjectDefinition(node);
+            },
+            InterfaceTypeExtension(node) {
+                collectObjectExtension(node);
+            },
+            // Union
+            UnionTypeDefinition(node) {
+                if (!implemented[node.name.value]) {
+                    implemented[node.name.value] = [];
+                }
+                if (node.types) {
+                    implemented[node.name.value].push(...node.types.map((type) => type.name.value));
+                }
+                implemented[node.name.value].push('__resolveType');
+            },
+            UnionTypeExtension(node) {
+                if (node.types) {
+                    if (!extended[node.name.value]) {
+                        extended[node.name.value] = [];
+                    }
+                    extended[node.name.value].push(...node.types.map((type) => type.name.value));
+                }
+            },
+            // Input
+            InputObjectTypeDefinition(node) {
+                collectObjectDefinition(node);
+            },
+            InputObjectTypeExtension(node) {
+                collectObjectExtension(node);
+            },
+            // Enum
+            EnumTypeDefinition(node) {
+                if (node.values) {
+                    if (!implemented[node.name.value]) {
+                        implemented[node.name.value] = [];
+                    }
+                    implemented[node.name.value].push(...node.values.map((value) => value.name.value));
+                }
+            },
+            EnumTypeExtension(node) {
+                if (node.values) {
+                    if (!extended[node.name.value]) {
+                        extended[node.name.value] = [];
+                    }
+                    extended[node.name.value].push(...node.values.map((value) => value.name.value));
+                }
+            },
+            // Scalar
+            ScalarTypeDefinition(node) {
+                if (!implemented.__scalars) {
+                    implemented.__scalars = [];
+                }
+                implemented.__scalars.push(node.name.value);
+            },
+        });
+    }
+    return {
+        id: config.id,
+        typeDefs,
+        implements: implemented,
+        extends: extended,
+        dirname: config.dirname,
+    };
+}

package/esm/module/module.js

@@ -0,0 +1,24 @@
+import { moduleFactory } from './factory';
+/**
+ * @api
+ * Creates a Module, an element used by Application. Accepts `ModuleConfig`.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { createModule, gql } from 'graphql-modules';
+ *
+ * export const usersModule = createModule({
+ *   id: 'users',
+ *   typeDefs: gql`
+ *     // GraphQL SDL
+ *   `,
+ *   resolvers: {
+ *     // ...
+ *   }
+ * });
+ * ```
+ */
+export function createModule(config) {
+    return moduleFactory(config);
+}