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

package/esm/di/errors.js

@@ -0,0 +1,79 @@
+import { stringify, wrappedError, ERROR_ORIGINAL_ERROR, getOriginalError, } from './utils';
+export function invalidProviderError(provider) {
+    return Error(`Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);
+}
+export function noInjectableError(type) {
+    return Error(`Missing @Injectable decorator for '${stringify(type)}'`);
+}
+export function noAnnotationError(typeOrFunc, params) {
+    const signature = [];
+    for (let i = 0, len = params.length; i < len; i++) {
+        const parameter = params[i];
+        if (!parameter.type) {
+            signature.push('?');
+        }
+        else {
+            signature.push(stringify(parameter.type));
+        }
+    }
+    return Error("Cannot resolve all parameters for '" +
+        stringify(typeOrFunc) +
+        "'(" +
+        signature.join(', ') +
+        '). ' +
+        "Make sure that all the parameters are decorated with Inject or have valid type annotations and that '" +
+        stringify(typeOrFunc) +
+        "' is decorated with Injectable.");
+}
+export function cyclicDependencyError(injector, key) {
+    return injectionError(injector, key, function () {
+        return `Cannot instantiate cyclic dependency!${constructResolvingPath(this.keys)}`;
+    });
+}
+export function noProviderError(injector, key) {
+    return injectionError(injector, key, function () {
+        const first = stringify(this.keys[0].token);
+        return `No provider for ${first}!${constructResolvingPath(this.keys)}`;
+    });
+}
+export function instantiationError(injector, originalException, key) {
+    return injectionError(injector, key, function () {
+        const first = stringify(this.keys[0].token);
+        return `Error during instantiation of ${first}: ${getOriginalError(this).message}${constructResolvingPath(this.keys)}`;
+    }, originalException);
+}
+function injectionError(injector, key, constructResolvingMessage, originalError) {
+    const error = (originalError ? wrappedError('', originalError) : Error());
+    error.addKey = addKey;
+    error.keys = [key];
+    error.constructResolvingMessage =
+        function wrappedConstructResolvingMessage() {
+            return (constructResolvingMessage.call(this) + ` - in ${injector.displayName}`);
+        };
+    error.message = error.constructResolvingMessage();
+    error[ERROR_ORIGINAL_ERROR] = originalError;
+    return error;
+}
+function constructResolvingPath(keys) {
+    if (keys.length > 1) {
+        const reversed = findFirstClosedCycle(keys.slice().reverse());
+        const tokenStrs = reversed.map((k) => stringify(k.token));
+        return ' (' + tokenStrs.join(' -> ') + ')';
+    }
+    return '';
+}
+function findFirstClosedCycle(keys) {
+    const res = [];
+    for (let i = 0; i < keys.length; ++i) {
+        if (res.indexOf(keys[i]) > -1) {
+            res.push(keys[i]);
+            return res;
+        }
+        res.push(keys[i]);
+    }
+    return res;
+}
+function addKey(key) {
+    this.keys.push(key);
+    this.message = this.constructResolvingMessage();
+}

package/esm/di/forward-ref.js

@@ -0,0 +1,22 @@
+import { stringify } from './utils';
+const forwardRefSymbol = Symbol('__forward_ref__');
+/**
+ * Useful in "circular dependencies of modules" situation
+ */
+export function forwardRef(forwardRefFn) {
+    forwardRefFn[forwardRefSymbol] = forwardRef;
+    forwardRefFn.toString = function () {
+        return stringify(this());
+    };
+    return forwardRefFn;
+}
+export function resolveForwardRef(type) {
+    if (typeof type === 'function' &&
+        type.hasOwnProperty(forwardRefSymbol) &&
+        type[forwardRefSymbol] === forwardRef) {
+        return type();
+    }
+    else {
+        return type;
+    }
+}

package/esm/di/index.js

@@ -0,0 +1,4 @@
+export { Injectable, Optional, Inject, ExecutionContext } from './decorators';
+export { forwardRef } from './forward-ref';
+export { InjectionToken, Type, Scope, onlySingletonProviders, onlyOperationProviders, } from './providers';
+export { Injector, ReflectiveInjector } from './injector';

package/esm/di/injector.js

@@ -0,0 +1,168 @@
+import { resolveProviders, } from './resolution';
+import { Key } from './registry';
+import { noProviderError, cyclicDependencyError, instantiationError, } from './errors';
+const _THROW_IF_NOT_FOUND = new Object();
+const UNDEFINED = new Object();
+const NOT_FOUND = new Object();
+function notInExecutionContext() {
+    throw new Error('Not in execution context');
+}
+// Publicly available Injector.
+// We use ReflectiveInjector everywhere
+// but we don't want to leak its API to everyone
+export class Injector {
+}
+export class ReflectiveInjector {
+    constructor({ name, providers, parent, fallbackParent, globalProvidersMap = new Map(), }) {
+        this._constructionCounter = 0;
+        this._executionContextGetter = notInExecutionContext;
+        this.displayName = name;
+        this._parent = parent || null;
+        this._fallbackParent = fallbackParent || null;
+        this._providers = providers;
+        this._globalProvidersMap = globalProvidersMap;
+        const len = this._providers.length;
+        this._keyIds = new Array(len);
+        this._objs = new Array(len);
+        for (let i = 0; i < len; i++) {
+            this._keyIds[i] = this._providers[i].key.id;
+            this._objs[i] = UNDEFINED;
+        }
+    }
+    static createFromResolved({ name, providers, parent, fallbackParent, globalProvidersMap, }) {
+        return new ReflectiveInjector({
+            name,
+            providers,
+            parent,
+            fallbackParent,
+            globalProvidersMap,
+        });
+    }
+    static resolve(providers) {
+        return resolveProviders(providers);
+    }
+    get parent() {
+        return this._parent;
+    }
+    get fallbackParent() {
+        return this._fallbackParent;
+    }
+    get(token, notFoundValue = _THROW_IF_NOT_FOUND) {
+        return this._getByKey(Key.get(token), notFoundValue);
+    }
+    setExecutionContextGetter(getter) {
+        this._executionContextGetter = getter;
+    }
+    _getByKey(key, notFoundValue) {
+        let inj = this;
+        function getObj() {
+            while (inj instanceof ReflectiveInjector) {
+                const inj_ = inj;
+                const obj = inj_._getObjByKeyId(key.id);
+                if (obj !== UNDEFINED) {
+                    return obj;
+                }
+                inj = inj_._parent;
+            }
+            return NOT_FOUND;
+        }
+        const resolvedValue = getObj();
+        if (resolvedValue !== NOT_FOUND) {
+            return resolvedValue;
+        }
+        // search in fallback Injector
+        if (this._fallbackParent) {
+            inj = this._fallbackParent;
+            const resolvedFallbackValue = getObj();
+            if (resolvedFallbackValue !== NOT_FOUND) {
+                return resolvedFallbackValue;
+            }
+        }
+        if (inj !== null) {
+            return inj.get(key.token, notFoundValue);
+        }
+        return this._throwOrNull(key, notFoundValue);
+    }
+    _isObjectDefinedByKeyId(keyId) {
+        for (let i = 0; i < this._keyIds.length; i++) {
+            if (this._keyIds[i] === keyId) {
+                return this._objs[i] !== UNDEFINED;
+            }
+        }
+        return false;
+    }
+    _getObjByKeyId(keyId) {
+        var _a, _b;
+        if ((_a = this._globalProvidersMap) === null || _a === void 0 ? void 0 : _a.has(keyId)) {
+            return (_b = this._globalProvidersMap.get(keyId)) === null || _b === void 0 ? void 0 : _b._getObjByKeyId(keyId);
+        }
+        for (let i = 0; i < this._keyIds.length; i++) {
+            if (this._keyIds[i] === keyId) {
+                if (this._objs[i] === UNDEFINED) {
+                    this._objs[i] = this._new(this._providers[i]);
+                }
+                return this._objs[i];
+            }
+        }
+        return UNDEFINED;
+    }
+    _throwOrNull(key, notFoundValue) {
+        if (notFoundValue !== _THROW_IF_NOT_FOUND) {
+            return notFoundValue;
+        }
+        else {
+            throw noProviderError(this, key);
+        }
+    }
+    instantiateAll() {
+        this._providers.forEach((provider) => {
+            this._getByKey(provider.key, _THROW_IF_NOT_FOUND);
+        });
+    }
+    _instantiateProvider(provider) {
+        const factory = provider.factory.factory;
+        let deps;
+        try {
+            deps = provider.factory.dependencies.map((dep) => this._getByDependency(dep));
+        }
+        catch (e) {
+            if (e.addKey) {
+                e.addKey(provider.key);
+            }
+            throw e;
+        }
+        let obj;
+        try {
+            obj = factory(...deps);
+            // attach execution context getter
+            if (provider.factory.executionContextIn.length > 0) {
+                for (const prop of provider.factory.executionContextIn) {
+                    Object.defineProperty(obj, prop, {
+                        get: () => {
+                            return this._executionContextGetter();
+                        },
+                    });
+                }
+            }
+        }
+        catch (e) {
+            throw instantiationError(this, e, provider.key);
+        }
+        return obj;
+    }
+    _getByDependency(dep) {
+        return this._getByKey(dep.key, dep.optional ? null : _THROW_IF_NOT_FOUND);
+    }
+    _new(provider) {
+        if (this._constructionCounter++ > this._getMaxNumberOfObjects()) {
+            throw cyclicDependencyError(this, provider.key);
+        }
+        return this._instantiateProvider(provider);
+    }
+    _getMaxNumberOfObjects() {
+        return this._objs.length;
+    }
+    toString() {
+        return this.displayName;
+    }
+}

package/esm/di/metadata.js

@@ -0,0 +1,17 @@
+import { noInjectableError } from './errors';
+export const INJECTABLE = Symbol('di:injectable');
+export function readInjectableMetadata(type, throwOnMissing) {
+    const meta = type[INJECTABLE];
+    if (!meta && throwOnMissing) {
+        throw noInjectableError(type);
+    }
+    return meta;
+}
+export function ensureInjectableMetadata(type) {
+    if (!readInjectableMetadata(type)) {
+        const meta = {
+            params: [],
+        };
+        type[INJECTABLE] = meta;
+    }
+}

package/esm/di/providers.js

@@ -0,0 +1,50 @@
+import { readInjectableMetadata } from './metadata';
+export const Type = Function;
+/// @ts-ignore
+export class InjectionToken {
+    constructor(_desc) {
+        this._desc = _desc;
+    }
+    toString() {
+        return `InjectionToken ${this._desc}`;
+    }
+}
+export function isToken(v) {
+    return v && v instanceof InjectionToken;
+}
+export function isType(v) {
+    return typeof v === 'function' && v !== Object;
+}
+export var Scope;
+(function (Scope) {
+    Scope[Scope["Singleton"] = 0] = "Singleton";
+    Scope[Scope["Operation"] = 1] = "Operation";
+})(Scope || (Scope = {}));
+export function onlySingletonProviders(providers = []) {
+    return providers.filter((provider) => {
+        if (isType(provider)) {
+            const { options } = readInjectableMetadata(provider, true);
+            return (options === null || options === void 0 ? void 0 : options.scope) !== Scope.Operation;
+        }
+        else {
+            return provider.scope !== Scope.Operation;
+        }
+    });
+}
+export function onlyOperationProviders(providers = []) {
+    return providers.filter((provider) => {
+        if (isType(provider)) {
+            const { options } = readInjectableMetadata(provider, true);
+            return (options === null || options === void 0 ? void 0 : options.scope) === Scope.Operation;
+        }
+        else {
+            return provider.scope === Scope.Operation;
+        }
+    });
+}
+export function isClassProvider(provider) {
+    return typeof provider.useClass !== 'undefined';
+}
+export function isFactoryProvider(provider) {
+    return typeof provider.useFactory !== 'undefined';
+}

package/esm/di/registry.js

@@ -0,0 +1,40 @@
+import { stringify } from './utils';
+import { resolveForwardRef } from './forward-ref';
+export class Key {
+    constructor(token, id) {
+        this.token = token;
+        this.id = id;
+        if (!token) {
+            throw new Error('Token must be defined!');
+        }
+    }
+    /**
+     * Returns a stringified token.
+     */
+    get displayName() {
+        return stringify(this.token);
+    }
+    static get(token) {
+        return _globalKeyRegistry.get(resolveForwardRef(token));
+    }
+}
+class GlobalKeyRegistry {
+    constructor() {
+        this._allKeys = new Map();
+    }
+    get(token) {
+        if (token instanceof Key) {
+            return token;
+        }
+        if (this._allKeys.has(token)) {
+            return this._allKeys.get(token);
+        }
+        const newKey = new Key(token, _globalKeyRegistry.numberOfKeys);
+        this._allKeys.set(token, newKey);
+        return newKey;
+    }
+    get numberOfKeys() {
+        return this._allKeys.size;
+    }
+}
+const _globalKeyRegistry = new GlobalKeyRegistry();

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;
+}