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

package/cjs/di/errors.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidProviderError = invalidProviderError;
+exports.noInjectableError = noInjectableError;
+exports.noAnnotationError = noAnnotationError;
+exports.cyclicDependencyError = cyclicDependencyError;
+exports.noProviderError = noProviderError;
+exports.instantiationError = instantiationError;
+const utils_1 = require("./utils");
+function invalidProviderError(provider) {
+    return Error(`Invalid provider - only instances of Provider and Type are allowed, got: ${provider}`);
+}
+function noInjectableError(type) {
+    return Error(`Missing @Injectable decorator for '${(0, utils_1.stringify)(type)}'`);
+}
+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((0, utils_1.stringify)(parameter.type));
+        }
+    }
+    return Error("Cannot resolve all parameters for '" +
+        (0, utils_1.stringify)(typeOrFunc) +
+        "'(" +
+        signature.join(', ') +
+        '). ' +
+        "Make sure that all the parameters are decorated with Inject or have valid type annotations and that '" +
+        (0, utils_1.stringify)(typeOrFunc) +
+        "' is decorated with Injectable.");
+}
+function cyclicDependencyError(injector, key) {
+    return injectionError(injector, key, function () {
+        return `Cannot instantiate cyclic dependency!${constructResolvingPath(this.keys)}`;
+    });
+}
+function noProviderError(injector, key) {
+    return injectionError(injector, key, function () {
+        const first = (0, utils_1.stringify)(this.keys[0].token);
+        return `No provider for ${first}!${constructResolvingPath(this.keys)}`;
+    });
+}
+function instantiationError(injector, originalException, key) {
+    return injectionError(injector, key, function () {
+        const first = (0, utils_1.stringify)(this.keys[0].token);
+        return `Error during instantiation of ${first}: ${(0, utils_1.getOriginalError)(this).message}${constructResolvingPath(this.keys)}`;
+    }, originalException);
+}
+function injectionError(injector, key, constructResolvingMessage, originalError) {
+    const error = (originalError ? (0, utils_1.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[utils_1.ERROR_ORIGINAL_ERROR] = originalError;
+    return error;
+}
+function constructResolvingPath(keys) {
+    if (keys.length > 1) {
+        const reversed = findFirstClosedCycle(keys.slice().reverse());
+        const tokenStrs = reversed.map((k) => (0, utils_1.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/cjs/di/forward-ref.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forwardRef = forwardRef;
+exports.resolveForwardRef = resolveForwardRef;
+const utils_1 = require("./utils");
+const forwardRefSymbol = Symbol('__forward_ref__');
+/**
+ * Useful in "circular dependencies of modules" situation
+ */
+function forwardRef(forwardRefFn) {
+    forwardRefFn[forwardRefSymbol] = forwardRef;
+    forwardRefFn.toString = function () {
+        return (0, utils_1.stringify)(this());
+    };
+    return forwardRefFn;
+}
+function resolveForwardRef(type) {
+    if (typeof type === 'function' &&
+        type.hasOwnProperty(forwardRefSymbol) &&
+        type[forwardRefSymbol] === forwardRef) {
+        return type();
+    }
+    else {
+        return type;
+    }
+}

package/cjs/di/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReflectiveInjector = exports.Injector = exports.onlyOperationProviders = exports.onlySingletonProviders = exports.Scope = exports.Type = exports.InjectionToken = exports.forwardRef = exports.ExecutionContext = exports.Inject = exports.Optional = exports.Injectable = void 0;
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "Injectable", { enumerable: true, get: function () { return decorators_1.Injectable; } });
+Object.defineProperty(exports, "Optional", { enumerable: true, get: function () { return decorators_1.Optional; } });
+Object.defineProperty(exports, "Inject", { enumerable: true, get: function () { return decorators_1.Inject; } });
+Object.defineProperty(exports, "ExecutionContext", { enumerable: true, get: function () { return decorators_1.ExecutionContext; } });
+var forward_ref_1 = require("./forward-ref");
+Object.defineProperty(exports, "forwardRef", { enumerable: true, get: function () { return forward_ref_1.forwardRef; } });
+var providers_1 = require("./providers");
+Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return providers_1.InjectionToken; } });
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return providers_1.Type; } });
+Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return providers_1.Scope; } });
+Object.defineProperty(exports, "onlySingletonProviders", { enumerable: true, get: function () { return providers_1.onlySingletonProviders; } });
+Object.defineProperty(exports, "onlyOperationProviders", { enumerable: true, get: function () { return providers_1.onlyOperationProviders; } });
+var injector_1 = require("./injector");
+Object.defineProperty(exports, "Injector", { enumerable: true, get: function () { return injector_1.Injector; } });
+Object.defineProperty(exports, "ReflectiveInjector", { enumerable: true, get: function () { return injector_1.ReflectiveInjector; } });

