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

package/esm/application/execution.js

@@ -0,0 +1,39 @@
+import { execute, } from 'graphql';
+import { isNotSchema } from '../shared/utils';
+export function executionCreator({ contextBuilder, }) {
+    const createExecution = (options) => {
+        // Custom or original execute function
+        const executeFn = (options === null || options === void 0 ? void 0 : options.execute) || execute;
+        return (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) => {
+            function perform({ context, ɵdestroy: destroy, }) {
+                const executionArgs = isNotSchema(argsOrSchema)
+                    ? {
+                        ...argsOrSchema,
+                        contextValue: context,
+                    }
+                    : {
+                        schema: argsOrSchema,
+                        document: document,
+                        rootValue,
+                        contextValue: context,
+                        variableValues,
+                        operationName,
+                        fieldResolver,
+                        typeResolver,
+                    };
+                // It's important to wrap the executeFn within a promise
+                // so we can easily control the end of execution (with finally)
+                return Promise.resolve()
+                    .then(() => executeFn(executionArgs))
+                    .finally(destroy);
+            }
+            if (options === null || options === void 0 ? void 0 : options.controller) {
+                return perform(options.controller);
+            }
+            return contextBuilder(isNotSchema(argsOrSchema)
+                ? argsOrSchema.contextValue
+                : contextValue).runWithContext(perform);
+        };
+    };
+    return createExecution;
+}

package/esm/application/operation-controller.js

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

package/esm/application/subscription.js

@@ -0,0 +1,51 @@
+import { subscribe, } from 'graphql';
+import { tapAsyncIterator, isAsyncIterable, isNotSchema, } from '../shared/utils';
+export function subscriptionCreator({ contextBuilder, }) {
+    const createSubscription = (options) => {
+        // Custom or original subscribe function
+        const subscribeFn = (options === null || options === void 0 ? void 0 : options.subscribe) || subscribe;
+        return (argsOrSchema, document, rootValue, contextValue, variableValues, operationName, fieldResolver, subscribeFieldResolver) => {
+            function perform({ context, ɵdestroy: destroy, }) {
+                const subscriptionArgs = isNotSchema(argsOrSchema)
+                    ? {
+                        ...argsOrSchema,
+                        contextValue: context,
+                    }
+                    : {
+                        schema: argsOrSchema,
+                        document: document,
+                        rootValue,
+                        contextValue: context,
+                        variableValues,
+                        operationName,
+                        fieldResolver,
+                        subscribeFieldResolver,
+                    };
+                let isIterable = false;
+                // It's important to wrap the subscribeFn within a promise
+                // so we can easily control the end of subscription (with finally)
+                return Promise.resolve()
+                    .then(() => subscribeFn(subscriptionArgs))
+                    .then((sub) => {
+                    if (isAsyncIterable(sub)) {
+                        isIterable = true;
+                        return tapAsyncIterator(sub, destroy);
+                    }
+                    return sub;
+                })
+                    .finally(() => {
+                    if (!isIterable) {
+                        destroy();
+                    }
+                });
+            }
+            if (options === null || options === void 0 ? void 0 : options.controller) {
+                return perform(options.controller);
+            }
+            return contextBuilder(isNotSchema(argsOrSchema)
+                ? argsOrSchema.contextValue
+                : contextValue).runWithContext(perform);
+        };
+    };
+    return createSubscription;
+}

package/esm/application/tokens.js

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

package/esm/async-context.browser.mjs

@@ -0,0 +1,7 @@
+// noop
+// TODO: typecheck
+
+export default {
+  getAsyncContext: () => undefined,
+  runWithAsyncContext: (_asyncContext, callback, ...args) => callback(...args),
+};

package/esm/async-context.node.cjs

@@ -0,0 +1,14 @@
+// use async hooks
+// TODO: typecheck
+
+const hooks = require('async_hooks');
+
+const alc = new hooks.AsyncLocalStorage();
+
+// we dont use named exports (exports.getAsyncContext) because node with typescript is weird
+
+module.exports = {
+  getAsyncContext: () => alc.getStore(),
+  runWithAsyncContext: (asyncContext, callback, ...args) =>
+    alc.run(asyncContext, callback, ...args),
+};

package/esm/di/decorators.js

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

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();