@graphql-mesh/grpc 1.0.0-alpha-20230424111644-b7c761da0 → 1.0.0-alpha-20230522105300-fe9c79867

package/cjs/directives.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcRootJsonDirective = exports.ObjMapScalar = exports.grpcConnectivityStateDirective = exports.grpcMethodDirective = void 0;
+const graphql_1 = require("graphql");
+exports.grpcMethodDirective = new graphql_1.GraphQLDirective({
+    name: 'grpcMethod',
+    locations: [graphql_1.DirectiveLocation.FIELD_DEFINITION],
+    args: {
+        rootJsonName: {
+            type: graphql_1.GraphQLString,
+        },
+        objPath: {
+            type: graphql_1.GraphQLString,
+        },
+        methodName: {
+            type: graphql_1.GraphQLString,
+        },
+        responseStream: {
+            type: graphql_1.GraphQLBoolean,
+        },
+    },
+});
+exports.grpcConnectivityStateDirective = new graphql_1.GraphQLDirective({
+    name: 'grpcConnectivityState',
+    locations: [graphql_1.DirectiveLocation.FIELD_DEFINITION],
+    args: {
+        rootJsonName: {
+            type: graphql_1.GraphQLString,
+        },
+        objPath: {
+            type: graphql_1.GraphQLString,
+        },
+    },
+});
+exports.ObjMapScalar = new graphql_1.GraphQLScalarType({
+    name: 'ObjMap',
+    serialize: value => JSON.stringify(value),
+    parseValue: value => JSON.parse(value.toString()),
+    parseLiteral: ast => {
+        if (ast.kind === 'StringValue') {
+            return JSON.parse(ast.value);
+        }
+        return null;
+    },
+});
+exports.grpcRootJsonDirective = new graphql_1.GraphQLDirective({
+    name: 'grpcRootJson',
+    locations: [graphql_1.DirectiveLocation.OBJECT],
+    args: {
+        name: {
+            type: graphql_1.GraphQLString,
+        },
+        rootJson: {
+            type: exports.ObjMapScalar,
+        },
+        loadOptions: {
+            type: exports.ObjMapScalar,
+        },
+    },
+    isRepeatable: true,
+});

package/cjs/index.js