package/cjs/di/injector.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReflectiveInjector = exports.Injector = void 0;
+const resolution_1 = require("./resolution");
+const registry_1 = require("./registry");
+const errors_1 = require("./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
+class Injector {
+}
+exports.Injector = Injector;
+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 (0, resolution_1.resolveProviders)(providers);
+    }
+    get parent() {
+        return this._parent;
+    }
+    get fallbackParent() {
+        return this._fallbackParent;
+    }
+    get(token, notFoundValue = _THROW_IF_NOT_FOUND) {
+        return this._getByKey(registry_1.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 (0, errors_1.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 (0, errors_1.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 (0, errors_1.cyclicDependencyError)(this, provider.key);
+        }
+        return this._instantiateProvider(provider);
+    }
+    _getMaxNumberOfObjects() {
+        return this._objs.length;
+    }
+    toString() {
+        return this.displayName;
+    }
+}
+exports.ReflectiveInjector = ReflectiveInjector;

package/cjs/di/metadata.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INJECTABLE = void 0;
+exports.readInjectableMetadata = readInjectableMetadata;
+exports.ensureInjectableMetadata = ensureInjectableMetadata;
+const errors_1 = require("./errors");
+exports.INJECTABLE = Symbol('di:injectable');
+function readInjectableMetadata(type, throwOnMissing) {
+    const meta = type[exports.INJECTABLE];
+    if (!meta && throwOnMissing) {
+        throw (0, errors_1.noInjectableError)(type);
+    }
+    return meta;
+}
+function ensureInjectableMetadata(type) {
+    if (!readInjectableMetadata(type)) {
+        const meta = {
+            params: [],
+        };
+        type[exports.INJECTABLE] = meta;
+    }
+}

package/cjs/di/providers.js

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

package/cjs/di/registry.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Key = void 0;
+const utils_1 = require("./utils");
+const forward_ref_1 = require("./forward-ref");
+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 (0, utils_1.stringify)(this.token);
+    }
+    static get(token) {
+        return _globalKeyRegistry.get((0, forward_ref_1.resolveForwardRef)(token));
+    }
+}
+exports.Key = Key;
+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/cjs/di/resolution.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dependency = exports.ResolvedFactory = exports.ResolvedProvider = void 0;
+exports.resolveProviders = resolveProviders;
+const providers_1 = require("./providers");
+const errors_1 = require("./errors");
+const registry_1 = require("./registry");
+const forward_ref_1 = require("./forward-ref");
+const metadata_1 = require("./metadata");
+const _EMPTY_LIST = [];
+class ResolvedProvider {
+    constructor(key, factory) {
+        this.key = key;
+        this.factory = factory;
+    }
+}
+exports.ResolvedProvider = ResolvedProvider;
+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;
+    }
+}
+exports.ResolvedFactory = ResolvedFactory;
+class Dependency {
+    constructor(key, optional) {
+        this.key = key;
+        this.optional = optional;
+    }
+    static fromKey(key) {
+        return new Dependency(key, false);
+    }
+}
+exports.Dependency = Dependency;
+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(registry_1.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 providers_1.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 (0, errors_1.invalidProviderError)(token);
+        }
+    });
+    return res;
+}
+function resolveFactory(provider) {
+    let factoryFn;
+    let resolvedDeps = _EMPTY_LIST;
+    let executionContextIn = _EMPTY_LIST;
+    let hasOnDestroyHook = false;
+    let isGlobal;
+    if ((0, providers_1.isClassProvider)(provider)) {
+        const useClass = (0, forward_ref_1.resolveForwardRef)(provider.useClass);
+        factoryFn = makeFactory(useClass);
+        resolvedDeps = dependenciesFor(useClass);
+        executionContextIn = executionContextInFor(useClass);
+        isGlobal = globalFor(useClass);
+        hasOnDestroyHook = typeof useClass.prototype.onDestroy === 'function';
+    }
+    else if ((0, providers_1.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 } = (0, metadata_1.readInjectableMetadata)(type, true);
+    if (!params) {
+        return [];
+    }
+    if (params.some((p) => p.type == null)) {
+        throw (0, errors_1.noAnnotationError)(type, params);
+    }
+    return params.map((p) => extractToken(p, params));
+}
+function executionContextInFor(type) {
+    const { options } = (0, metadata_1.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 } = (0, metadata_1.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 = (0, forward_ref_1.resolveForwardRef)(param.type);
+    if (token) {
+        return createDependency(token, param.optional);
+    }
+    throw (0, errors_1.noAnnotationError)(param.type, params);
+}
+function createDependency(token, optional) {
+    return new Dependency(registry_1.Key.get(token), optional);
+}
+function makeFactory(t) {
+    return (...args) => new t(...args);
+}

package/cjs/di/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_LOGGER = exports.ERROR_ORIGINAL_ERROR = exports.ERROR_TYPE = void 0;
+exports.getType = getType;
+exports.getOriginalError = getOriginalError;
+exports.getErrorLogger = getErrorLogger;
+exports.wrappedError = wrappedError;
+exports.stringify = stringify;
+exports.ERROR_TYPE = 'diType';
+exports.ERROR_ORIGINAL_ERROR = 'diOriginalError';
+exports.ERROR_LOGGER = 'diErrorLogger';
+function getType(error) {
+    return error[exports.ERROR_TYPE];
+}
+function getOriginalError(error) {
+    return error[exports.ERROR_ORIGINAL_ERROR];
+}
+function defaultErrorLogger(console, ...values) {
+    // eslint-disable-next-line no-console
+    console.error(...values);
+}
+function getErrorLogger(error) {
+    return error[exports.ERROR_LOGGER] || defaultErrorLogger;
+}
+function wrappedError(message, originalError) {
+    const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;
+    const error = Error(msg);
+    error[exports.ERROR_ORIGINAL_ERROR] = originalError;
+    return error;
+}
+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/cjs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gql = exports.Scope = exports.InjectionToken = exports.forwardRef = exports.ExecutionContext = exports.Optional = exports.Injectable = exports.Inject = exports.Injector = exports.createModule = exports.createApplication = void 0;
+const tslib_1 = require("tslib");
+// application
+var application_1 = require("./application/application");
+Object.defineProperty(exports, "createApplication", { enumerable: true, get: function () { return application_1.createApplication; } });
+tslib_1.__exportStar(require("./application/tokens"), exports);
+tslib_1.__exportStar(require("./application/types"), exports);
+// modules
+var module_1 = require("./module/module");
+Object.defineProperty(exports, "createModule", { enumerable: true, get: function () { return module_1.createModule; } });
+tslib_1.__exportStar(require("./module/types"), exports);
+tslib_1.__exportStar(require("./module/metadata"), exports);
+tslib_1.__exportStar(require("./module/tokens"), exports);
+// di
+var di_1 = require("./di");
+Object.defineProperty(exports, "Injector", { enumerable: true, get: function () { return di_1.Injector; } });
+Object.defineProperty(exports, "Inject", { enumerable: true, get: function () { return di_1.Inject; } });
+Object.defineProperty(exports, "Injectable", { enumerable: true, get: function () { return di_1.Injectable; } });
+Object.defineProperty(exports, "Optional", { enumerable: true, get: function () { return di_1.Optional; } });
+Object.defineProperty(exports, "ExecutionContext", { enumerable: true, get: function () { return di_1.ExecutionContext; } });
+Object.defineProperty(exports, "forwardRef", { enumerable: true, get: function () { return di_1.forwardRef; } });
+Object.defineProperty(exports, "InjectionToken", { enumerable: true, get: function () { return di_1.InjectionToken; } });
+Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return di_1.Scope; } });
+require("./shared/types");
+var gql_1 = require("./shared/gql");
+Object.defineProperty(exports, "gql", { enumerable: true, get: function () { return gql_1.gql; } });
+tslib_1.__exportStar(require("./shared/di"), exports);
+// testing
+tslib_1.__exportStar(require("./testing"), exports);