@graphql-mesh/runtime 1.0.0-alpha-20220804093904-8e2e41f7f → 1.0.0-alpha-20230420220344-25b6b92bf

package/cjs/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESH_API_CONTEXT_SYMBOL = exports.MESH_CONTEXT_SYMBOL = void 0;
+exports.MESH_CONTEXT_SYMBOL = Symbol('isMeshContext');
+exports.MESH_API_CONTEXT_SYMBOL = Symbol('isMeshAPIContext');

package/cjs/get-mesh.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMesh = exports.wrapFetchWithPlugins = void 0;
+const graphql_1 = require("graphql");
+const core_1 = require("@envelop/core");
+const extended_validation_1 = require("@envelop/extended-validation");
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const utils_1 = require("@graphql-mesh/utils");
+const delegate_1 = require("@graphql-tools/delegate");
+const utils_2 = require("@graphql-tools/utils");
+const fetch_1 = require("@whatwg-node/fetch");
+const constants_js_1 = require("./constants.js");
+const in_context_sdk_js_1 = require("./in-context-sdk.js");
+const useSubschema_js_1 = require("./useSubschema.js");
+const memoizedGetEnvelopedFactory = (0, utils_2.memoize1)(function getEnvelopedFactory(plugins) {
+    return (0, core_1.envelop)({
+        plugins,
+    });
+});
+const memoizedGetOperationType = (0, utils_2.memoize1)((document) => {
+    const operationAST = (0, graphql_1.getOperationAST)(document, undefined);
+    if (!operationAST) {
+        throw new Error('Must provide document with a valid operation');
+    }
+    return operationAST.operation;
+});
+function wrapFetchWithPlugins(plugins) {
+    return async function wrappedFetchFn(url, options, context, info) {
+        if (url != null && typeof url !== 'string') {
+            throw new TypeError(`First parameter(url) of 'fetch' must be a string, got ${(0, utils_2.inspect)(url)}`);
+        }
+        if (options != null && typeof options !== 'object') {
+            throw new TypeError(`Second parameter(options) of 'fetch' must be an object, got ${(0, utils_2.inspect)(options)}`);
+        }
+        if (context != null && typeof context !== 'object') {
+            throw new TypeError(`Third parameter(context) of 'fetch' must be an object, got ${(0, utils_2.inspect)(context)}`);
+        }
+        if (info != null && typeof info !== 'object') {
+            throw new TypeError(`Fourth parameter(info) of 'fetch' must be an object, got ${(0, utils_2.inspect)(info)}`);
+        }
+        let fetchFn;
+        const doneHooks = [];
+        for (const plugin of plugins) {
+            if ((plugin === null || plugin === void 0 ? void 0 : plugin.onFetch) != null) {
+                const doneHook = await plugin.onFetch({
+                    fetchFn,
+                    setFetchFn(newFetchFn) {
+                        fetchFn = newFetchFn;
+                    },
+                    url,
+                    options,
+                    context,
+                    info,
+                });
+                if (doneHook) {
+                    doneHooks.push(doneHook);
+                }
+            }
+        }
+        let response = await fetchFn(url, options, context, info);
+        for (const doneHook of doneHooks) {
+            await doneHook({
+                response,
+                setResponse(newResponse) {
+                    response = newResponse;
+                },
+            });
+        }
+        return response;
+    };
+}
+exports.wrapFetchWithPlugins = wrapFetchWithPlugins;
+// Use in-context-sdk for tracing
+function createProxyingResolverFactory(apiName, rootTypeMap) {
+    return function createProxyingResolver({ operation }) {
+        const rootType = rootTypeMap.get(operation);
+        return function proxyingResolver(root, args, context, info) {
+            var _a, _b;
+            if (!((_b = (_a = context === null || context === void 0 ? void 0 : context[apiName]) === null || _a === void 0 ? void 0 : _a[rootType.name]) === null || _b === void 0 ? void 0 : _b[info.fieldName])) {
+                throw new Error(`${info.fieldName} couldn't find in ${rootType.name} of ${apiName} as a ${operation}`);
+            }
+            return context[apiName][rootType.name][info.fieldName]({ root, args, context, info });
+        };
+    };
+}
+async function getMesh(options) {
+    const rawSources = [];
+    const { pubsub = new utils_1.PubSub(), cache, logger = new utils_1.DefaultLogger('🕸️  Mesh'), additionalEnvelopPlugins = [], sources, merger, additionalResolvers = [], additionalTypeDefs = [], transforms = [], fetchFn = fetch_1.fetch, } = options;
+    const getMeshLogger = logger.child('GetMesh');
+    getMeshLogger.debug(`Getting subschemas from source handlers`);
+    let failed = false;
+    const initialPluginList = [
+        // TODO: Not a good practise to expect users to be a Yoga user
+        (0, core_1.useExtendContext)(({ request, req }) => {
+            // Maybe Node-like environment
+            if (req === null || req === void 0 ? void 0 : req.headers) {
+                return {
+                    headers: (0, utils_1.getHeadersObj)(req.headers),
+                };
+            }
+            // Fetch environment
+            if (request === null || request === void 0 ? void 0 : request.headers) {
+                return {
+                    headers: (0, utils_1.getHeadersObj)(request.headers),
+                };
+            }
+            return {};
+        }),
+        (0, core_1.useExtendContext)(() => ({
+            pubsub,
+            cache,
+            logger,
+            [constants_js_1.MESH_CONTEXT_SYMBOL]: true,
+        })),
+        {
+            onFetch({ setFetchFn }) {
+                setFetchFn(fetchFn);
+            },
+        },
+        {
+            onParse({ setParseFn }) {
+                setParseFn(utils_1.parseWithCache);
+            },
+        },
+        ...additionalEnvelopPlugins,
+    ];
+    const wrappedFetchFn = wrapFetchWithPlugins(initialPluginList);
+    await Promise.allSettled(sources.map(async (apiSource) => {
+        const apiName = apiSource.name;
+        const sourceLogger = logger.child(apiName);
+        sourceLogger.debug(`Generating the schema`);
+        try {
+            const source = await apiSource.handler.getMeshSource({
+                fetchFn: wrappedFetchFn,
+            });
+            sourceLogger.debug(`The schema has been generated successfully`);
+            let apiSchema = source.schema;
+            sourceLogger.debug(`Analyzing transforms`);
+            let transforms;
+            const { wrapTransforms, noWrapTransforms } = (0, utils_1.groupTransforms)(apiSource.transforms);
+            if (!(wrapTransforms === null || wrapTransforms === void 0 ? void 0 : wrapTransforms.length) && (noWrapTransforms === null || noWrapTransforms === void 0 ? void 0 : noWrapTransforms.length)) {
+                sourceLogger.debug(`${noWrapTransforms.length} bare transforms found and applying`);
+                apiSchema = (0, utils_1.applySchemaTransforms)(apiSchema, source, null, noWrapTransforms);
+            }
+            else {
+                transforms = apiSource.transforms;
+            }
+            const rootTypeMap = (0, utils_2.getRootTypeMap)(apiSchema);
+            rawSources.push({
+                name: apiName,
+                schema: apiSchema,
+                executor: source.executor,
+                transforms,
+                contextVariables: source.contextVariables || {},
+                handler: apiSource.handler,
+                batch: 'batch' in source ? source.batch : true,
+                merge: source.merge,
+                createProxyingResolver: createProxyingResolverFactory(apiName, rootTypeMap),
+            });
+        }
+        catch (e) {
+            sourceLogger.error(`Failed to generate the schema`, e);
+            failed = true;
+        }
+    }));
+    if (failed) {
+        throw new Error(`Schemas couldn't be generated successfully. Check for the logs by running Mesh${cross_helpers_1.process.env.DEBUG == null
+            ? ' with DEBUG=1 environmental variable to get more verbose output'
+            : ''}.`);
+    }
+    getMeshLogger.debug(`Schemas have been generated by the source handlers`);
+    getMeshLogger.debug(`Merging schemas using the defined merging strategy.`);
+    const unifiedSubschema = await merger.getUnifiedSchema({
+        rawSources,
+        typeDefs: additionalTypeDefs,
+        resolvers: additionalResolvers,
+    });
+    unifiedSubschema.transforms = unifiedSubschema.transforms || [];
+    for (const rootLevelTransform of transforms) {
+        if (rootLevelTransform.noWrap) {
+            if (rootLevelTransform.transformSchema) {
+                unifiedSubschema.schema = rootLevelTransform.transformSchema(unifiedSubschema.schema, unifiedSubschema);
+            }
+        }
+        else {
+            unifiedSubschema.transforms.push(rootLevelTransform);
+        }
+    }
+    let inContextSDK$;
+    const subschema = new delegate_1.Subschema(unifiedSubschema);
+    const plugins = [
+        (0, core_1.useEngine)({
+            validate: graphql_1.validate,
+            specifiedRules: graphql_1.specifiedRules,
+        }),
+        (0, useSubschema_js_1.useSubschema)(subschema),
+        (0, core_1.useExtendContext)(() => {
+            if (!inContextSDK$) {
+                const onDelegateHooks = [];
+                for (const plugin of initialPluginList) {
+                    if ((plugin === null || plugin === void 0 ? void 0 : plugin.onDelegate) != null) {
+                        onDelegateHooks.push(plugin.onDelegate);
+                    }
+                }
+                inContextSDK$ = (0, in_context_sdk_js_1.getInContextSDK)(subschema.transformedSchema, rawSources, logger, onDelegateHooks);
+            }
+            return inContextSDK$;
+        }),
+        (0, extended_validation_1.useExtendedValidation)({
+            rules: [extended_validation_1.OneOfInputObjectsRule],
+        }),
+        ...initialPluginList,
+    ];
+    const EMPTY_ROOT_VALUE = {};
+    const EMPTY_CONTEXT_VALUE = {};
+    const EMPTY_VARIABLES_VALUE = {};
+    function createExecutor(globalContext = EMPTY_CONTEXT_VALUE) {
+        const getEnveloped = memoizedGetEnvelopedFactory(plugins);
+        const { schema, parse, execute, subscribe, contextFactory } = getEnveloped(globalContext);
+        return async function meshExecutor(documentOrSDL, variableValues = EMPTY_VARIABLES_VALUE, contextValue = EMPTY_CONTEXT_VALUE, rootValue = EMPTY_ROOT_VALUE, operationName) {
+            const document = typeof documentOrSDL === 'string' ? parse(documentOrSDL) : documentOrSDL;
+            const executeFn = memoizedGetOperationType(document) === 'subscription' ? subscribe : execute;
+            return executeFn({
+                schema,
+                document,
+                contextValue: await contextFactory(contextValue),
+                rootValue,
+                variableValues: variableValues,
+                operationName,
+            });
+        };
+    }
+    function sdkRequesterFactory(globalContext) {
+        const executor = createExecutor(globalContext);
+        return async function sdkRequester(...args) {
+            const result = await executor(...args);
+            if ((0, utils_2.isAsyncIterable)(result)) {
+                return (0, utils_2.mapAsyncIterator)(result, extractDataOrThrowErrors);
+            }
+            return extractDataOrThrowErrors(result);
+        };
+    }
+    function meshDestroy() {
+        return pubsub.publish('destroy', undefined);
+    }
+    return {
+        get schema() {
+            return subschema.transformedSchema;
+        },
+        rawSources,
+        cache,
+        pubsub,
+        destroy: meshDestroy,
+        logger,
+        plugins,
+        get getEnveloped() {
+            return memoizedGetEnvelopedFactory(plugins);
+        },
+        createExecutor,
+        get execute() {
+            return createExecutor();
+        },
+        get subscribe() {
+            return createExecutor();
+        },
+        sdkRequesterFactory,
+    };
+}
+exports.getMesh = getMesh;
+function extractDataOrThrowErrors(result) {
+    if (result.errors) {
+        if (result.errors.length === 1) {
+            throw result.errors[0];
+        }
+        throw new utils_2.AggregateError(result.errors);
+    }
+    return result.data;
+}

