@graphql-mesh/grpc 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/{index.mjs → esm/index.js}

@@ -1,160 +1,35 @@
-import Long from 'long';
-import { stringInterpolator } from '@graphql-mesh/string-interpolation';
-import { Metadata, credentials, loadPackageDefinition } from '@grpc/grpc-js';
-import { loadFileDescriptorSetFromObject } from '@grpc/proto-loader';
+/* eslint-disable import/no-duplicates */
+import globby from 'globby';
+import { specifiedDirectives } from 'graphql';
 import { SchemaComposer } from 'graphql-compose';
-import { GraphQLJSON, GraphQLBigInt, GraphQLByte, GraphQLUnsignedInt, GraphQLVoid } from 'graphql-scalars';
+import { GraphQLBigInt, GraphQLByte, GraphQLJSON, GraphQLUnsignedInt, GraphQLVoid, } from 'graphql-scalars';
 import lodashGet from 'lodash.get';
 import lodashHas from 'lodash.has';
 import protobufjs from 'protobufjs';
-import grpcReflection from '@ardatan/grpc-reflection-js';
-import descriptor, { FileDescriptorSet } from 'protobufjs/ext/descriptor/index.js';
-import { withCancel } from '@graphql-mesh/utils';
-import { path, fs, process } from '@graphql-mesh/cross-helpers';
-import { specifiedDirectives } from 'graphql';
-import globby from 'globby';
-
-function patchLongJs() {
-    const originalLongFromValue = Long.fromValue.bind(Long);
-    Long.fromValue = (value) => {
-        if (typeof value === 'bigint') {
-            return Long.fromValue(value.toString());
-        }
-        return originalLongFromValue(value);
-    };
-}
-patchLongJs();
-
-const SCALARS = new Map([
-    ['bool', 'Boolean'],
-    ['bytes', 'Byte'],
-    ['double', 'Float'],
-    ['fixed32', 'Int'],
-    ['fixed64', 'BigInt'],
-    ['float', 'Float'],
-    ['int32', 'Int'],
-    ['int64', 'BigInt'],
-    ['sfixed32', 'Int'],
-    ['sfixed64', 'BigInt'],
-    ['sint32', 'Int'],
-    ['sint64', 'BigInt'],
-    ['string', 'String'],
-    ['uint32', 'UnsignedInt'],
-    ['uint64', 'BigInt'], // A new scalar might be needed
-]);
-function isScalarType(type) {
-    return SCALARS.has(type);
-}
-function getGraphQLScalar(scalarType) {
-    const gqlScalar = SCALARS.get(scalarType);
-    if (!gqlScalar) {
-        throw new Error(`Could not find GraphQL Scalar for type ${scalarType}`);
-    }
-    return SCALARS.get(scalarType);
-}
-
-function getTypeName(schemaComposer, pathWithName, isInput) {
-    if (pathWithName === null || pathWithName === void 0 ? void 0 : pathWithName.length) {
-        const baseTypeName = pathWithName.filter(Boolean).join('_');
-        if (isScalarType(baseTypeName)) {
-            return getGraphQLScalar(baseTypeName);
-        }
-        if (schemaComposer.isEnumType(baseTypeName)) {
-            return baseTypeName;
-        }
-        return isInput ? baseTypeName + '_Input' : baseTypeName;
-    }
-    return 'Void';
-}
-function addIncludePathResolver(root, includePaths) {
-    const originalResolvePath = root.resolvePath;
-    root.resolvePath = (origin, target) => {
-        if (path.isAbsolute(target)) {
-            return target;
-        }
-        for (const directory of includePaths) {
-            const fullPath = path.join(directory, target);
-            if (fs.existsSync(fullPath)) {
-                return fullPath;
-            }
-        }
-        const path$1 = originalResolvePath(origin, target);
-        if (path$1 === null) {
-            console.warn(`${target} not found in any of the include paths ${includePaths}`);
-        }
-        return path$1;
-    };
-}
-function isBlob(input) {
-    return input != null && input.stream instanceof Function;
-}
-function addMetaDataToCall(callFn, input, context, metaData, isResponseStream = false) {
-    const callFnArguments = [];
-    if (!isBlob(input)) {
-        callFnArguments.push(input);
-    }
-    if (metaData) {
-        const meta = new Metadata();
-        for (const [key, value] of Object.entries(metaData)) {
-            let metaValue = value;
-            if (Array.isArray(value)) {
-                // Extract data from context
-                metaValue = lodashGet(context, value);
-            }
-            // Ensure that the metadata is compatible with what node-grpc expects
-            if (typeof metaValue !== 'string' && !(metaValue instanceof Buffer)) {
-                metaValue = JSON.stringify(metaValue);
-            }
-            if (typeof metaValue === 'string') {
-                metaValue = stringInterpolator.parse(metaValue, context);
-            }
-            meta.add(key, metaValue);
-        }
-        callFnArguments.push(meta);
-    }
-    return new Promise((resolve, reject) => {
-        const call = callFn(...callFnArguments, (error, response) => {
-            if (error) {
-                reject(error);
-            }
-            resolve(response);
-        });
-        if (isResponseStream) {
-            let isCancelled = false;
-            const responseStreamWithCancel = withCancel(call, () => {
-                var _a;
-                if (!isCancelled) {
-                    (_a = call.call) === null || _a === void 0 ? void 0 : _a.cancelWithStatus(0, 'Cancelled by GraphQL Mesh');
-                    isCancelled = true;
-                }
-            });
-            resolve(responseStreamWithCancel);
-            if (isBlob(input)) {
-                input.stream().pipe(call);
-            }
-        }
-    });
-}
-
-/* eslint-disable import/no-duplicates */
+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 { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { credentials, loadPackageDefinition } from '@grpc/grpc-js';
+import { fromJSON } from '@grpc/proto-loader';
+import './patchLongJs.js';
+import { addIncludePathResolver, addMetaDataToCall, getTypeName } from './utils.js';
 const { Root } = protobufjs;
-const QUERY_METHOD_PREFIXES = ['get', 'list'];
-class GrpcHandler {
-    constructor({ config, baseDir, store, logger }) {
+const QUERY_METHOD_PREFIXES = ['get', 'list', 'search'];
+export default class GrpcHandler {
+    constructor({ config, baseDir, store, logger, pubsub, }) {
         this.schemaComposer = new SchemaComposer();
         this.logger = logger;
         this.config = config;
         this.baseDir = baseDir;
-        this.rootJsonAndDecodedDescriptorSets = store.proxy('descriptorSet.proto', {
-            codify: rootJsonAndDecodedDescriptorSets => `
-import { FileDescriptorSet } from 'protobufjs/ext/descriptor/index.js';
-
+        this.rootJsonEntries = store.proxy('rootJsonEntries', {
+            codify: rootJsonEntries => `
 export default [
-${rootJsonAndDecodedDescriptorSets
-                .map(({ name, rootJson, decodedDescriptorSet }) => `
+${rootJsonEntries
+                .map(({ name, rootJson }) => `
   {
     name: ${JSON.stringify(name)},
-    decodedDescriptorSet: FileDescriptorSet.fromObject(${JSON.stringify(decodedDescriptorSet.toJSON(), null, 2)}),
     rootJson: ${JSON.stringify(rootJson, null, 2)},
   },
 `)
@@ -162,29 +37,32 @@ ${rootJsonAndDecodedDescriptorSets
 ];
 `.trim(),
             fromJSON: jsonData => {
-                return jsonData.map(({ name, rootJson, decodedDescriptorSet }) => ({
+                return jsonData.map(({ name, rootJson }) => ({
                     name,
                     rootJson,
-                    decodedDescriptorSet: FileDescriptorSet.fromObject(decodedDescriptorSet),
                 }));
             },
-            toJSON: rootJsonAndDecodedDescriptorSets => {
-                return rootJsonAndDecodedDescriptorSets.map(({ name, rootJson, decodedDescriptorSet }) => {
+            toJSON: rootJsonEntries => {
+                return rootJsonEntries.map(({ name, rootJson }) => {
                     return {
                         name,
                         rootJson,
-                        decodedDescriptorSet: decodedDescriptorSet.toJSON(),
                     };
                 });
             },
             validate: () => { },
         });
+        this.pubsub = pubsub;
     }
-    async getRootPromisesFromReflection(creds) {
+    async processReflection(creds) {
         this.logger.debug(`Using the reflection`);
         const grpcReflectionServer = this.config.endpoint;
         this.logger.debug(`Creating gRPC Reflection Client`);
-        const reflectionClient = new grpcReflection.Client(grpcReflectionServer, creds);
+        const reflectionClient = new Client(grpcReflectionServer, creds);
+        const subId = this.pubsub.subscribe('destroy', () => {
+            reflectionClient.grpcClient.close();
+            this.pubsub.unsubscribe(subId);
+        });
         const services = await reflectionClient.listServices();
         const userServices = services.filter(service => service && !(service === null || service === void 0 ? void 0 : service.startsWith('grpc.')));
         return userServices.map(async (service) => {
@@ -193,21 +71,23 @@ ${rootJsonAndDecodedDescriptorSets
             return serviceRoot;
         });
     }
-    async getRootPromiseFromDescriptorFilePath() {
+    async processDescriptorFile() {
         var _a;
         let fileName;
         let options;
-        if (typeof this.config.descriptorSetFilePath === 'object') {
-            fileName = this.config.descriptorSetFilePath.file;
+        if (typeof this.config.source === 'object') {
+            fileName = this.config.source.file;
             options = {
-                ...this.config.descriptorSetFilePath.load,
-                includeDirs: (_a = this.config.descriptorSetFilePath.load.includeDirs) === null || _a === void 0 ? void 0 : _a.map(includeDir => path.isAbsolute(includeDir) ? includeDir : path.join(this.baseDir, includeDir)),
+                ...this.config.source.load,
+                includeDirs: (_a = this.config.source.load.includeDirs) === null || _a === void 0 ? void 0 : _a.map(includeDir => path.isAbsolute(includeDir) ? includeDir : path.join(this.baseDir, includeDir)),
             };
         }
         else {
-            fileName = this.config.descriptorSetFilePath;
+            fileName = this.config.source;
         }
-        const absoluteFilePath = path.isAbsolute(fileName) ? fileName : path.join(this.baseDir, fileName);
+        const absoluteFilePath = path.isAbsolute(fileName)
+            ? fileName
+            : path.join(this.baseDir, fileName);
         this.logger.debug(`Using the descriptor set from ${absoluteFilePath} `);
         const descriptorSetBuffer = await fs.promises.readFile(absoluteFilePath);
         this.logger.debug(`Reading ${absoluteFilePath} `);
@@ -230,7 +110,7 @@ ${rootJsonAndDecodedDescriptorSets
         }
         return rootFromDescriptor;
     }
-    async getRootPromiseFromProtoFilePath() {
+    async processProtoFile() {
         var _a, _b;
         this.logger.debug(`Using proto file(s)`);
         let protoRoot = new Root();
@@ -239,46 +119,47 @@ ${rootJsonAndDecodedDescriptorSets
             keepCase: true,
             alternateCommentMode: true,
         };
-        if (typeof this.config.protoFilePath === 'object') {
-            fileGlob = this.config.protoFilePath.file;
+        if (typeof this.config.source === 'object') {
+            fileGlob = this.config.source.file;
             options = {
                 ...options,
-                ...this.config.protoFilePath.load,
-                includeDirs: (_b = (_a = this.config.protoFilePath.load) === null || _a === void 0 ? void 0 : _a.includeDirs) === null || _b === void 0 ? void 0 : _b.map(includeDir => path.isAbsolute(includeDir) ? includeDir : path.join(this.baseDir, includeDir)),
+                ...this.config.source.load,
+                includeDirs: (_b = (_a = this.config.source.load) === null || _a === void 0 ? void 0 : _a.includeDirs) === null || _b === void 0 ? void 0 : _b.map(includeDir => path.isAbsolute(includeDir) ? includeDir : path.join(this.baseDir, includeDir)),
             };
             if (options.includeDirs) {
                 if (!Array.isArray(options.includeDirs)) {
-                    return Promise.reject(new Error('The includeDirs option must be an array'));
+                    throw new Error('The includeDirs option must be an array');
                 }
                 addIncludePathResolver(protoRoot, options.includeDirs);
             }
         }
         else {
-            fileGlob = this.config.protoFilePath;
+            fileGlob = this.config.source;
         }
         const fileNames = await globby(fileGlob, {
             cwd: this.baseDir,
         });
         this.logger.debug(`Loading proto files(${fileGlob}); \n ${fileNames.join('\n')} `);
-        protoRoot = await protoRoot.load(fileNames.map(filePath => (path.isAbsolute(filePath) ? filePath : path.join(this.baseDir, filePath))), options);
+        protoRoot = await protoRoot.load(fileNames.map(filePath => path.isAbsolute(filePath) ? filePath : path.join(this.baseDir, filePath)), options);
         this.logger.debug(`Adding proto content to the root`);
         return protoRoot;
     }
     getCachedDescriptorSets(creds) {
-        return this.rootJsonAndDecodedDescriptorSets.getWithSet(async () => {
+        return this.rootJsonEntries.getWithSet(async () => {
             const rootPromises = [];
             this.logger.debug(`Building Roots`);
-            if (this.config.useReflection) {
-                const reflectionPromises = await this.getRootPromisesFromReflection(creds);
-                rootPromises.push(...reflectionPromises);
-            }
-            if (this.config.descriptorSetFilePath) {
-                const rootPromise = this.getRootPromiseFromDescriptorFilePath();
-                rootPromises.push(rootPromise);
+            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());
+                }
             }
-            if (this.config.protoFilePath) {
-                const rootPromise = this.getRootPromiseFromProtoFilePath();
-                rootPromises.push(rootPromise);
+            else {
+                const reflectionPromises = await this.processReflection(creds);
+                rootPromises.push(...reflectionPromises);
             }
             return Promise.all(rootPromises.map(async (root$, i) => {
                 const root = await root$;
@@ -292,7 +173,6 @@ ${rootJsonAndDecodedDescriptorSets
                     rootJson: root.toJSON({
                         keepComments: true,
                     }),
-                    decodedDescriptorSet: root.toDescriptor('proto3'),
                 };
             }));
         });
@@ -306,7 +186,10 @@ ${rootJsonAndDecodedDescriptorSets
             const absoluteCertChainPath = path.isAbsolute(this.config.credentialsSsl.certChain)
                 ? this.config.credentialsSsl.certChain
                 : path.join(this.baseDir, this.config.credentialsSsl.certChain);
-            const sslFiles = [fs.promises.readFile(absolutePrivateKeyPath), fs.promises.readFile(absoluteCertChainPath)];
+            const sslFiles = [
+                fs.promises.readFile(absolutePrivateKeyPath),
+                fs.promises.readFile(absoluteCertChainPath),
+            ];
             if (this.config.credentialsSsl.rootCA !== 'rootCA') {
                 const absoluteRootCAPath = path.isAbsolute(this.config.credentialsSsl.rootCA)
                     ? this.config.credentialsSsl.rootCA
@@ -384,14 +267,20 @@ ${rootJsonAndDecodedDescriptorSets
                     description,
                     fields: {},
                 });
-                for (const [fieldName, { type, rule, comment }] of fieldEntries) {
+                for (const [fieldName, { type, rule, comment, keyType }] of fieldEntries) {
                     logger.debug(`Visiting ${currentPath}.nested.fields[${fieldName}]`);
                     const baseFieldTypePath = type.split('.');
                     inputTC.addFields({
                         [fieldName]: {
                             type: () => {
-                                const fieldTypePath = this.walkToFindTypePath(rootJson, pathWithName, baseFieldTypePath);
-                                const fieldInputTypeName = getTypeName(this.schemaComposer, fieldTypePath, true);
+                                let fieldInputTypeName;
+                                if (keyType) {
+                                    fieldInputTypeName = 'JSON';
+                                }
+                                else {
+                                    const fieldTypePath = this.walkToFindTypePath(rootJson, pathWithName, baseFieldTypePath);
+                                    fieldInputTypeName = getTypeName(this.schemaComposer, fieldTypePath, true);
+                                }
                                 return rule === 'repeated' ? `[${fieldInputTypeName}]` : fieldInputTypeName;
                             },
                             description: comment,
@@ -400,8 +289,14 @@ ${rootJsonAndDecodedDescriptorSets
                     outputTC.addFields({
                         [fieldName]: {
                             type: () => {
-                                const fieldTypePath = this.walkToFindTypePath(rootJson, pathWithName, baseFieldTypePath);
-                                const fieldTypeName = getTypeName(this.schemaComposer, fieldTypePath, false);
+                                let fieldTypeName;
+                                if (keyType) {
+                                    fieldTypeName = 'JSON';
+                                }
+                                else {
+                                    const fieldTypePath = this.walkToFindTypePath(rootJson, pathWithName, baseFieldTypePath);
+                                    fieldTypeName = getTypeName(this.schemaComposer, fieldTypePath, false);
+                                }
                                 return rule === 'repeated' ? `[${fieldTypeName}]` : fieldTypeName;
                             },
                             description: comment,
@@ -429,6 +324,10 @@ ${rootJsonAndDecodedDescriptorSets
                 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('_');
@@ -438,7 +337,11 @@ ${rootJsonAndDecodedDescriptorSets
                         const baseResponseTypePath = (_a = method.responseType) === null || _a === void 0 ? void 0 : _a.split('.');
                         if (baseResponseTypePath) {
                             const responseTypePath = this.walkToFindTypePath(rootJson, pathWithName, baseResponseTypePath);
-                            return getTypeName(this.schemaComposer, responseTypePath, false);
+                            let typeName = getTypeName(this.schemaComposer, responseTypePath, false);
+                            if (method.responseStream) {
+                                typeName = `[${typeName}]`;
+                            }
+                            return typeName;
                         }
                         return 'Void';
                     },
@@ -459,28 +362,22 @@ ${rootJsonAndDecodedDescriptorSets
                         return undefined;
                     },
                 };
-                if (method.responseStream) {
-                    this.schemaComposer.Subscription.addFields({
-                        [rootFieldName]: {
-                            ...fieldConfig,
-                            subscribe: (__, args, context) => addMetaDataToCall(client[methodName].bind(client), args.input, context, this.config.metaData, true),
-                            resolve: (payload) => payload,
-                        },
-                    });
-                }
-                else {
-                    const methodNameLowerCased = methodName.toLowerCase();
-                    const prefixQueryMethod = this.config.prefixQueryMethod || QUERY_METHOD_PREFIXES;
-                    const rootTypeComposer = prefixQueryMethod.some(prefix => methodNameLowerCased.startsWith(prefix))
-                        ? this.schemaComposer.Query
-                        : this.schemaComposer.Mutation;
-                    rootTypeComposer.addFields({
-                        [rootFieldName]: {
-                            ...fieldConfig,
-                            resolve: (_, args, context) => addMetaDataToCall(client[methodName].bind(client), args.input, context, this.config.metaData),
-                        },
-                    });
-                }
+                const methodNameLowerCased = methodName.toLowerCase();
+                const prefixQueryMethod = this.config.prefixQueryMethod || QUERY_METHOD_PREFIXES;
+                const rootTypeComposer = prefixQueryMethod.some(prefix => methodNameLowerCased.startsWith(prefix))
+                    ? this.schemaComposer.Query
+                    : this.schemaComposer.Mutation;
+                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),
+                    },
+                });
             }
             const connectivityStateFieldName = pathWithName.join('_') + '_connectivityState';
             this.schemaComposer.Query.addFields({
@@ -521,14 +418,26 @@ ${rootJsonAndDecodedDescriptorSets
         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, decodedDescriptorSet } of artifacts) {
+        for (const { name, rootJson } of artifacts) {
             const rootLogger = this.logger.child(name);
             rootLogger.debug(`Creating package definition from file descriptor set object`);
-            const packageDefinition = loadFileDescriptorSetFromObject(decodedDescriptorSet);
+            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 });
+            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));
@@ -539,5 +448,3 @@ ${rootJsonAndDecodedDescriptorSets
         };
     }
 }
-
-export default GrpcHandler;

package/esm/patchLongJs.js

@@ -0,0 +1,11 @@
+import Long from 'long';
+function patchLongJs() {
+    const originalLongFromValue = Long.fromValue.bind(Long);
+    Long.fromValue = (value) => {
+        if (typeof value === 'bigint') {
+            return Long.fromValue(value.toString());
+        }
+        return originalLongFromValue(value);
+    };
+}
+patchLongJs();

package/esm/scalars.js

@@ -0,0 +1,27 @@
+const SCALARS = new Map([
+    ['bool', 'Boolean'],
+    ['bytes', 'Byte'],
+    ['double', 'Float'],
+    ['fixed32', 'Int'],
+    ['fixed64', 'BigInt'],
+    ['float', 'Float'],
+    ['int32', 'Int'],
+    ['int64', 'BigInt'],
+    ['sfixed32', 'Int'],
+    ['sfixed64', 'BigInt'],
+    ['sint32', 'Int'],
+    ['sint64', 'BigInt'],
+    ['string', 'String'],
+    ['uint32', 'UnsignedInt'],
+    ['uint64', 'BigInt'], // A new scalar might be needed
+]);
+export function isScalarType(type) {
+    return SCALARS.has(type);
+}
+export function getGraphQLScalar(scalarType) {
+    const gqlScalar = SCALARS.get(scalarType);
+    if (!gqlScalar) {
+        throw new Error(`Could not find GraphQL Scalar for type ${scalarType}`);
+    }
+    return SCALARS.get(scalarType);
+}

package/esm/utils.js

@@ -0,0 +1,89 @@
+import lodashGet from 'lodash.get';
+import { fs, path as pathModule } from '@graphql-mesh/cross-helpers';
+import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { withCancel } from '@graphql-mesh/utils';
+import { Metadata, } from '@grpc/grpc-js';
+import { getGraphQLScalar, isScalarType } from './scalars.js';
+export function getTypeName(schemaComposer, pathWithName, isInput) {
+    if (pathWithName === null || pathWithName === void 0 ? void 0 : pathWithName.length) {
+        const baseTypeName = pathWithName.filter(Boolean).join('_');
+        if (isScalarType(baseTypeName)) {
+            return getGraphQLScalar(baseTypeName);
+        }
+        if (schemaComposer.isEnumType(baseTypeName)) {
+            return baseTypeName;
+        }
+        return isInput ? baseTypeName + '_Input' : baseTypeName;
+    }
+    return 'Void';
+}
+export function addIncludePathResolver(root, includePaths) {
+    const originalResolvePath = root.resolvePath;
+    root.resolvePath = (origin, target) => {
+        if (pathModule.isAbsolute(target)) {
+            return target;
+        }
+        for (const directory of includePaths) {
+            const fullPath = pathModule.join(directory, target);
+            if (fs.existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+        const path = originalResolvePath(origin, target);
+        if (path === null) {
+            console.warn(`${target} not found in any of the include paths ${includePaths}`);
+        }
+        return path;
+    };
+}
+function isBlob(input) {
+    return input != null && input.stream instanceof Function;
+}
+export function addMetaDataToCall(callFn, input, resolverData, metaData, isResponseStream = false) {
+    const callFnArguments = [];
+    if (!isBlob(input)) {
+        callFnArguments.push(input);
+    }
+    if (metaData) {
+        const meta = new Metadata();
+        for (const [key, value] of Object.entries(metaData)) {
+            let metaValue = value;
+            if (Array.isArray(value)) {
+                // Extract data from context
+                metaValue = lodashGet(resolverData.context, value);
+            }
+            // Ensure that the metadata is compatible with what node-grpc expects
+            if (typeof metaValue !== 'string' && !(metaValue instanceof Buffer)) {
+                metaValue = JSON.stringify(metaValue);
+            }
+            if (typeof metaValue === 'string') {
+                metaValue = stringInterpolator.parse(metaValue, resolverData);
+            }
+            meta.add(key, metaValue);
+        }
+        callFnArguments.push(meta);
+    }
+    return new Promise((resolve, reject) => {
+        const call = callFn(...callFnArguments, (error, response) => {
+            if (error) {
+                reject(error);
+            }
+            resolve(response);
+        });
+        if (isResponseStream) {
+            let isCancelled = false;
+            const responseStreamWithCancel = withCancel(call, () => {
+                var _a;
+                if (!isCancelled) {
+                    (_a = call.call) === null || _a === void 0 ? void 0 : _a.cancelWithStatus(0, 'Cancelled by GraphQL Mesh');
+                    isCancelled = true;
+                }
+            });
+            resolve(responseStreamWithCancel);
+            if (isBlob(input)) {
+                const blobStream = input.stream();
+                blobStream.pipe(call);
+            }
+        }
+    });
+}