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

package/esm/module/resolvers.js

@@ -0,0 +1,337 @@
+import { GraphQLScalarType, concatAST, Kind, defaultFieldResolver, } from 'graphql';
+import { useLocation, ExtraResolverError, ResolverDuplicatedError, ResolverInvalidError, } from './../shared/errors';
+import { isNil, isDefined, isPrimitive } from '../shared/utils';
+import { createMiddleware, mergeMiddlewareMaps, validateMiddlewareMap, } from '../shared/middleware';
+const resolverMetadataProp = Symbol('metadata');
+export function createResolvers(config, metadata, app) {
+    const ensure = ensureImplements(metadata);
+    const normalizedModuleMiddlewareMap = config.middlewares || {};
+    const middlewareMap = mergeMiddlewareMaps(app.middlewareMap, normalizedModuleMiddlewareMap);
+    validateMiddlewareMap(normalizedModuleMiddlewareMap, metadata);
+    const resolvers = addDefaultResolvers(mergeResolvers(config), middlewareMap, config);
+    // Wrap resolvers
+    for (const typeName in resolvers) {
+        if (resolvers.hasOwnProperty(typeName)) {
+            const obj = resolvers[typeName];
+            if (isScalarResolver(obj)) {
+                continue;
+            }
+            else if (isEnumResolver(obj)) {
+                continue;
+            }
+            else if (obj && typeof obj === 'object') {
+                for (const fieldName in obj) {
+                    if (obj.hasOwnProperty(fieldName)) {
+                        ensure.type(typeName, fieldName);
+                        const path = [typeName, fieldName];
+                        // function
+                        if (isResolveFn(obj[fieldName])) {
+                            const resolver = wrapResolver({
+                                config,
+                                resolver: obj[fieldName],
+                                middlewareMap,
+                                path,
+                                isTypeResolver: fieldName === '__isTypeOf' || fieldName === '__resolveType',
+                                isReferenceResolver: fieldName === '__resolveReference',
+                                isObjectResolver: fieldName === '__resolveObject',
+                            });
+                            resolvers[typeName][fieldName] = resolver;
+                        }
+                        else if (isResolveOptions(obj[fieldName])) {
+                            // { resolve }
+                            if (isDefined(obj[fieldName].resolve)) {
+                                const resolver = wrapResolver({
+                                    config,
+                                    resolver: obj[fieldName].resolve,
+                                    middlewareMap,
+                                    path,
+                                });
+                                resolvers[typeName][fieldName].resolve = resolver;
+                            }
+                            // { subscribe }
+                            if (isDefined(obj[fieldName].subscribe)) {
+                                const resolver = wrapResolver({
+                                    config,
+                                    resolver: obj[fieldName].subscribe,
+                                    middlewareMap,
+                                    path,
+                                });
+                                resolvers[typeName][fieldName].subscribe = resolver;
+                            }
+                            if (isDefined(obj[fieldName].extensions)) {
+                                // Do NOT add a resolve if one is not specified, it will cause
+                                // change in behavior in systems like `grafast`
+                                resolvers[typeName][fieldName].extensions =
+                                    obj[fieldName].extensions;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return resolvers;
+}
+/**
+ * Wrap a resolver so we use module's context instead of app context.
+ * Use a middleware if available.
+ * Attach metadata to a resolver (we will see if it's helpful, probably in error handling)
+ */
+function wrapResolver({ resolver, config, path, middlewareMap, isTypeResolver, isReferenceResolver, isObjectResolver, }) {
+    if (isTypeResolver || isReferenceResolver) {
+        const wrappedResolver = (root, context, info) => {
+            const ctx = {
+                root,
+                context: isReferenceResolver
+                    ? context.ɵgetModuleContext(config.id, context)
+                    : // We mark the context object as possibly undefined,
+                        // because graphql-jit for some reason doesn't pass it for isTypeOf or resolveType methods
+                        context === null || context === void 0 ? void 0 : context.ɵgetModuleContext(config.id, context),
+                info,
+            };
+            return resolver(ctx.root, ctx.context, ctx.info);
+        };
+        writeResolverMetadata(wrappedResolver, config);
+        return wrappedResolver;
+    }
+    if (isObjectResolver) {
+        const wrappedResolver = (root, fields, context, info) => {
+            const moduleContext = context.ɵgetModuleContext(config.id, context);
+            return resolver(root, fields, moduleContext, info);
+        };
+        writeResolverMetadata(wrappedResolver, config);
+        return wrappedResolver;
+    }
+    const middleware = createMiddleware(path, middlewareMap);
+    const wrappedResolver = (root, args, context, info) => {
+        const ctx = {
+            root,
+            args,
+            context: context.ɵgetModuleContext(config.id, context),
+            info,
+        };
+        return middleware(ctx, () => resolver(ctx.root, ctx.args, ctx.context, ctx.info));
+    };
+    writeResolverMetadata(wrappedResolver, config);
+    return wrappedResolver;
+}
+/**
+ * We iterate over every defined resolver and check if it's valid and not duplicated
+ */
+function mergeResolvers(config) {
+    if (!config.resolvers) {
+        return {};
+    }
+    const resolvers = Array.isArray(config.resolvers)
+        ? config.resolvers
+        : [config.resolvers];
+    const container = {};
+    for (const currentResolvers of resolvers) {
+        for (const typeName in currentResolvers) {
+            if (currentResolvers.hasOwnProperty(typeName)) {
+                const value = currentResolvers[typeName];
+                if (isNil(value)) {
+                    continue;
+                }
+                else if (isScalarResolver(value)) {
+                    addScalar({ typeName, resolver: value, container, config });
+                }
+                else if (isEnumResolver(value)) {
+                    addEnum({ typeName, resolver: value, container, config });
+                }
+                else if (value && typeof value === 'object') {
+                    addObject({ typeName, fields: value, container, config });
+                }
+                else {
+                    throw new ResolverInvalidError(`Resolver of "${typeName}" is invalid`, useLocation({ dirname: config.dirname, id: config.id }));
+                }
+            }
+        }
+    }
+    return container;
+}
+function addObject({ typeName, fields, container, config, }) {
+    if (!container[typeName]) {
+        container[typeName] = {};
+    }
+    for (const fieldName in fields) {
+        if (fields.hasOwnProperty(fieldName)) {
+            const resolver = fields[fieldName];
+            if (isResolveFn(resolver)) {
+                if (container[typeName][fieldName]) {
+                    throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}"`, useLocation({ dirname: config.dirname, id: config.id }));
+                }
+                writeResolverMetadata(resolver, config);
+                container[typeName][fieldName] = resolver;
+            }
+            else if (isResolveOptions(resolver)) {
+                if (!container[typeName][fieldName]) {
+                    container[typeName][fieldName] = {};
+                }
+                // resolve
+                if (isDefined(resolver.resolve)) {
+                    if (container[typeName][fieldName].resolve) {
+                        throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}" (resolve method)`, useLocation({ dirname: config.dirname, id: config.id }));
+                    }
+                    writeResolverMetadata(resolver.resolve, config);
+                    container[typeName][fieldName].resolve = resolver.resolve;
+                }
+                // subscribe
+                if (isDefined(resolver.subscribe)) {
+                    if (container[typeName][fieldName].subscribe) {
+                        throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}" (subscribe method)`, useLocation({ dirname: config.dirname, id: config.id }));
+                    }
+                    writeResolverMetadata(resolver.subscribe, config);
+                    container[typeName][fieldName].subscribe = resolver.subscribe;
+                }
+                // extensions
+                if (isDefined(resolver.extensions)) {
+                    if (container[typeName][fieldName].extensions) {
+                        throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${fieldName}" (extensions object)`, useLocation({ dirname: config.dirname, id: config.id }));
+                    }
+                    writeResolverMetadata(resolver.extensions, config);
+                    container[typeName][fieldName].extensions = resolver.extensions;
+                }
+            }
+        }
+    }
+}
+function addScalar({ typeName, resolver, container, config, }) {
+    if (container[typeName]) {
+        throw new ResolverDuplicatedError(`Duplicated resolver of scalar "${typeName}"`, useLocation({ dirname: config.dirname, id: config.id }));
+    }
+    writeResolverMetadata(resolver.parseLiteral, config);
+    writeResolverMetadata(resolver.parseValue, config);
+    writeResolverMetadata(resolver.serialize, config);
+    container[typeName] = resolver;
+}
+function addEnum({ typeName, resolver, container, config, }) {
+    if (!container[typeName]) {
+        container[typeName] = {};
+    }
+    for (const key in resolver) {
+        if (resolver.hasOwnProperty(key)) {
+            const value = resolver[key];
+            if (container[typeName][key]) {
+                throw new ResolverDuplicatedError(`Duplicated resolver of "${typeName}.${key}" enum value`, useLocation({ dirname: config.dirname, id: config.id }));
+            }
+            container[typeName][key] = value;
+        }
+    }
+}
+/**
+ * Helps to make sure a resolver has a corresponding type/field definition.
+ * We don't want to pass resolve function that are not related to the module.
+ */
+function ensureImplements(metadata) {
+    return {
+        type(name, field) {
+            var _a, _b;
+            const type = []
+                .concat((_a = metadata.implements) === null || _a === void 0 ? void 0 : _a[name], (_b = metadata.extends) === null || _b === void 0 ? void 0 : _b[name])
+                .filter(isDefined);
+            if (type === null || type === void 0 ? void 0 : type.includes(field)) {
+                return true;
+            }
+            const id = `"${name}.${field}"`;
+            throw new ExtraResolverError(`Resolver of "${id}" type cannot be implemented`, `${id} is not defined`, useLocation({ dirname: metadata.dirname, id: metadata.id }));
+        },
+        scalar(name) {
+            var _a;
+            if ((((_a = metadata.implements) === null || _a === void 0 ? void 0 : _a.__scalars) || []).includes(name)) {
+                return true;
+            }
+            throw new ExtraResolverError(`Resolver of "${name}" scalar cannot be implemented`, `${name} is not defined`, useLocation({ dirname: metadata.dirname, id: metadata.id }));
+        },
+    };
+}
+function writeResolverMetadata(resolver, config) {
+    if (!resolver) {
+        return;
+    }
+    resolver[resolverMetadataProp] = {
+        moduleId: config.id,
+    };
+}
+export function readResolverMetadata(resolver) {
+    return resolver[resolverMetadataProp];
+}
+/**
+ * In order to use middlewares on fields
+ * that are defined in SDL but have no implemented resolvers,
+ * we would have to recreate GraphQLSchema and wrap resolve functions.
+ *
+ * Since we can't access GraphQLSchema on a module level
+ * and recreating GraphQLSchema seems unreasonable,
+ * we can create default resolvers instead.
+ *
+ * @example
+ *
+ * gql`
+ *  type Query {
+ *    me: User!
+ *  }
+ *
+ *  type User {
+ *    name: String!
+ *  }
+ * `
+ *
+ * The resolver of `Query.me` is implemented and resolver of `User.name` is not.
+ * In case where a middleware wants to intercept the resolver of `User.name`,
+ * we use a default field resolver from `graphql` package
+ * and put it next to other defined resolvers.
+ *
+ * This way our current logic of wrapping resolvers and running
+ * middleware functions stays untouched.
+ */
+function addDefaultResolvers(resolvers, middlewareMap, config) {
+    const container = resolvers;
+    const sdl = Array.isArray(config.typeDefs)
+        ? concatAST(config.typeDefs)
+        : config.typeDefs;
+    function hasMiddleware(typeName, fieldName) {
+        var _a, _b, _c, _d, _e, _f;
+        return ((((_b = (_a = middlewareMap['*']) === null || _a === void 0 ? void 0 : _a['*']) === null || _b === void 0 ? void 0 : _b.length) ||
+            ((_d = (_c = middlewareMap[typeName]) === null || _c === void 0 ? void 0 : _c['*']) === null || _d === void 0 ? void 0 : _d.length) ||
+            ((_f = (_e = middlewareMap[typeName]) === null || _e === void 0 ? void 0 : _e[fieldName]) === null || _f === void 0 ? void 0 : _f.length)) > 0);
+    }
+    sdl.definitions.forEach((definition) => {
+        if (definition.kind === Kind.OBJECT_TYPE_DEFINITION ||
+            definition.kind === Kind.OBJECT_TYPE_EXTENSION) {
+            // Right now we only support Object type
+            if (definition.fields) {
+                const typeName = definition.name.value;
+                definition.fields.forEach((field) => {
+                    var _a;
+                    const fieldName = field.name.value;
+                    if (!((_a = container[typeName]) === null || _a === void 0 ? void 0 : _a[fieldName]) &&
+                        hasMiddleware(typeName, fieldName)) {
+                        if (!container[typeName]) {
+                            container[typeName] = {};
+                        }
+                        container[typeName][fieldName] = defaultFieldResolver;
+                    }
+                });
+            }
+        }
+    });
+    return container;
+}
+//
+// Resolver helpers
+//
+function isResolveFn(value) {
+    return typeof value === 'function';
+}
+function isResolveOptions(value) {
+    return (isDefined(value.resolve) ||
+        isDefined(value.subscribe) ||
+        isDefined(value.extensions));
+}
+function isScalarResolver(obj) {
+    return obj instanceof GraphQLScalarType;
+}
+function isEnumResolver(obj) {
+    return Object.values(obj).every(isPrimitive);
+}

package/esm/module/tokens.js

@@ -0,0 +1,18 @@
+import { InjectionToken } from '../di';
+/**
+ * @api
+ * `MODULE_ID` is an InjectionToken representing module's ID
+ *
+ * @example
+ * ```typescript
+ * import { MODULE_ID, Inject, Injectable } from 'graphql-modules';
+ *
+ * (A)Injectable()
+ * export class Data {
+ *   constructor((A)Inject(MODULE_ID) moduleId: string) {
+ *     console.log(`Data used in ${moduleId} module`)
+ *   }
+ * }
+ * ```
+ */
+export const MODULE_ID = new InjectionToken('module-id');

package/esm/module/type-defs.js

@@ -0,0 +1,21 @@
+import { Kind } from 'graphql';
+import { NonDocumentNodeError, useLocation } from '../shared/errors';
+/**
+ * Create a list of DocumentNode objects based on Module's config.
+ * Add a location, so we get richer errors.
+ */
+export function createTypeDefs(config) {
+    const typeDefs = Array.isArray(config.typeDefs)
+        ? config.typeDefs
+        : [config.typeDefs];
+    ensureDocumentNode(config, typeDefs);
+    return typeDefs;
+}
+function ensureDocumentNode(config, typeDefs) {
+    function ensureEach(doc, i) {
+        if ((doc === null || doc === void 0 ? void 0 : doc.kind) !== Kind.DOCUMENT) {
+            throw new NonDocumentNodeError(`Expected parsed document but received ${typeof doc} at index ${i} in typeDefs list`, useLocation(config));
+        }
+    }
+    typeDefs.forEach(ensureEach);
+}

package/esm/shared/errors.js

@@ -0,0 +1,69 @@
+export class ModuleNonUniqueIdError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ModuleDuplicatedError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ExtraResolverError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ExtraMiddlewareError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ResolverDuplicatedError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class ResolverInvalidError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+export class NonDocumentNodeError extends ExtendableBuiltin(Error) {
+    constructor(message, ...rest) {
+        super(composeMessage(message, ...rest));
+        this.name = this.constructor.name;
+        this.message = composeMessage(message, ...rest);
+    }
+}
+// helpers
+export function useLocation({ dirname, id }) {
+    return dirname
+        ? `Module "${id}" located at ${dirname}`
+        : [
+            `Module "${id}"`,
+            `Hint: pass __dirname to "dirname" option of your modules to get more insightful errors`,
+        ].join('\n');
+}
+export function ExtendableBuiltin(cls) {
+    function ExtendableBuiltin() {
+        cls.apply(this, arguments);
+    }
+    ExtendableBuiltin.prototype = Object.create(cls.prototype);
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+    return ExtendableBuiltin;
+}
+export function composeMessage(...lines) {
+    return lines.join('\n');
+}

package/esm/shared/gql.js

@@ -0,0 +1,9 @@
+import { parse, Kind } from 'graphql';
+export function gql(literals) {
+    const result = typeof literals === 'string' ? literals : literals[0];
+    const parsed = parse(result);
+    if (!parsed || parsed.kind !== Kind.DOCUMENT) {
+        throw new Error('Not a valid GraphQL document.');
+    }
+    return parsed;
+}

package/esm/shared/middleware.js

@@ -0,0 +1,103 @@
+import { mergeDeepWith } from 'ramda';
+import { isDefined } from './utils';
+import { ExtraMiddlewareError, useLocation } from './errors';
+export function compose(middleware) {
+    if (!Array.isArray(middleware)) {
+        throw new TypeError('Middleware stack must be an array!');
+    }
+    for (const fn of middleware) {
+        if (typeof fn !== 'function') {
+            throw new TypeError('Middleware must be composed of functions!');
+        }
+    }
+    return function composed(context, next) {
+        // last called middleware
+        let index = -1;
+        function dispatch(i) {
+            if (i <= index) {
+                return Promise.reject(new Error('next() called multiple times'));
+            }
+            index = i;
+            const fn = i === middleware.length ? next : middleware[i];
+            if (!fn) {
+                return Promise.resolve();
+            }
+            try {
+                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
+            }
+            catch (err) {
+                return Promise.reject(err);
+            }
+        }
+        return dispatch(0);
+    };
+}
+export function createMiddleware(path, middlewareMap) {
+    const middlewares = middlewareMap ? pickMiddlewares(path, middlewareMap) : [];
+    return compose(middlewares);
+}
+export function mergeMiddlewareMaps(app, mod) {
+    const merge = (left, right) => {
+        return mergeDeepWith((l, r) => {
+            if (Array.isArray(l)) {
+                return l.concat(r || []);
+            }
+            return merge(l, r);
+        }, left, right);
+    };
+    return merge(app, mod);
+}
+function pickMiddlewares(path, middlewareMap) {
+    var _a;
+    const middlewares = [];
+    const [type, field] = path;
+    if ((_a = middlewareMap['*']) === null || _a === void 0 ? void 0 : _a['*']) {
+        middlewares.push(...middlewareMap['*']['*']);
+    }
+    const typeMap = middlewareMap[type];
+    if (typeMap) {
+        if (typeMap['*']) {
+            middlewares.push(...typeMap['*']);
+        }
+        if (field && typeMap[field]) {
+            middlewares.push(...typeMap[field]);
+        }
+    }
+    return middlewares.filter(isDefined);
+}
+export function validateMiddlewareMap(middlewareMap, metadata) {
+    const exists = checkExistence(metadata);
+    for (const typeName in middlewareMap.types) {
+        if (middlewareMap.types.hasOwnProperty(typeName)) {
+            const typeMiddlewareMap = middlewareMap[typeName];
+            if (!exists.type(typeName)) {
+                throw new ExtraMiddlewareError(`Cannot apply a middleware to non existing "${typeName}" type`, useLocation({ dirname: metadata.dirname, id: metadata.id }));
+            }
+            for (const fieldName in typeMiddlewareMap[typeName]) {
+                if (typeMiddlewareMap[typeName].hasOwnProperty(fieldName)) {
+                    if (!exists.field(typeName, fieldName)) {
+                        throw new ExtraMiddlewareError(`Cannot apply a middleware to non existing "${typeName}.${fieldName}" type.field`, useLocation({ dirname: metadata.dirname, id: metadata.id }));
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * Helps to make sure a middleware has a corresponding type/field definition.
+ * We don't want to pass a module-level middlewares that are not related to the module.
+ * Not because it's dangerous but to prevent unused middlewares.
+ */
+function checkExistence(metadata) {
+    return {
+        type(name) {
+            var _a, _b;
+            return isDefined(((_a = metadata.implements) === null || _a === void 0 ? void 0 : _a[name]) || ((_b = metadata.extends) === null || _b === void 0 ? void 0 : _b[name]));
+        },
+        field(type, name) {
+            var _a, _b, _c, _d;
+            return isDefined(((_b = (_a = metadata.implements) === null || _a === void 0 ? void 0 : _a[type]) === null || _b === void 0 ? void 0 : _b.includes(name)) ||
+                ((_d = (_c = metadata.extends) === null || _c === void 0 ? void 0 : _c[type]) === null || _d === void 0 ? void 0 : _d.includes(name)));
+        },
+    };
+}

package/esm/shared/utils.js

@@ -0,0 +1,101 @@
+import { GraphQLSchema } from 'graphql';
+export function flatten(arr) {
+    return Array.prototype.concat(...arr);
+}
+export function isDefined(val) {
+    return !isNil(val);
+}
+export function isNil(val) {
+    return val === null || typeof val === 'undefined';
+}
+export function isObject(val) {
+    return Object.prototype.toString.call(val) === '[object Object]';
+}
+export function isPrimitive(val) {
+    return ['number', 'string', 'boolean', 'symbol', 'bigint'].includes(typeof val);
+}
+export function isAsyncIterable(obj) {
+    return obj && typeof obj[Symbol.asyncIterator] === 'function';
+}
+export function tapAsyncIterator(iterable, doneCallback) {
+    const iteratorMethod = iterable[Symbol.asyncIterator];
+    const iterator = iteratorMethod.call(iterable);
+    function mapResult(result) {
+        if (result.done) {
+            doneCallback();
+        }
+        return result;
+    }
+    return {
+        async next() {
+            try {
+                let result = await iterator.next();
+                return mapResult(result);
+            }
+            catch (error) {
+                doneCallback();
+                throw error;
+            }
+        },
+        async return(value) {
+            try {
+                const result = await iterator.return(value);
+                return mapResult(result);
+            }
+            catch (error) {
+                doneCallback();
+                throw error;
+            }
+        },
+        throw(error) {
+            doneCallback();
+            return iterator.throw(error);
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+export function once(cb) {
+    let called = false;
+    return () => {
+        if (!called) {
+            called = true;
+            cb();
+        }
+    };
+}
+export function share(factory) {
+    let cached = null;
+    return (arg) => {
+        if (!cached) {
+            cached = factory(arg);
+        }
+        return cached;
+    };
+}
+export function uniqueId(isNotUsed) {
+    let id;
+    while (!isNotUsed((id = Math.random().toString(16).substr(2)))) { }
+    return id;
+}
+export function isNotSchema(obj) {
+    return obj instanceof GraphQLSchema === false;
+}
+export function merge(source, target) {
+    const result = {
+        ...source,
+        ...target,
+    };
+    function attachSymbols(obj) {
+        const symbols = Object.getOwnPropertySymbols(obj);
+        for (const symbol of symbols) {
+            result[symbol] = obj[symbol];
+        }
+    }
+    if (source) {
+        attachSymbols(source);
+    }
+    attachSymbols(target);
+    return result;
+}

package/esm/testing/di.js

@@ -0,0 +1,6 @@
+export function provideEmpty(token) {
+    return {
+        provide: token,
+        useValue: {},
+    };
+}

package/esm/testing/graphql.js

@@ -0,0 +1,7 @@
+export function execute(app, inputs, options) {
+    const executor = app.createExecution(options);
+    return executor({
+        schema: app.schema,
+        ...inputs,
+    });
+}