package/cjs/in-context-sdk.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInContextSDK = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-mesh/utils");
+const batch_delegate_1 = require("@graphql-tools/batch-delegate");
+const delegate_1 = require("@graphql-tools/delegate");
+const utils_2 = require("@graphql-tools/utils");
+const wrap_1 = require("@graphql-tools/wrap");
+const constants_js_1 = require("./constants.js");
+async function getInContextSDK(unifiedSchema, rawSources, logger, onDelegateHooks) {
+    const inContextSDK = {};
+    const sourceMap = unifiedSchema.extensions.sourceMap;
+    for (const rawSource of rawSources) {
+        const rawSourceLogger = logger.child(`${rawSource.name}`);
+        const rawSourceContext = {
+            rawSource,
+            [constants_js_1.MESH_API_CONTEXT_SYMBOL]: true,
+        };
+        // TODO: Somehow rawSource reference got lost in somewhere
+        let rawSourceSubSchemaConfig;
+        const stitchingInfo = unifiedSchema.extensions.stitchingInfo;
+        if (stitchingInfo) {
+            for (const [subschemaConfig, subschema] of stitchingInfo.subschemaMap) {
+                if (subschemaConfig.name === rawSource.name) {
+                    rawSourceSubSchemaConfig = subschema;
+                    break;
+                }
+            }
+        }
+        else {
+            rawSourceSubSchemaConfig = rawSource;
+        }
+        // If there is a single source, there is no unifiedSchema
+        const transformedSchema = sourceMap.get(rawSource);
+        const rootTypes = {
+            query: transformedSchema.getQueryType(),
+            mutation: transformedSchema.getMutationType(),
+            subscription: transformedSchema.getSubscriptionType(),
+        };
+        rawSourceLogger.debug(`Generating In Context SDK`);
+        for (const operationType in rootTypes) {
+            const rootType = rootTypes[operationType];
+            if (rootType) {
+                rawSourceContext[rootType.name] = {};
+                const rootTypeFieldMap = rootType.getFields();
+                for (const fieldName in rootTypeFieldMap) {
+                    const rootTypeField = rootTypeFieldMap[fieldName];
+                    const inContextSdkLogger = rawSourceLogger.child(`InContextSDK.${rootType.name}.${fieldName}`);
+                    const namedReturnType = (0, graphql_1.getNamedType)(rootTypeField.type);
+                    const shouldHaveSelectionSet = !(0, graphql_1.isLeafType)(namedReturnType);
+                    rawSourceContext[rootType.name][fieldName] = async ({ root, args, context, info = {
+                        fieldName,
+                        fieldNodes: [],
+                        returnType: namedReturnType,
+                        parentType: rootType,
+                        path: {
+                            typename: rootType.name,
+                            key: fieldName,
+                            prev: undefined,
+                        },
+                        schema: transformedSchema,
+                        fragments: {},
+                        rootValue: root,
+                        operation: {
+                            kind: graphql_1.Kind.OPERATION_DEFINITION,
+                            operation: operationType,
+                            selectionSet: {
+                                kind: graphql_1.Kind.SELECTION_SET,
+                                selections: [],
+                            },
+                        },
+                        variableValues: {},
+                    }, selectionSet, key, argsFromKeys, valuesFromResults, }) => {
+                        inContextSdkLogger.debug(`Called with`, {
+                            args,
+                            key,
+                        });
+                        const commonDelegateOptions = {
+                            schema: rawSourceSubSchemaConfig,
+                            rootValue: root,
+                            operation: operationType,
+                            fieldName,
+                            context,
+                            transformedSchema,
+                            info,
+                            transforms: [],
+                        };
+                        // If there isn't an extraction of a value
+                        if (typeof selectionSet !== 'function') {
+                            commonDelegateOptions.returnType = rootTypeField.type;
+                        }
+                        if (shouldHaveSelectionSet) {
+                            let selectionCount = 0;
+                            for (const fieldNode of info.fieldNodes) {
+                                if (fieldNode.selectionSet != null) {
+                                    selectionCount += fieldNode.selectionSet.selections.length;
+                                }
+                            }
+                            if (selectionCount === 0) {
+                                if (!selectionSet) {
+                                    throw new Error(`You have to provide 'selectionSet' for context.${rawSource.name}.${rootType.name}.${fieldName}`);
+                                }
+                                commonDelegateOptions.info = {
+                                    ...info,
+                                    fieldNodes: [
+                                        {
+                                            ...info.fieldNodes[0],
+                                            selectionSet: {
+                                                kind: graphql_1.Kind.SELECTION_SET,
+                                                selections: [
+                                                    {
+                                                        kind: graphql_1.Kind.FIELD,
+                                                        name: {
+                                                            kind: graphql_1.Kind.NAME,
+                                                            value: '__typename',
+                                                        },
+                                                    },
+                                                ],
+                                            },
+                                        },
+                                        ...info.fieldNodes.slice(1),
+                                    ],
+                                };
+                            }
+                        }
+                        if (key && argsFromKeys) {
+                            const batchDelegationOptions = {
+                                ...commonDelegateOptions,
+                                key,
+                                argsFromKeys,
+                                valuesFromResults,
+                            };
+                            if (selectionSet) {
+                                const selectionSetFactory = normalizeSelectionSetParamOrFactory(selectionSet);
+                                const path = [fieldName];
+                                const wrapQueryTransform = new wrap_1.WrapQuery(path, selectionSetFactory, identical);
+                                batchDelegationOptions.transforms = [wrapQueryTransform];
+                            }
+                            const onDelegateHookDones = [];
+                            for (const onDelegateHook of onDelegateHooks) {
+                                const onDelegateDone = await onDelegateHook({
+                                    ...batchDelegationOptions,
+                                    sourceName: rawSource.name,
+                                    typeName: rootType.name,
+                                    fieldName,
+                                });
+                                if (onDelegateDone) {
+                                    onDelegateHookDones.push(onDelegateDone);
+                                }
+                            }
+                            let result = await (0, batch_delegate_1.batchDelegateToSchema)(batchDelegationOptions);
+                            for (const onDelegateHookDone of onDelegateHookDones) {
+                                await onDelegateHookDone({
+                                    result,
+                                    setResult(newResult) {
+                                        result = newResult;
+                                    },
+                                });
+                            }
+                            return result;
+                        }
+                        else {
+                            const regularDelegateOptions = {
+                                ...commonDelegateOptions,
+                                args,
+                            };
+                            if (selectionSet) {
+                                const selectionSetFactory = normalizeSelectionSetParamOrFactory(selectionSet);
+                                const path = [fieldName];
+                                const wrapQueryTransform = new wrap_1.WrapQuery(path, selectionSetFactory, valuesFromResults || identical);
+                                regularDelegateOptions.transforms = [wrapQueryTransform];
+                            }
+                            const onDelegateHookDones = [];
+                            for (const onDelegateHook of onDelegateHooks) {
+                                const onDelegateDone = await onDelegateHook({
+                                    ...regularDelegateOptions,
+                                    sourceName: rawSource.name,
+                                    typeName: rootType.name,
+                                    fieldName,
+                                });
+                                if (onDelegateDone) {
+                                    onDelegateHookDones.push(onDelegateDone);
+                                }
+                            }
+                            let result = await (0, delegate_1.delegateToSchema)(regularDelegateOptions);
+                            for (const onDelegateHookDone of onDelegateHookDones) {
+                                await onDelegateHookDone({
+                                    result,
+                                    setResult(newResult) {
+                                        result = newResult;
+                                    },
+                                });
+                            }
+                            return result;
+                        }
+                    };
+                }
+            }
+        }
+        inContextSDK[rawSource.name] = rawSourceContext;
+    }
+    return inContextSDK;
+}
+exports.getInContextSDK = getInContextSDK;
+function getSelectionSetFromDocumentNode(documentNode) {
+    const operationDefinition = documentNode.definitions.find(definition => definition.kind === graphql_1.Kind.OPERATION_DEFINITION);
+    if (!operationDefinition) {
+        throw new Error('DocumentNode must contain an OperationDefinitionNode');
+    }
+    return operationDefinition.selectionSet;
+}
+function normalizeSelectionSetParam(selectionSetParam) {
+    if (typeof selectionSetParam === 'string') {
+        const documentNode = (0, utils_1.parseWithCache)(selectionSetParam);
+        return getSelectionSetFromDocumentNode(documentNode);
+    }
+    if ((0, utils_2.isDocumentNode)(selectionSetParam)) {
+        return getSelectionSetFromDocumentNode(selectionSetParam);
+    }
+    return selectionSetParam;
+}
+const normalizeSelectionSetParamFactory = (0, utils_2.memoize1)(function normalizeSelectionSetParamFactory(selectionSetParamFactory) {
+    const memoizedSelectionSetFactory = (0, utils_2.memoize1)(selectionSetParamFactory);
+    return function selectionSetFactory(subtree) {
+        const selectionSetParam = memoizedSelectionSetFactory(subtree);
+        return normalizeSelectionSetParam(selectionSetParam);
+    };
+});
+function normalizeSelectionSetParamOrFactory(selectionSetParamOrFactory) {
+    if (typeof selectionSetParamOrFactory === 'function') {
+        return normalizeSelectionSetParamFactory(selectionSetParamOrFactory);
+    }
+    return () => normalizeSelectionSetParam(selectionSetParamOrFactory);
+}
+function identical(val) {
+    return val;
+}