@@ -13,49 +13,27 @@ const index_js_1 = tslib_1.__importDefault(require("protobufjs/ext/descriptor/in
 const grpc_reflection_js_1 = require("@ardatan/grpc-reflection-js");
 const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
 const cross_helpers_2 = require("@graphql-mesh/cross-helpers");
+const store_1 = require("@graphql-mesh/store");
 const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-mesh/utils");
+const utils_2 = require("@graphql-tools/utils");
 const grpc_js_1 = require("@grpc/grpc-js");
 const proto_loader_1 = require("@grpc/proto-loader");
+const directives_js_1 = require("./directives.js");
 require("./patchLongJs.js");
 const utils_js_1 = require("./utils.js");
 const { Root } = protobufjs_1.default;
 const QUERY_METHOD_PREFIXES = ['get', 'list', 'search'];
 class GrpcHandler {
-    constructor({ config, baseDir, store, logger, pubsub, }) {
+    constructor({ config, baseDir, store, logger, pubsub, importFn, }) {
+        this.grpcObjectByserviceClientByObjPath = new WeakMap();
         this.schemaComposer = new graphql_compose_1.SchemaComposer();
         this.logger = logger;
         this.config = config;
         this.baseDir = baseDir;
-        this.rootJsonEntries = store.proxy('rootJsonEntries', {
-            codify: rootJsonEntries => `
-export default [
-${rootJsonEntries
-                .map(({ name, rootJson }) => `
-  {
-    name: ${JSON.stringify(name)},
-    rootJson: ${JSON.stringify(rootJson, null, 2)},
-  },
-`)
-                .join('\n')}
-];
-`.trim(),
-            fromJSON: jsonData => {
-                return jsonData.map(({ name, rootJson }) => ({
-                    name,
-                    rootJson,
-                }));
-            },
-            toJSON: rootJsonEntries => {
-                return rootJsonEntries.map(({ name, rootJson }) => {
-                    return {
-                        name,
-                        rootJson,
-                    };
-                });
-            },
-            validate: () => { },
-        });
+        this.schemaWithAnnotationsProxy = store.proxy('schemaWithAnnotations', store_1.PredefinedProxyOptions.GraphQLSchemaWithDiffing);
         this.pubsub = pubsub;
+        this.importFn = importFn;
     }
     async processReflection(creds) {
         this.logger.debug(`Using the reflection`);
@@ -147,38 +125,36 @@ ${rootJsonEntries
         this.logger.debug(`Adding proto content to the root`);
         return protoRoot;
     }
-    getCachedDescriptorSets(creds) {
-        return this.rootJsonEntries.getWithSet(async () => {
-            const rootPromises = [];
-            this.logger.debug(`Building Roots`);
-            if (this.config.source) {
-                const filePath = typeof this.config.source === 'string' ? this.config.source : this.config.source.file;
-                if (filePath.endsWith('json')) {
-                    rootPromises.push(this.processDescriptorFile());
-                }
-                else if (filePath.endsWith('proto')) {
-                    rootPromises.push(this.processProtoFile());
-                }
+    async getDescriptorSets(creds) {
+        const rootPromises = [];
+        this.logger.debug(`Building Roots`);
+        if (this.config.source) {
+            const filePath = typeof this.config.source === 'string' ? this.config.source : this.config.source.file;
+            if (filePath.endsWith('json')) {
+                rootPromises.push(this.processDescriptorFile());
             }
-            else {
-                const reflectionPromises = await this.processReflection(creds);
-                rootPromises.push(...reflectionPromises);
+            else if (filePath.endsWith('proto')) {
+                rootPromises.push(this.processProtoFile());
             }
-            return Promise.all(rootPromises.map(async (root$, i) => {
-                const root = await root$;
-                const rootName = root.name || `Root${i}`;
-                const rootLogger = this.logger.child(rootName);
-                rootLogger.debug(`Resolving entire the root tree`);
-                root.resolveAll();
-                rootLogger.debug(`Creating artifacts from descriptor set and root`);
-                return {
-                    name: rootName,
-                    rootJson: root.toJSON({
-                        keepComments: true,
-                    }),
-                };
-            }));
-        });
+        }
+        else {
+            const reflectionPromises = await this.processReflection(creds);
+            rootPromises.push(...reflectionPromises);
+        }
+        return Promise.all(rootPromises.map(async (root$, i) => {
+            const root = await root$;
+            const rootName = root.name || `Root${i}`;
+            const rootLogger = this.logger.child(rootName);
+            rootLogger.debug(`Resolving entire the root tree`);
+            root.resolveAll();
+            rootLogger.debug(`Creating artifacts from descriptor set and root`);
+            return {
+                name: rootName,
+                rootJson: root.toJSON({
+                    keepComments: true,
+                }),
+            };
+        }));
     }
     async getCredentials() {
         if (this.config.credentialsSsl) {
@@ -219,8 +195,102 @@ ${rootJsonEntries
         }
         return currentWalkingPath.concat(baseTypePath);
     }
-    visit({ nested, name, currentPath, rootJson, creds, grpcObject, rootLogger: logger, }) {
+    getGrpcObject({ rootJson, loadOptions, rootLogger, }) {
+        const packageDefinition = (0, proto_loader_1.fromJSON)(rootJson, loadOptions);
+        rootLogger.debug(`Creating service client for package definition`);
+        const grpcObject = (0, grpc_js_1.loadPackageDefinition)(packageDefinition);
+        return grpcObject;
+    }
+    getServiceClient({ grpcObject, objPath, creds, }) {
         var _a;
+        let serviceClientByObjPath = this.grpcObjectByserviceClientByObjPath.get(grpcObject);
+        if (!serviceClientByObjPath) {
+            serviceClientByObjPath = new Map();
+            this.grpcObjectByserviceClientByObjPath.set(grpcObject, serviceClientByObjPath);
+        }
+        let client = serviceClientByObjPath.get(objPath);
+        if (!client) {
+            const ServiceClient = (0, lodash_get_1.default)(grpcObject, objPath);
+            if (typeof ServiceClient !== 'function') {
+                throw new Error(`Object at path ${objPath} is not a Service constructor`);
+            }
+            client = new ServiceClient((_a = string_interpolation_1.stringInterpolator.parse(this.config.endpoint, { env: cross_helpers_1.process.env })) !== null && _a !== void 0 ? _a : this.config.endpoint, creds);
+            const subId = this.pubsub.subscribe('destroy', () => {
+                client.close();
+                this.pubsub.unsubscribe(subId);
+            });
+            serviceClientByObjPath.set(objPath, client);
+        }
+        return client;
+    }
+    getFieldResolver({ client, methodName, isResponseStream, }) {
+        const metaData = this.config.metaData;
+        const clientMethod = client[methodName].bind(client);
+        return function grpcFieldResolver(root, args, context) {
+            return (0, utils_js_1.addMetaDataToCall)(clientMethod, args.input, {
+                root,
+                args,
+                context,
+                env: cross_helpers_1.process.env,
+            }, metaData, isResponseStream);
+        };
+    }
+    getConnectivityStateResolver({ client, }) {
+        return function connectivityStateResolver(_, { tryToConnect }) {
+            return client.getChannel().getConnectivityState(tryToConnect);
+        };
+    }
+    processDirectives({ schema, creds }) {
+        const queryType = schema.getQueryType();
+        const rootJsonAnnotations = (0, utils_2.getDirective)(schema, queryType, 'grpcRootJson');
+        const rootJsonMap = new Map();
+        const grpcObjectByRootJsonName = new Map();
+        for (const { name, rootJson, loadOptions } of rootJsonAnnotations) {
+            rootJsonMap.set(name, rootJson);
+            const rootLogger = this.logger.child(name);
+            grpcObjectByRootJsonName.set(name, this.getGrpcObject({ rootJson, loadOptions, rootLogger }));
+        }
+        const rootTypes = (0, utils_2.getRootTypes)(schema);
+        for (const rootType of rootTypes) {
+            for (const fieldName in rootType.getFields()) {
+                const field = rootType.getFields()[fieldName];
+                const directives = (0, utils_2.getDirectives)(schema, field);
+                if (directives === null || directives === void 0 ? void 0 : directives.length) {
+                    for (const directiveObj of directives) {
+                        switch (directiveObj.name) {
+                            case 'grpcMethod': {
+                                const { rootJsonName, objPath, methodName, responseStream } = directiveObj.args;
+                                const grpcObject = grpcObjectByRootJsonName.get(rootJsonName);
+                                const client = this.getServiceClient({
+                                    grpcObject,
+                                    objPath,
+                                    creds,
+                                });
+                                field.resolve = this.getFieldResolver({
+                                    client,
+                                    methodName,
+                                    isResponseStream: responseStream,
+                                });
+                                break;
+                            }
+                            case 'grpcConnectivityState': {
+                                const { rootJsonName, objPath } = directiveObj.args;
+                                const grpcObject = grpcObjectByRootJsonName.get(rootJsonName);
+                                const client = this.getServiceClient({
+                                    grpcObject,
+                                    objPath,
+                                    creds,
+                                });
+                                field.resolve = this.getConnectivityStateResolver({ client });
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    visit({ nested, name, currentPath, rootJsonName, rootJson, rootLogger: logger, loadOptions, }) {
         const pathWithName = [...currentPath, ...name.split('.')].filter(Boolean);
         if ('nested' in nested) {
             for (const key in nested.nested) {
@@ -230,9 +300,8 @@ ${rootJsonEntries
                     nested: currentNested,
                     name: key,
                     currentPath: pathWithName,
+                    rootJsonName,
                     rootJson,
-                    creds,
-                    grpcObject,
                     rootLogger: logger,
                 });
             }
@@ -322,15 +391,6 @@ ${rootJsonEntries
         }
         else if ('methods' in nested) {
             const objPath = pathWithName.join('.');
-            const ServiceClient = (0, lodash_get_1.default)(grpcObject, objPath);
-            if (typeof ServiceClient !== 'function') {
-                throw new Error(`Object at path ${objPath} is not a Service constructor`);
-            }
-            const client = new ServiceClient((_a = string_interpolation_1.stringInterpolator.parse(this.config.endpoint, { env: cross_helpers_1.process.env })) !== null && _a !== void 0 ? _a : this.config.endpoint, creds);
-            const subId = this.pubsub.subscribe('destroy', () => {
-                client.close();
-                this.pubsub.unsubscribe(subId);
-            });
             for (const methodName in nested.methods) {
                 const method = nested.methods[methodName];
                 const rootFieldName = [...pathWithName, methodName].join('_');
@@ -370,19 +430,26 @@ ${rootJsonEntries
                 const rootTypeComposer = prefixQueryMethod.some(prefix => methodNameLowerCased.startsWith(prefix))
                     ? this.schemaComposer.Query
                     : this.schemaComposer.Mutation;
+                this.schemaComposer.addDirective(directives_js_1.grpcMethodDirective);
                 rootTypeComposer.addFields({
                     [rootFieldName]: {
                         ...fieldConfig,
-                        resolve: (root, args, context, info) => (0, utils_js_1.addMetaDataToCall)(client[methodName].bind(client), args.input, {
-                            root,
-                            args,
-                            context,
-                            env: cross_helpers_1.process.env,
-                        }, this.config.metaData, !!method.responseStream),
+                        directives: [
+                            {
+                                name: 'grpcMethod',
+                                args: {
+                                    rootJsonName,
+                                    objPath,
+                                    methodName,
+                                    responseStream: !!method.responseStream,
+                                },
+                            },
+                        ],
                     },
                 });
             }
             const connectivityStateFieldName = pathWithName.join('_') + '_connectivityState';
+            this.schemaComposer.addDirective(directives_js_1.grpcConnectivityStateDirective);
             this.schemaComposer.Query.addFields({
                 [connectivityStateFieldName]: {
                     type: 'ConnectivityState',
@@ -391,61 +458,96 @@ ${rootJsonEntries
                             type: 'Boolean',
                         },
                     },
-                    resolve: (_, { tryToConnect }) => client.getChannel().getConnectivityState(tryToConnect),
+                    directives: [
+                        {
+                            name: 'grpcConnectivityState',
+                            args: {
+                                rootJsonName,
+                                objPath,
+                            },
+                        },
+                    ],
                 },
             });
         }
     }
-    async getMeshSource() {
-        this.config.requestTimeout = this.config.requestTimeout || 200000;
-        this.schemaComposer.add(graphql_scalars_1.GraphQLBigInt);
-        this.schemaComposer.add(graphql_scalars_1.GraphQLByte);
-        this.schemaComposer.add(graphql_scalars_1.GraphQLUnsignedInt);
-        this.schemaComposer.add(graphql_scalars_1.GraphQLVoid);
-        this.schemaComposer.add(graphql_scalars_1.GraphQLJSON);
-        this.schemaComposer.createScalarTC({
-            name: 'File',
-        });
-        // identical of grpc's ConnectivityState
-        this.schemaComposer.createEnumTC({
-            name: 'ConnectivityState',
-            values: {
-                IDLE: { value: 0 },
-                CONNECTING: { value: 1 },
-                READY: { value: 2 },
-                TRANSIENT_FAILURE: { value: 3 },
-                SHUTDOWN: { value: 4 },
-            },
+    async getCachedNonExecutableSchema(creds) {
+        var _a;
+        const interpolatedSource = (_a = this.config.source) === null || _a === void 0 ? void 0 : _a.toString();
+        if (interpolatedSource === null || interpolatedSource === void 0 ? void 0 : interpolatedSource.endsWith('.graphql')) {
+            this.logger.info(`Fetching GraphQL Schema with annotations`);
+            const sdl = await (0, utils_1.readFileOrUrl)(interpolatedSource, {
+                allowUnknownExtensions: true,
+                cwd: this.baseDir,
+                fetch: this.fetchFn,
+                importFn: this.importFn,
+                logger: this.logger,
+                headers: this.config.schemaHeaders,
+            });
+            return (0, graphql_1.buildSchema)(sdl, {
+                assumeValidSDL: true,
+                assumeValid: true,
+            });
+        }
+        return this.schemaWithAnnotationsProxy.getWithSet(async () => {
+            this.schemaComposer.add(graphql_scalars_1.GraphQLBigInt);
+            this.schemaComposer.add(graphql_scalars_1.GraphQLByte);
+            this.schemaComposer.add(graphql_scalars_1.GraphQLUnsignedInt);
+            this.schemaComposer.add(graphql_scalars_1.GraphQLVoid);
+            this.schemaComposer.add(graphql_scalars_1.GraphQLJSON);
+            this.schemaComposer.createScalarTC({
+                name: 'File',
+            });
+            // identical of grpc's ConnectivityState
+            this.schemaComposer.createEnumTC({
+                name: 'ConnectivityState',
+                values: {
+                    IDLE: { value: 0 },
+                    CONNECTING: { value: 1 },
+                    READY: { value: 2 },
+                    TRANSIENT_FAILURE: { value: 3 },
+                    SHUTDOWN: { value: 4 },
+                },
+            });
+            this.logger.debug(`Getting stored root and decoded descriptor set objects`);
+            const descriptorSets = await this.getDescriptorSets(creds);
+            for (const { name: rootJsonName, rootJson } of descriptorSets) {
+                const rootLogger = this.logger.child(rootJsonName);
+                rootLogger.debug(`Creating package definition from file descriptor set object`);
+                let loadOptions;
+                if (typeof this.config.source === 'object') {
+                    loadOptions = this.config.source.load;
+                }
+                this.logger.debug(`Building the schema structure based on the root object`);
+                this.visit({
+                    nested: rootJson,
+                    name: '',
+                    currentPath: [],
+                    rootJsonName,
+                    rootJson,
+                    rootLogger,
+                    loadOptions,
+                });
+                this.schemaComposer.addDirective(directives_js_1.grpcRootJsonDirective);
+                this.schemaComposer.Query.setDirectiveByName('grpcRootJson', {
+                    name: rootJsonName,
+                    rootJson,
+                });
+            }
+            // graphql-compose doesn't add @defer and @stream to the schema
+            graphql_1.specifiedDirectives.forEach(directive => this.schemaComposer.addDirective(directive));
+            this.logger.debug(`Building the final GraphQL Schema`);
+            const schema = this.schemaComposer.buildSchema();
+            return schema;
         });
+    }
+    async getMeshSource({ fetchFn }) {
+        this.fetchFn = fetchFn;
+        this.config.requestTimeout = this.config.requestTimeout || 200000;
         this.logger.debug(`Getting channel credentials`);
         const creds = await this.getCredentials();
-        this.logger.debug(`Getting stored root and decoded descriptor set objects`);
-        const artifacts = await this.getCachedDescriptorSets(creds);
-        for (const { name, rootJson } of artifacts) {
-            const rootLogger = this.logger.child(name);
-            rootLogger.debug(`Creating package definition from file descriptor set object`);
-            let options;
-            if (typeof this.config.source === 'object') {
-                options = this.config.source.load;
-            }
-            const packageDefinition = (0, proto_loader_1.fromJSON)(rootJson, options);
-            rootLogger.debug(`Creating service client for package definition`);
-            const grpcObject = (0, grpc_js_1.loadPackageDefinition)(packageDefinition);
-            this.logger.debug(`Building the schema structure based on the root object`);
-            this.visit({
-                nested: rootJson,
-                name: '',
-                currentPath: [],
-                rootJson,
-                creds,
-                grpcObject,
-                rootLogger,
-            });
-        }
-        // graphql-compose doesn't add @defer and @stream to the schema
-        graphql_1.specifiedDirectives.forEach(directive => this.schemaComposer.addDirective(directive));
-        this.logger.debug(`Building the final GraphQL Schema`);
-        const schema = this.schemaComposer.buildSchema();
+        const schema = await this.getCachedNonExecutableSchema(creds);
+        this.processDirectives({ schema, creds });
         return {
             schema,
         };

package/esm/directives.js

@@ -0,0 +1,58 @@
+import { DirectiveLocation, GraphQLBoolean, GraphQLDirective, GraphQLScalarType, GraphQLString, } from 'graphql';
+export const grpcMethodDirective = new GraphQLDirective({
+    name: 'grpcMethod',
+    locations: [DirectiveLocation.FIELD_DEFINITION],
+    args: {
+        rootJsonName: {
+            type: GraphQLString,
+        },
+        objPath: {
+            type: GraphQLString,
+        },
+        methodName: {
+            type: GraphQLString,
+        },
+        responseStream: {
+            type: GraphQLBoolean,
+        },
+    },
+});
+export const grpcConnectivityStateDirective = new GraphQLDirective({
+    name: 'grpcConnectivityState',
+    locations: [DirectiveLocation.FIELD_DEFINITION],
+    args: {
+        rootJsonName: {
+            type: GraphQLString,
+        },
+        objPath: {
+            type: GraphQLString,
+        },
+    },
+});
+export const ObjMapScalar = new GraphQLScalarType({
+    name: 'ObjMap',
+    serialize: value => JSON.stringify(value),
+    parseValue: value => JSON.parse(value.toString()),
+    parseLiteral: ast => {
+        if (ast.kind === 'StringValue') {
+            return JSON.parse(ast.value);
+        }
+        return null;
+    },
+});
+export const grpcRootJsonDirective = new GraphQLDirective({
+    name: 'grpcRootJson',
+    locations: [DirectiveLocation.OBJECT],
+    args: {
+        name: {
+            type: GraphQLString,
+        },
+        rootJson: {
+            type: ObjMapScalar,
+        },
+        loadOptions: {
+            type: ObjMapScalar,
+        },
+    },
+    isRepeatable: true,
+});

package/esm/index.js

@@ -1,6 +1,6 @@
 /* eslint-disable import/no-duplicates */
 import globby from 'globby';
-import { specifiedDirectives } from 'graphql';
+import { buildSchema, specifiedDirectives, } from 'graphql';
 import { SchemaComposer } from 'graphql-compose';
 import { GraphQLBigInt, GraphQLByte, GraphQLJSON, GraphQLUnsignedInt, GraphQLVoid, } from 'graphql-scalars';
 import lodashGet from 'lodash.get';
@@ -10,49 +10,27 @@ import descriptor from 'protobufjs/ext/descriptor/index.js';
 import { Client } from '@ardatan/grpc-reflection-js';
 import { path, process } from '@graphql-mesh/cross-helpers';
 import { fs } from '@graphql-mesh/cross-helpers';
+import { PredefinedProxyOptions } from '@graphql-mesh/store';
 import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { readFileOrUrl } from '@graphql-mesh/utils';
+import { getDirective, getDirectives, getRootTypes } from '@graphql-tools/utils';
 import { credentials, loadPackageDefinition } from '@grpc/grpc-js';
 import { fromJSON } from '@grpc/proto-loader';
+import { grpcConnectivityStateDirective, grpcMethodDirective, grpcRootJsonDirective, } from './directives.js';
 import './patchLongJs.js';
 import { addIncludePathResolver, addMetaDataToCall, getTypeName } from './utils.js';
 const { Root } = protobufjs;
 const QUERY_METHOD_PREFIXES = ['get', 'list', 'search'];
 export default class GrpcHandler {
-    constructor({ config, baseDir, store, logger, pubsub, }) {
+    constructor({ config, baseDir, store, logger, pubsub, importFn, }) {
+        this.grpcObjectByserviceClientByObjPath = new WeakMap();
         this.schemaComposer = new SchemaComposer();
         this.logger = logger;
         this.config = config;
         this.baseDir = baseDir;
-        this.rootJsonEntries = store.proxy('rootJsonEntries', {
-            codify: rootJsonEntries => `
-export default [
-${rootJsonEntries
-                .map(({ name, rootJson }) => `
-  {
-    name: ${JSON.stringify(name)},
-    rootJson: ${JSON.stringify(rootJson, null, 2)},
-  },
-`)
-                .join('\n')}
-];
-`.trim(),
-            fromJSON: jsonData => {
-                return jsonData.map(({ name, rootJson }) => ({
-                    name,
-                    rootJson,
-                }));
-            },
-            toJSON: rootJsonEntries => {
-                return rootJsonEntries.map(({ name, rootJson }) => {
-                    return {
-                        name,
-                        rootJson,
-                    };
-                });
-            },
-            validate: () => { },
-        });
+        this.schemaWithAnnotationsProxy = store.proxy('schemaWithAnnotations', PredefinedProxyOptions.GraphQLSchemaWithDiffing);
         this.pubsub = pubsub;
+        this.importFn = importFn;
     }
     async processReflection(creds) {
         this.logger.debug(`Using the reflection`);
@@ -144,38 +122,36 @@ ${rootJsonEntries
         this.logger.debug(`Adding proto content to the root`);
         return protoRoot;
     }
-    getCachedDescriptorSets(creds) {
-        return this.rootJsonEntries.getWithSet(async () => {
-            const rootPromises = [];
-            this.logger.debug(`Building Roots`);
-            if (this.config.source) {
-                const filePath = typeof this.config.source === 'string' ? this.config.source : this.config.source.file;
-                if (filePath.endsWith('json')) {
-                    rootPromises.push(this.processDescriptorFile());
-                }
-                else if (filePath.endsWith('proto')) {
-                    rootPromises.push(this.processProtoFile());
-                }
+    async getDescriptorSets(creds) {
+        const rootPromises = [];
+        this.logger.debug(`Building Roots`);
+        if (this.config.source) {
+            const filePath = typeof this.config.source === 'string' ? this.config.source : this.config.source.file;
+            if (filePath.endsWith('json')) {
+                rootPromises.push(this.processDescriptorFile());
             }
-            else {
-                const reflectionPromises = await this.processReflection(creds);
-                rootPromises.push(...reflectionPromises);
+            else if (filePath.endsWith('proto')) {
+                rootPromises.push(this.processProtoFile());
             }
-            return Promise.all(rootPromises.map(async (root$, i) => {
-                const root = await root$;
-                const rootName = root.name || `Root${i}`;
-                const rootLogger = this.logger.child(rootName);
-                rootLogger.debug(`Resolving entire the root tree`);
-                root.resolveAll();
-                rootLogger.debug(`Creating artifacts from descriptor set and root`);
-                return {
-                    name: rootName,
-                    rootJson: root.toJSON({
-                        keepComments: true,
-                    }),
-                };
-            }));
-        });
+        }
+        else {
+            const reflectionPromises = await this.processReflection(creds);
+            rootPromises.push(...reflectionPromises);
+        }
+        return Promise.all(rootPromises.map(async (root$, i) => {
+            const root = await root$;
+            const rootName = root.name || `Root${i}`;
+            const rootLogger = this.logger.child(rootName);
+            rootLogger.debug(`Resolving entire the root tree`);
+            root.resolveAll();
+            rootLogger.debug(`Creating artifacts from descriptor set and root`);
+            return {
+                name: rootName,
+                rootJson: root.toJSON({
+                    keepComments: true,
+                }),
+            };
+        }));
     }
     async getCredentials() {
         if (this.config.credentialsSsl) {
@@ -216,8 +192,102 @@ ${rootJsonEntries
         }
         return currentWalkingPath.concat(baseTypePath);
     }
-    visit({ nested, name, currentPath, rootJson, creds, grpcObject, rootLogger: logger, }) {
+    getGrpcObject({ rootJson, loadOptions, rootLogger, }) {
+        const packageDefinition = fromJSON(rootJson, loadOptions);
+        rootLogger.debug(`Creating service client for package definition`);
+        const grpcObject = loadPackageDefinition(packageDefinition);
+        return grpcObject;
+    }
+    getServiceClient({ grpcObject, objPath, creds, }) {
         var _a;
+        let serviceClientByObjPath = this.grpcObjectByserviceClientByObjPath.get(grpcObject);
+        if (!serviceClientByObjPath) {
+            serviceClientByObjPath = new Map();
+            this.grpcObjectByserviceClientByObjPath.set(grpcObject, serviceClientByObjPath);
+        }
+        let client = serviceClientByObjPath.get(objPath);
+        if (!client) {
+            const ServiceClient = lodashGet(grpcObject, objPath);
+            if (typeof ServiceClient !== 'function') {
+                throw new Error(`Object at path ${objPath} is not a Service constructor`);
+            }
+            client = new ServiceClient((_a = stringInterpolator.parse(this.config.endpoint, { env: process.env })) !== null && _a !== void 0 ? _a : this.config.endpoint, creds);
+            const subId = this.pubsub.subscribe('destroy', () => {
+                client.close();
+                this.pubsub.unsubscribe(subId);
+            });
+            serviceClientByObjPath.set(objPath, client);
+        }
+        return client;
+    }
+    getFieldResolver({ client, methodName, isResponseStream, }) {
+        const metaData = this.config.metaData;
+        const clientMethod = client[methodName].bind(client);
+        return function grpcFieldResolver(root, args, context) {
+            return addMetaDataToCall(clientMethod, args.input, {
+                root,
+                args,
+                context,
+                env: process.env,
+            }, metaData, isResponseStream);
+        };
+    }
+    getConnectivityStateResolver({ client, }) {
+        return function connectivityStateResolver(_, { tryToConnect }) {
+            return client.getChannel().getConnectivityState(tryToConnect);
+        };
+    }
+    processDirectives({ schema, creds }) {
+        const queryType = schema.getQueryType();
+        const rootJsonAnnotations = getDirective(schema, queryType, 'grpcRootJson');
+        const rootJsonMap = new Map();
+        const grpcObjectByRootJsonName = new Map();
+        for (const { name, rootJson, loadOptions } of rootJsonAnnotations) {
+            rootJsonMap.set(name, rootJson);
+            const rootLogger = this.logger.child(name);
+            grpcObjectByRootJsonName.set(name, this.getGrpcObject({ rootJson, loadOptions, rootLogger }));
+        }
+        const rootTypes = getRootTypes(schema);
+        for (const rootType of rootTypes) {
+            for (const fieldName in rootType.getFields()) {
+                const field = rootType.getFields()[fieldName];
+                const directives = getDirectives(schema, field);
+                if (directives === null || directives === void 0 ? void 0 : directives.length) {
+                    for (const directiveObj of directives) {
+                        switch (directiveObj.name) {
+                            case 'grpcMethod': {
+                                const { rootJsonName, objPath, methodName, responseStream } = directiveObj.args;
+                                const grpcObject = grpcObjectByRootJsonName.get(rootJsonName);
+                                const client = this.getServiceClient({
+                                    grpcObject,
+                                    objPath,
+                                    creds,
+                                });
+                                field.resolve = this.getFieldResolver({
+                                    client,
+                                    methodName,
+                                    isResponseStream: responseStream,
+                                });
+                                break;
+                            }
+                            case 'grpcConnectivityState': {
+                                const { rootJsonName, objPath } = directiveObj.args;
+                                const grpcObject = grpcObjectByRootJsonName.get(rootJsonName);
+                                const client = this.getServiceClient({
+                                    grpcObject,
+                                    objPath,
+                                    creds,
+                                });
+                                field.resolve = this.getConnectivityStateResolver({ client });
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    visit({ nested, name, currentPath, rootJsonName, rootJson, rootLogger: logger, loadOptions, }) {
         const pathWithName = [...currentPath, ...name.split('.')].filter(Boolean);
         if ('nested' in nested) {
             for (const key in nested.nested) {
@@ -227,9 +297,8 @@ ${rootJsonEntries
                     nested: currentNested,
                     name: key,
                     currentPath: pathWithName,
+                    rootJsonName,
                     rootJson,
-                    creds,
-                    grpcObject,
                     rootLogger: logger,
                 });
             }
@@ -319,15 +388,6 @@ ${rootJsonEntries
         }
         else if ('methods' in nested) {
             const objPath = pathWithName.join('.');
-            const ServiceClient = lodashGet(grpcObject, objPath);
-            if (typeof ServiceClient !== 'function') {
-                throw new Error(`Object at path ${objPath} is not a Service constructor`);
-            }
-            const client = new ServiceClient((_a = stringInterpolator.parse(this.config.endpoint, { env: process.env })) !== null && _a !== void 0 ? _a : this.config.endpoint, creds);
-            const subId = this.pubsub.subscribe('destroy', () => {
-                client.close();
-                this.pubsub.unsubscribe(subId);
-            });
             for (const methodName in nested.methods) {
                 const method = nested.methods[methodName];
                 const rootFieldName = [...pathWithName, methodName].join('_');
@@ -367,19 +427,26 @@ ${rootJsonEntries
                 const rootTypeComposer = prefixQueryMethod.some(prefix => methodNameLowerCased.startsWith(prefix))
                     ? this.schemaComposer.Query
                     : this.schemaComposer.Mutation;
+                this.schemaComposer.addDirective(grpcMethodDirective);
                 rootTypeComposer.addFields({
                     [rootFieldName]: {
                         ...fieldConfig,
-                        resolve: (root, args, context, info) => addMetaDataToCall(client[methodName].bind(client), args.input, {
-                            root,
-                            args,
-                            context,
-                            env: process.env,
-                        }, this.config.metaData, !!method.responseStream),
+                        directives: [
+                            {
+                                name: 'grpcMethod',
+                                args: {
+                                    rootJsonName,
+                                    objPath,
+                                    methodName,
+                                    responseStream: !!method.responseStream,
+                                },
+                            },
+                        ],
                     },
                 });
             }
             const connectivityStateFieldName = pathWithName.join('_') + '_connectivityState';
+            this.schemaComposer.addDirective(grpcConnectivityStateDirective);
             this.schemaComposer.Query.addFields({
                 [connectivityStateFieldName]: {
                     type: 'ConnectivityState',
@@ -388,61 +455,96 @@ ${rootJsonEntries
                             type: 'Boolean',
                         },
                     },
-                    resolve: (_, { tryToConnect }) => client.getChannel().getConnectivityState(tryToConnect),
+                    directives: [
+                        {
+                            name: 'grpcConnectivityState',
+                            args: {
+                                rootJsonName,
+                                objPath,
+                            },
+                        },
+                    ],
                 },
             });
         }
     }
-    async getMeshSource() {
-        this.config.requestTimeout = this.config.requestTimeout || 200000;
-        this.schemaComposer.add(GraphQLBigInt);
-        this.schemaComposer.add(GraphQLByte);
-        this.schemaComposer.add(GraphQLUnsignedInt);
-        this.schemaComposer.add(GraphQLVoid);
-        this.schemaComposer.add(GraphQLJSON);
-        this.schemaComposer.createScalarTC({
-            name: 'File',
-        });
-        // identical of grpc's ConnectivityState
-        this.schemaComposer.createEnumTC({
-            name: 'ConnectivityState',
-            values: {
-                IDLE: { value: 0 },
-                CONNECTING: { value: 1 },
-                READY: { value: 2 },
-                TRANSIENT_FAILURE: { value: 3 },
-                SHUTDOWN: { value: 4 },
-            },
+    async getCachedNonExecutableSchema(creds) {
+        var _a;
+        const interpolatedSource = (_a = this.config.source) === null || _a === void 0 ? void 0 : _a.toString();
+        if (interpolatedSource === null || interpolatedSource === void 0 ? void 0 : interpolatedSource.endsWith('.graphql')) {
+            this.logger.info(`Fetching GraphQL Schema with annotations`);
+            const sdl = await readFileOrUrl(interpolatedSource, {
+                allowUnknownExtensions: true,
+                cwd: this.baseDir,
+                fetch: this.fetchFn,
+                importFn: this.importFn,
+                logger: this.logger,
+                headers: this.config.schemaHeaders,
+            });
+            return buildSchema(sdl, {
+                assumeValidSDL: true,
+                assumeValid: true,
+            });
+        }
+        return this.schemaWithAnnotationsProxy.getWithSet(async () => {
+            this.schemaComposer.add(GraphQLBigInt);
+            this.schemaComposer.add(GraphQLByte);
+            this.schemaComposer.add(GraphQLUnsignedInt);
+            this.schemaComposer.add(GraphQLVoid);
+            this.schemaComposer.add(GraphQLJSON);
+            this.schemaComposer.createScalarTC({
+                name: 'File',
+            });
+            // identical of grpc's ConnectivityState
+            this.schemaComposer.createEnumTC({
+                name: 'ConnectivityState',
+                values: {
+                    IDLE: { value: 0 },
+                    CONNECTING: { value: 1 },
+                    READY: { value: 2 },
+                    TRANSIENT_FAILURE: { value: 3 },
+                    SHUTDOWN: { value: 4 },
+                },
+            });
+            this.logger.debug(`Getting stored root and decoded descriptor set objects`);
+            const descriptorSets = await this.getDescriptorSets(creds);
+            for (const { name: rootJsonName, rootJson } of descriptorSets) {
+                const rootLogger = this.logger.child(rootJsonName);
+                rootLogger.debug(`Creating package definition from file descriptor set object`);
+                let loadOptions;
+                if (typeof this.config.source === 'object') {
+                    loadOptions = this.config.source.load;
+                }
+                this.logger.debug(`Building the schema structure based on the root object`);
+                this.visit({
+                    nested: rootJson,
+                    name: '',
+                    currentPath: [],
+                    rootJsonName,
+                    rootJson,
+                    rootLogger,
+                    loadOptions,
+                });
+                this.schemaComposer.addDirective(grpcRootJsonDirective);
+                this.schemaComposer.Query.setDirectiveByName('grpcRootJson', {
+                    name: rootJsonName,
+                    rootJson,
+                });
+            }
+            // graphql-compose doesn't add @defer and @stream to the schema
+            specifiedDirectives.forEach(directive => this.schemaComposer.addDirective(directive));
+            this.logger.debug(`Building the final GraphQL Schema`);
+            const schema = this.schemaComposer.buildSchema();
+            return schema;
         });
+    }
+    async getMeshSource({ fetchFn }) {
+        this.fetchFn = fetchFn;
+        this.config.requestTimeout = this.config.requestTimeout || 200000;
         this.logger.debug(`Getting channel credentials`);
         const creds = await this.getCredentials();
-        this.logger.debug(`Getting stored root and decoded descriptor set objects`);
-        const artifacts = await this.getCachedDescriptorSets(creds);
-        for (const { name, rootJson } of artifacts) {
-            const rootLogger = this.logger.child(name);
-            rootLogger.debug(`Creating package definition from file descriptor set object`);
-            let options;
-            if (typeof this.config.source === 'object') {
-                options = this.config.source.load;
-            }
-            const packageDefinition = fromJSON(rootJson, options);
-            rootLogger.debug(`Creating service client for package definition`);
-            const grpcObject = loadPackageDefinition(packageDefinition);
-            this.logger.debug(`Building the schema structure based on the root object`);
-            this.visit({
-                nested: rootJson,
-                name: '',
-                currentPath: [],
-                rootJson,
-                creds,
-                grpcObject,
-                rootLogger,
-            });
-        }
-        // graphql-compose doesn't add @defer and @stream to the schema
-        specifiedDirectives.forEach(directive => this.schemaComposer.addDirective(directive));
-        this.logger.debug(`Building the final GraphQL Schema`);
-        const schema = this.schemaComposer.buildSchema();
+        const schema = await this.getCachedNonExecutableSchema(creds);
+        this.processDirectives({ schema, creds });
         return {
             schema,
         };

package/package.json

@@ -1,20 +1,21 @@
 {
   "name": "@graphql-mesh/grpc",
-  "version": "1.0.0-alpha-20230424111644-b7c761da0",
+  "version": "1.0.0-alpha-20230522105300-fe9c79867",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/cross-helpers": "^0.3.4",
-    "@graphql-mesh/store": "1.0.0-alpha-20230424111644-b7c761da0",
-    "@graphql-mesh/types": "1.0.0-alpha-20230424111644-b7c761da0",
-    "@graphql-mesh/utils": "1.0.0-alpha-20230424111644-b7c761da0",
+    "@graphql-mesh/cross-helpers": "0.4.0-alpha-20230522105300-fe9c79867",
+    "@graphql-mesh/store": "1.0.0-alpha-20230522105300-fe9c79867",
+    "@graphql-mesh/types": "1.0.0-alpha-20230522105300-fe9c79867",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230522105300-fe9c79867",
+    "@graphql-tools/utils": "^9.2.1",
     "graphql": "*",
     "tslib": "^2.4.0"
   },
   "dependencies": {
     "@ardatan/grpc-reflection-js": "0.0.2",
-    "@graphql-mesh/string-interpolation": "0.4.4",
+    "@graphql-mesh/string-interpolation": "0.5.0-alpha-20230522105300-fe9c79867",
     "@grpc/grpc-js": "^1.1.7",
-    "@grpc/proto-loader": "0.7.6",
+    "@grpc/proto-loader": "0.7.7",
     "globby": "11.1.0",
     "graphql-compose": "9.0.10",
     "graphql-scalars": "^1.20.4",

package/typings/directives.d.cts

@@ -0,0 +1,5 @@
+import { GraphQLDirective, GraphQLScalarType } from 'graphql';
+export declare const grpcMethodDirective: GraphQLDirective;
+export declare const grpcConnectivityStateDirective: GraphQLDirective;
+export declare const ObjMapScalar: GraphQLScalarType<any, string>;
+export declare const grpcRootJsonDirective: GraphQLDirective;

package/typings/directives.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLDirective, GraphQLScalarType } from 'graphql';
+export declare const grpcMethodDirective: GraphQLDirective;
+export declare const grpcConnectivityStateDirective: GraphQLDirective;
+export declare const ObjMapScalar: GraphQLScalarType<any, string>;
+export declare const grpcRootJsonDirective: GraphQLDirective;

package/typings/index.d.cts

@@ -1,37 +1,68 @@
-import { AnyNestedObject } from 'protobufjs';
+import { GraphQLFieldResolver, GraphQLSchema } from 'graphql';
+import { AnyNestedObject, IParseOptions } from 'protobufjs';
 import protobufjs from 'protobufjs';
 import { Logger, MeshHandler, MeshHandlerOptions, YamlConfig } from '@graphql-mesh/types';
+import { GetMeshSourcePayload } from '@graphql-mesh/types';
 import { ChannelCredentials, loadPackageDefinition } from '@grpc/grpc-js';
+import { ServiceClient } from '@grpc/grpc-js/build/src/make-client.cjs';
 import './patchLongJs.cjs';
-type RootJsonEntry = {
-    name: string;
-    rootJson: protobufjs.INamespace;
-};
+interface LoadOptions extends IParseOptions {
+    includeDirs?: string[];
+}
 export default class GrpcHandler implements MeshHandler {
     private config;
     private baseDir;
-    private rootJsonEntries;
+    private schemaWithAnnotationsProxy;
     private logger;
     private pubsub;
-    constructor({ config, baseDir, store, logger, pubsub, }: MeshHandlerOptions<YamlConfig.GrpcHandler>);
+    private fetchFn;
+    private importFn;
+    constructor({ config, baseDir, store, logger, pubsub, importFn, }: MeshHandlerOptions<YamlConfig.GrpcHandler>);
     processReflection(creds: ChannelCredentials): Promise<Promise<protobufjs.Root>[]>;
     processDescriptorFile(): Promise<protobufjs.Root>;
     processProtoFile(): Promise<protobufjs.Root>;
-    getCachedDescriptorSets(creds: ChannelCredentials): Promise<RootJsonEntry[]>;
+    getDescriptorSets(creds: ChannelCredentials): Promise<{
+        name: string;
+        rootJson: protobufjs.INamespace;
+    }[]>;
     getCredentials(): Promise<ChannelCredentials>;
     walkToFindTypePath(rootJson: protobufjs.INamespace, pathWithName: string[], baseTypePath: string[]): string[];
-    visit({ nested, name, currentPath, rootJson, creds, grpcObject, rootLogger: logger, }: {
+    getGrpcObject({ rootJson, loadOptions, rootLogger, }: {
+        rootJson: protobufjs.INamespace;
+        loadOptions: LoadOptions;
+        rootLogger: Logger;
+    }): import("@grpc/grpc-js").GrpcObject;
+    private grpcObjectByserviceClientByObjPath;
+    getServiceClient({ grpcObject, objPath, creds, }: {
+        grpcObject: ReturnType<typeof loadPackageDefinition>;
+        objPath: string;
+        creds: ChannelCredentials;
+    }): ServiceClient;
+    getFieldResolver({ client, methodName, isResponseStream, }: {
+        client: ServiceClient;
+        methodName: string;
+        isResponseStream: boolean;
+    }): GraphQLFieldResolver<any, any>;
+    getConnectivityStateResolver({ client, }: {
+        client: ServiceClient;
+    }): GraphQLFieldResolver<any, any>;
+    processDirectives({ schema, creds }: {
+        schema: GraphQLSchema;
+        creds: ChannelCredentials;
+    }): void;
+    visit({ nested, name, currentPath, rootJsonName, rootJson, rootLogger: logger, loadOptions, }: {
         nested: AnyNestedObject;
         name: string;
         currentPath: string[];
+        rootJsonName: string;
         rootJson: protobufjs.INamespace;
-        creds: ChannelCredentials;
-        grpcObject: ReturnType<typeof loadPackageDefinition>;
         rootLogger: Logger;
+        loadOptions?: LoadOptions;
     }): void;
     private schemaComposer;
-    getMeshSource(): Promise<{
-        schema: import("graphql").GraphQLSchema;
+    private getCachedNonExecutableSchema;
+    getMeshSource({ fetchFn }: GetMeshSourcePayload): Promise<{
+        schema: GraphQLSchema;
     }>;
 }
 export {};

package/typings/index.d.ts

@@ -1,37 +1,68 @@
-import { AnyNestedObject } from 'protobufjs';
+import { GraphQLFieldResolver, GraphQLSchema } from 'graphql';
+import { AnyNestedObject, IParseOptions } from 'protobufjs';
 import protobufjs from 'protobufjs';
 import { Logger, MeshHandler, MeshHandlerOptions, YamlConfig } from '@graphql-mesh/types';
+import { GetMeshSourcePayload } from '@graphql-mesh/types';
 import { ChannelCredentials, loadPackageDefinition } from '@grpc/grpc-js';
+import { ServiceClient } from '@grpc/grpc-js/build/src/make-client.js';
 import './patchLongJs.js';
-type RootJsonEntry = {
-    name: string;
-    rootJson: protobufjs.INamespace;
-};
+interface LoadOptions extends IParseOptions {
+    includeDirs?: string[];
+}
 export default class GrpcHandler implements MeshHandler {
     private config;
     private baseDir;
-    private rootJsonEntries;
+    private schemaWithAnnotationsProxy;
     private logger;
     private pubsub;
-    constructor({ config, baseDir, store, logger, pubsub, }: MeshHandlerOptions<YamlConfig.GrpcHandler>);
+    private fetchFn;
+    private importFn;
+    constructor({ config, baseDir, store, logger, pubsub, importFn, }: MeshHandlerOptions<YamlConfig.GrpcHandler>);
     processReflection(creds: ChannelCredentials): Promise<Promise<protobufjs.Root>[]>;
     processDescriptorFile(): Promise<protobufjs.Root>;
     processProtoFile(): Promise<protobufjs.Root>;
-    getCachedDescriptorSets(creds: ChannelCredentials): Promise<RootJsonEntry[]>;
+    getDescriptorSets(creds: ChannelCredentials): Promise<{
+        name: string;
+        rootJson: protobufjs.INamespace;
+    }[]>;
     getCredentials(): Promise<ChannelCredentials>;
     walkToFindTypePath(rootJson: protobufjs.INamespace, pathWithName: string[], baseTypePath: string[]): string[];
-    visit({ nested, name, currentPath, rootJson, creds, grpcObject, rootLogger: logger, }: {
+    getGrpcObject({ rootJson, loadOptions, rootLogger, }: {
+        rootJson: protobufjs.INamespace;
+        loadOptions: LoadOptions;
+        rootLogger: Logger;
+    }): import("@grpc/grpc-js").GrpcObject;
+    private grpcObjectByserviceClientByObjPath;
+    getServiceClient({ grpcObject, objPath, creds, }: {
+        grpcObject: ReturnType<typeof loadPackageDefinition>;
+        objPath: string;
+        creds: ChannelCredentials;
+    }): ServiceClient;
+    getFieldResolver({ client, methodName, isResponseStream, }: {
+        client: ServiceClient;
+        methodName: string;
+        isResponseStream: boolean;
+    }): GraphQLFieldResolver<any, any>;
+    getConnectivityStateResolver({ client, }: {
+        client: ServiceClient;
+    }): GraphQLFieldResolver<any, any>;
+    processDirectives({ schema, creds }: {
+        schema: GraphQLSchema;
+        creds: ChannelCredentials;
+    }): void;
+    visit({ nested, name, currentPath, rootJsonName, rootJson, rootLogger: logger, loadOptions, }: {
         nested: AnyNestedObject;
         name: string;
         currentPath: string[];
+        rootJsonName: string;
         rootJson: protobufjs.INamespace;
-        creds: ChannelCredentials;
-        grpcObject: ReturnType<typeof loadPackageDefinition>;
         rootLogger: Logger;
+        loadOptions?: LoadOptions;
     }): void;
     private schemaComposer;
-    getMeshSource(): Promise<{
-        schema: import("graphql").GraphQLSchema;
+    private getCachedNonExecutableSchema;
+    getMeshSource({ fetchFn }: GetMeshSourcePayload): Promise<{
+        schema: GraphQLSchema;
     }>;
 }
 export {};