package/cjs/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./get-mesh.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./useSubschema.js"), exports);

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_js_1 = require("./constants.js");

package/cjs/useSubschema.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSubschema = void 0;
+const graphql_1 = require("graphql");
+const core_1 = require("@envelop/core");
+const utils_1 = require("@graphql-mesh/utils");
+const batch_execute_1 = require("@graphql-tools/batch-execute");
+const delegate_1 = require("@graphql-tools/delegate");
+const utils_2 = require("@graphql-tools/utils");
+var IntrospectionQueryType;
+(function (IntrospectionQueryType) {
+    IntrospectionQueryType["FEDERATION"] = "FEDERATION";
+    IntrospectionQueryType["REGULAR"] = "REGULAR";
+})(IntrospectionQueryType || (IntrospectionQueryType = {}));
+function getIntrospectionOperationType(operationAST) {
+    let introspectionQueryType = null;
+    (0, graphql_1.visit)(operationAST, {
+        Field: node => {
+            if (node.name.value === '__schema' || node.name.value === '__type') {
+                introspectionQueryType = IntrospectionQueryType.REGULAR;
+                return graphql_1.BREAK;
+            }
+            if (node.name.value === '_service') {
+                introspectionQueryType = IntrospectionQueryType.FEDERATION;
+                return graphql_1.BREAK;
+            }
+        },
+    });
+    return introspectionQueryType;
+}
+function getExecuteFn(subschema) {
+    return async function subschemaExecute(args) {
+        var _a;
+        const originalRequest = {
+            document: args.document,
+            variables: args.variableValues,
+            operationName: (_a = args.operationName) !== null && _a !== void 0 ? _a : undefined,
+            rootValue: args.rootValue,
+            context: args.contextValue,
+        };
+        const operationAST = (0, utils_2.getOperationASTFromRequest)(originalRequest);
+        // TODO: We need more elegant solution
+        const introspectionQueryType = getIntrospectionOperationType(operationAST);
+        if (introspectionQueryType === IntrospectionQueryType.FEDERATION) {
+            const executionResult = {
+                data: {
+                    _service: {
+                        sdl: (0, utils_2.printSchemaWithDirectives)(args.schema),
+                    },
+                },
+            };
+            return executionResult;
+        }
+        else if (introspectionQueryType === IntrospectionQueryType.REGULAR) {
+            return (0, graphql_1.execute)(args);
+        }
+        const delegationContext = {
+            subschema,
+            subschemaConfig: subschema,
+            targetSchema: args.schema,
+            operation: operationAST.operation,
+            fieldName: '',
+            context: args.contextValue,
+            rootValue: args.rootValue,
+            transforms: subschema.transforms,
+            transformedSchema: subschema.transformedSchema,
+            skipTypeMerging: true,
+            returnType: (0, utils_2.getDefinedRootType)(args.schema, operationAST.operation),
+        };
+        let executor = subschema.executor;
+        if (executor == null) {
+            executor = (0, delegate_1.createDefaultExecutor)(subschema.schema);
+        }
+        if (subschema.batch) {
+            executor = (0, batch_execute_1.createBatchingExecutor)(executor);
+        }
+        const transformationContext = {};
+        const transformedRequest = (0, utils_1.applyRequestTransforms)(originalRequest, delegationContext, transformationContext, subschema.transforms);
+        const originalResult = await executor(transformedRequest);
+        if ((0, utils_2.isAsyncIterable)(originalResult)) {
+            return (0, core_1.mapAsyncIterator)(originalResult, singleResult => (0, utils_1.applyResultTransforms)(singleResult, delegationContext, transformationContext, subschema.transforms));
+        }
+        const transformedResult = (0, utils_1.applyResultTransforms)(originalResult, delegationContext, transformationContext, subschema.transforms);
+        return transformedResult;
+    };
+}
+// Creates an envelop plugin to execute a subschema inside Envelop
+function useSubschema(subschema) {
+    const executeFn = getExecuteFn(subschema);
+    const plugin = {
+        onPluginInit({ setSchema }) {
+            // To prevent unwanted warnings from stitching
+            if (!('_transformedSchema' in subschema)) {
+                subschema.transformedSchema = (0, delegate_1.applySchemaTransforms)(subschema.schema, subschema);
+            }
+            subschema.transformedSchema.extensions =
+                subschema.transformedSchema.extensions || subschema.schema.extensions || {};
+            Object.assign(subschema.transformedSchema.extensions, subschema.schema.extensions);
+            setSchema(subschema.transformedSchema);
+        },
+        onExecute({ setExecuteFn }) {
+            setExecuteFn(executeFn);
+        },
+        onSubscribe({ setSubscribeFn }) {
+            setSubscribeFn(executeFn);
+        },
+    };
+    return plugin;
+}
+exports.useSubschema = useSubschema;

package/esm/constants.js

@@ -0,0 +1,2 @@
+export const MESH_CONTEXT_SYMBOL = Symbol('isMeshContext');
+export const MESH_API_CONTEXT_SYMBOL = Symbol('isMeshAPIContext');