@graphql-mesh/transport-grpc 0.0.0

package/cjs/index.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gRPCTransport = void 0;
+const tslib_1 = require("tslib");
+const transport_common_1 = require("@graphql-mesh/transport-common");
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const grpc_js_1 = require("@grpc/grpc-js");
+const proto_loader_1 = require("@grpc/proto-loader");
+const lodash_get_1 = tslib_1.__importDefault(require("lodash.get"));
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const disposablestack_1 = require("@whatwg-node/disposablestack");
+const graphql_1 = require("graphql");
+const utils_js_1 = require("./utils.js");
+const graphql_scalars_1 = require("graphql-scalars");
+const utils_1 = require("@graphql-tools/utils");
+const utils_2 = require("@graphql-mesh/utils");
+require("./patchLongJs.js");
+class gRPCTransport extends disposablestack_1.DisposableStack {
+    constructor(baseDir, logger, endpoint, config) {
+        super();
+        this.baseDir = baseDir;
+        this.logger = logger;
+        this.endpoint = endpoint;
+        this.config = config;
+        this.grpcObjectByserviceClientByObjPath = new WeakMap();
+    }
+    getCredentials() {
+        this.logger.debug(`Getting channel credentials`);
+        if (this.config.credentialsSsl) {
+            this.logger.debug(() => `Using SSL Connection with credentials at ${this.config.credentialsSsl.privateKey} & ${this.config.credentialsSsl.certChain}`);
+            const absolutePrivateKeyPath = cross_helpers_1.path.isAbsolute(this.config.credentialsSsl.privateKey)
+                ? this.config.credentialsSsl.privateKey
+                : cross_helpers_1.path.join(this.baseDir, this.config.credentialsSsl.privateKey);
+            const absoluteCertChainPath = cross_helpers_1.path.isAbsolute(this.config.credentialsSsl.certChain)
+                ? this.config.credentialsSsl.certChain
+                : cross_helpers_1.path.join(this.baseDir, this.config.credentialsSsl.certChain);
+            const sslFiles = [
+                cross_helpers_1.fs.promises.readFile(absolutePrivateKeyPath),
+                cross_helpers_1.fs.promises.readFile(absoluteCertChainPath),
+            ];
+            if (this.config.credentialsSsl.rootCA !== 'rootCA') {
+                const absoluteRootCAPath = cross_helpers_1.path.isAbsolute(this.config.credentialsSsl.rootCA)
+                    ? this.config.credentialsSsl.rootCA
+                    : cross_helpers_1.path.join(this.baseDir, this.config.credentialsSsl.rootCA);
+                sslFiles.unshift(cross_helpers_1.fs.promises.readFile(absoluteRootCAPath));
+            }
+            return Promise.all(sslFiles).then(([rootCA, privateKey, certChain]) => grpc_js_1.credentials.createSsl(rootCA, privateKey, certChain));
+        }
+        else if (this.config.useHTTPS) {
+            this.logger.debug(`Using SSL Connection`);
+            return grpc_js_1.credentials.createSsl();
+        }
+        this.logger.debug(`Using insecure connection`);
+        return grpc_js_1.credentials.createInsecure();
+    }
+    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, }) {
+        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(string_interpolation_1.stringInterpolator.parse(this.endpoint, { env: cross_helpers_1.process.env }) ??
+                this.endpoint, creds);
+            this.defer(() => client.close());
+            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 schemaTypeMap = schema.getTypeMap();
+        for (const scalarTypeName in graphql_scalars_1.resolvers) {
+            if (scalarTypeName in schemaTypeMap) {
+                (0, utils_js_1.addExecutionLogicToScalar)(schemaTypeMap[scalarTypeName], graphql_scalars_1.resolvers[scalarTypeName]);
+            }
+        }
+        if ('ObjMap' in schemaTypeMap) {
+            (0, utils_js_1.addExecutionLogicToScalar)(schemaTypeMap.ObjMap, transport_common_1.ObjMapScalar);
+        }
+        const queryType = schema.getQueryType();
+        const rootJsonAnnotations = (0, utils_1.getDirective)(schema, queryType, 'grpcRootJson');
+        const rootJsonMap = new Map();
+        const grpcObjectByRootJsonName = new Map();
+        for (let { name, rootJson, loadOptions } of rootJsonAnnotations) {
+            rootJson = typeof rootJson === 'string' ? JSON.parse(rootJson) : rootJson;
+            rootJsonMap.set(name, rootJson);
+            const rootLogger = this.logger.child(name);
+            grpcObjectByRootJsonName.set(name, this.getGrpcObject({ rootJson, loadOptions, rootLogger }));
+        }
+        const rootTypes = (0, utils_1.getRootTypes)(schema);
+        for (const rootType of rootTypes) {
+            const rootTypeFields = rootType.getFields();
+            for (const fieldName in rootTypeFields) {
+                const field = rootTypeFields[fieldName];
+                const directives = (0, utils_1.getDirectives)(schema, field);
+                if (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,
+                                });
+                                if (rootType.name === 'Subscription') {
+                                    field.subscribe = this.getFieldResolver({
+                                        client,
+                                        methodName,
+                                        isResponseStream: responseStream,
+                                    });
+                                    field.resolve = function identityFn(root) {
+                                        console.log('geldi');
+                                        return root;
+                                    };
+                                }
+                                else {
+                                    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;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const typeMap = schema.getTypeMap();
+        for (const typeName in typeMap) {
+            const type = typeMap[typeName];
+            if ((0, graphql_1.isEnumType)(type)) {
+                const values = type.getValues();
+                for (const value of values) {
+                    const enumAnnotations = (0, utils_1.getDirective)(schema, value, 'enum');
+                    if (enumAnnotations?.length) {
+                        for (const enumAnnotation of enumAnnotations) {
+                            const enumSerializedValue = enumAnnotation.value;
+                            if (enumSerializedValue) {
+                                const serializedValue = JSON.parse(enumSerializedValue);
+                                value.value = serializedValue;
+                                let valueLookup = type._valueLookup;
+                                if (!valueLookup) {
+                                    valueLookup = new Map(type.getValues().map(enumValue => [enumValue.value, enumValue]));
+                                    type._valueLookup = valueLookup;
+                                }
+                                type._valueLookup.set(serializedValue, value);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+exports.gRPCTransport = gRPCTransport;
+exports.default = {
+    getSubgraphExecutor({ transportEntry, subgraph, cwd, logger }) {
+        const transport = new gRPCTransport(cwd, logger, transportEntry.location, transportEntry.options);
+        return (0, utils_2.mapMaybePromise)(transport.getCredentials(), creds => {
+            transport.processDirectives({ schema: subgraph, creds });
+            return (0, transport_common_1.createDefaultExecutor)(subgraph);
+        });
+    }
+};

package/cjs/package.json

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

package/cjs/patchLongJs.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const long_1 = tslib_1.__importDefault(require("long"));
+function patchLongJs() {
+    const originalLongFromValue = long_1.default.fromValue.bind(long_1.default);
+    long_1.default.fromValue = (value) => {
+        if (typeof value === 'bigint') {
+            return long_1.default.fromValue(value.toString());
+        }
+        return originalLongFromValue(value);
+    };
+}
+patchLongJs();

package/cjs/utils.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMetaDataToCall = addMetaDataToCall;
+exports.addExecutionLogicToScalar = addExecutionLogicToScalar;
+const tslib_1 = require("tslib");
+const lodash_get_1 = tslib_1.__importDefault(require("lodash.get"));
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-mesh/utils");
+const grpc_js_1 = require("@grpc/grpc-js");
+function isBlob(input) {
+    return input != null && input.stream instanceof Function;
+}
+function addMetaDataToCall(callFn, input, resolverData, metaData, isResponseStream = false) {
+    const callFnArguments = [];
+    if (!isBlob(input)) {
+        callFnArguments.push(input);
+    }
+    if (metaData) {
+        const meta = new grpc_js_1.Metadata();
+        for (const [key, value] of Object.entries(metaData)) {
+            let metaValue = value;
+            if (Array.isArray(value)) {
+                // Extract data from context
+                metaValue = (0, lodash_get_1.default)(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 = string_interpolation_1.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 = (0, utils_1.withCancel)(call, () => {
+                if (!isCancelled) {
+                    call.call?.cancelWithStatus(0, 'Cancelled by GraphQL Mesh');
+                    isCancelled = true;
+                }
+            });
+            resolve(responseStreamWithCancel);
+            if (isBlob(input)) {
+                const blobStream = input.stream();
+                blobStream.pipe(call);
+            }
+        }
+    });
+}
+function addExecutionLogicToScalar(nonExecutableScalar, actualScalar) {
+    Object.defineProperties(nonExecutableScalar, {
+        serialize: {
+            value: actualScalar.serialize,
+        },
+        parseValue: {
+            value: actualScalar.parseValue,
+        },
+        parseLiteral: {
+            value: actualScalar.parseLiteral,
+        },
+        extensions: {
+            value: {
+                ...actualScalar.extensions,
+                ...nonExecutableScalar.extensions,
+            },
+        },
+    });
+}

package/esm/index.js

@@ -0,0 +1,202 @@
+import { createDefaultExecutor, ObjMapScalar } from "@graphql-mesh/transport-common";
+import { path, fs, process } from '@graphql-mesh/cross-helpers';
+import { credentials, loadPackageDefinition } from '@grpc/grpc-js';
+import { fromJSON } from '@grpc/proto-loader';
+import lodashGet from 'lodash.get';
+import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { DisposableStack } from '@whatwg-node/disposablestack';
+import { isEnumType } from "graphql";
+import { addExecutionLogicToScalar, addMetaDataToCall } from "./utils.js";
+import { resolvers as scalarResolvers } from 'graphql-scalars';
+import { getDirective, getDirectives, getRootTypes } from '@graphql-tools/utils';
+import { mapMaybePromise } from "@graphql-mesh/utils";
+import './patchLongJs.js';
+export class gRPCTransport extends DisposableStack {
+    constructor(baseDir, logger, endpoint, config) {
+        super();
+        this.baseDir = baseDir;
+        this.logger = logger;
+        this.endpoint = endpoint;
+        this.config = config;
+        this.grpcObjectByserviceClientByObjPath = new WeakMap();
+    }
+    getCredentials() {
+        this.logger.debug(`Getting channel credentials`);
+        if (this.config.credentialsSsl) {
+            this.logger.debug(() => `Using SSL Connection with credentials at ${this.config.credentialsSsl.privateKey} & ${this.config.credentialsSsl.certChain}`);
+            const absolutePrivateKeyPath = path.isAbsolute(this.config.credentialsSsl.privateKey)
+                ? this.config.credentialsSsl.privateKey
+                : path.join(this.baseDir, this.config.credentialsSsl.privateKey);
+            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),
+            ];
+            if (this.config.credentialsSsl.rootCA !== 'rootCA') {
+                const absoluteRootCAPath = path.isAbsolute(this.config.credentialsSsl.rootCA)
+                    ? this.config.credentialsSsl.rootCA
+                    : path.join(this.baseDir, this.config.credentialsSsl.rootCA);
+                sslFiles.unshift(fs.promises.readFile(absoluteRootCAPath));
+            }
+            return Promise.all(sslFiles).then(([rootCA, privateKey, certChain]) => credentials.createSsl(rootCA, privateKey, certChain));
+        }
+        else if (this.config.useHTTPS) {
+            this.logger.debug(`Using SSL Connection`);
+            return credentials.createSsl();
+        }
+        this.logger.debug(`Using insecure connection`);
+        return credentials.createInsecure();
+    }
+    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, }) {
+        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(stringInterpolator.parse(this.endpoint, { env: process.env }) ??
+                this.endpoint, creds);
+            this.defer(() => client.close());
+            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 schemaTypeMap = schema.getTypeMap();
+        for (const scalarTypeName in scalarResolvers) {
+            if (scalarTypeName in schemaTypeMap) {
+                addExecutionLogicToScalar(schemaTypeMap[scalarTypeName], scalarResolvers[scalarTypeName]);
+            }
+        }
+        if ('ObjMap' in schemaTypeMap) {
+            addExecutionLogicToScalar(schemaTypeMap.ObjMap, ObjMapScalar);
+        }
+        const queryType = schema.getQueryType();
+        const rootJsonAnnotations = getDirective(schema, queryType, 'grpcRootJson');
+        const rootJsonMap = new Map();
+        const grpcObjectByRootJsonName = new Map();
+        for (let { name, rootJson, loadOptions } of rootJsonAnnotations) {
+            rootJson = typeof rootJson === 'string' ? JSON.parse(rootJson) : rootJson;
+            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) {
+            const rootTypeFields = rootType.getFields();
+            for (const fieldName in rootTypeFields) {
+                const field = rootTypeFields[fieldName];
+                const directives = getDirectives(schema, field);
+                if (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,
+                                });
+                                if (rootType.name === 'Subscription') {
+                                    field.subscribe = this.getFieldResolver({
+                                        client,
+                                        methodName,
+                                        isResponseStream: responseStream,
+                                    });
+                                    field.resolve = function identityFn(root) {
+                                        console.log('geldi');
+                                        return root;
+                                    };
+                                }
+                                else {
+                                    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;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const typeMap = schema.getTypeMap();
+        for (const typeName in typeMap) {
+            const type = typeMap[typeName];
+            if (isEnumType(type)) {
+                const values = type.getValues();
+                for (const value of values) {
+                    const enumAnnotations = getDirective(schema, value, 'enum');
+                    if (enumAnnotations?.length) {
+                        for (const enumAnnotation of enumAnnotations) {
+                            const enumSerializedValue = enumAnnotation.value;
+                            if (enumSerializedValue) {
+                                const serializedValue = JSON.parse(enumSerializedValue);
+                                value.value = serializedValue;
+                                let valueLookup = type._valueLookup;
+                                if (!valueLookup) {
+                                    valueLookup = new Map(type.getValues().map(enumValue => [enumValue.value, enumValue]));
+                                    type._valueLookup = valueLookup;
+                                }
+                                type._valueLookup.set(serializedValue, value);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+export default {
+    getSubgraphExecutor({ transportEntry, subgraph, cwd, logger }) {
+        const transport = new gRPCTransport(cwd, logger, transportEntry.location, transportEntry.options);
+        return mapMaybePromise(transport.getCredentials(), creds => {
+            transport.processDirectives({ schema: subgraph, creds });
+            return createDefaultExecutor(subgraph);
+        });
+    }
+};

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/utils.js

@@ -0,0 +1,73 @@
+import lodashGet from 'lodash.get';
+import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { withCancel } from '@graphql-mesh/utils';
+import { Metadata } from '@grpc/grpc-js';
+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, () => {
+                if (!isCancelled) {
+                    call.call?.cancelWithStatus(0, 'Cancelled by GraphQL Mesh');
+                    isCancelled = true;
+                }
+            });
+            resolve(responseStreamWithCancel);
+            if (isBlob(input)) {
+                const blobStream = input.stream();
+                blobStream.pipe(call);
+            }
+        }
+    });
+}
+export function addExecutionLogicToScalar(nonExecutableScalar, actualScalar) {
+    Object.defineProperties(nonExecutableScalar, {
+        serialize: {
+            value: actualScalar.serialize,
+        },
+        parseValue: {
+            value: actualScalar.parseValue,
+        },
+        parseLiteral: {
+            value: actualScalar.parseLiteral,
+        },
+        extensions: {
+            value: {
+                ...actualScalar.extensions,
+                ...nonExecutableScalar.extensions,
+            },
+        },
+    });
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@graphql-mesh/transport-grpc",
+  "version": "0.0.0",
+  "sideEffects": false,
+  "peerDependencies": {
+    "@graphql-mesh/types": "^0.102.10",
+    "@graphql-mesh/utils": "^0.102.10",
+    "@graphql-tools/utils": "^10.5.5",
+    "graphql": "*",
+    "tslib": "^2.4.0"
+  },
+  "dependencies": {
+    "@graphql-mesh/string-interpolation": "^0.5.6",
+    "@graphql-mesh/transport-common": "^0.7.11",
+    "@grpc/grpc-js": "^1.1.7",
+    "@grpc/proto-loader": "^0.7.8",
+    "@whatwg-node/disposablestack": "^0.0.5",
+    "graphql-scalars": "^1.22.4",
+    "lodash.get": "^4.4.2",
+    "protobufjs": "^7.2.5"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ardatan/graphql-mesh",
+    "directory": "packages/transports/grpc"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/typings/index.d.cts

@@ -0,0 +1,73 @@
+import type { Logger } from "@graphql-mesh/types";
+import type { ChannelCredentials } from '@grpc/grpc-js';
+import { loadPackageDefinition } from '@grpc/grpc-js';
+import type { ServiceClient } from '@grpc/grpc-js/build/src/make-client.cjs';
+import protobufjs from 'protobufjs';
+import { DisposableStack } from '@whatwg-node/disposablestack';
+import { type GraphQLFieldResolver, type GraphQLSchema } from "graphql";
+import { type MaybePromise } from '@graphql-tools/utils';
+import './patchLongJs.cjs';
+/**
+ * SSL Credentials
+ */
+interface GrpcCredentialsSsl {
+    rootCA?: string;
+    certChain?: string;
+    privateKey?: string;
+}
+export interface gRPCTransportOptions {
+    /**
+     * Request timeout in milliseconds
+     * Default: 200000
+     */
+    requestTimeout?: number;
+    credentialsSsl?: GrpcCredentialsSsl;
+    /**
+     * Use https instead of http for gRPC connection
+     */
+    useHTTPS?: boolean;
+    /**
+     * MetaData
+     */
+    metaData?: {
+        [k: string]: any;
+    };
+}
+interface LoadOptions {
+    includeDirs?: string[];
+}
+export declare class gRPCTransport extends DisposableStack {
+    private baseDir;
+    private logger;
+    private endpoint;
+    private config;
+    constructor(baseDir: string, logger: Logger, endpoint: string, config: gRPCTransportOptions);
+    getCredentials(): MaybePromise<ChannelCredentials>;
+    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;
+}
+declare const _default: {
+    getSubgraphExecutor({ transportEntry, subgraph, cwd, logger }: import("@graphql-mesh/transport-common").TransportGetSubgraphExecutorOptions<gRPCTransportOptions>): MaybePromise<import("@graphql-mesh/transport-common").Executor>;
+};
+export default _default;

package/typings/index.d.ts

@@ -0,0 +1,73 @@
+import type { Logger } from "@graphql-mesh/types";
+import type { ChannelCredentials } from '@grpc/grpc-js';
+import { loadPackageDefinition } from '@grpc/grpc-js';
+import type { ServiceClient } from '@grpc/grpc-js/build/src/make-client.js';
+import protobufjs from 'protobufjs';
+import { DisposableStack } from '@whatwg-node/disposablestack';
+import { type GraphQLFieldResolver, type GraphQLSchema } from "graphql";
+import { type MaybePromise } from '@graphql-tools/utils';
+import './patchLongJs.js';
+/**
+ * SSL Credentials
+ */
+interface GrpcCredentialsSsl {
+    rootCA?: string;
+    certChain?: string;
+    privateKey?: string;
+}
+export interface gRPCTransportOptions {
+    /**
+     * Request timeout in milliseconds
+     * Default: 200000
+     */
+    requestTimeout?: number;
+    credentialsSsl?: GrpcCredentialsSsl;
+    /**
+     * Use https instead of http for gRPC connection
+     */
+    useHTTPS?: boolean;
+    /**
+     * MetaData
+     */
+    metaData?: {
+        [k: string]: any;
+    };
+}
+interface LoadOptions {
+    includeDirs?: string[];
+}
+export declare class gRPCTransport extends DisposableStack {
+    private baseDir;
+    private logger;
+    private endpoint;
+    private config;
+    constructor(baseDir: string, logger: Logger, endpoint: string, config: gRPCTransportOptions);
+    getCredentials(): MaybePromise<ChannelCredentials>;
+    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;
+}
+declare const _default: {
+    getSubgraphExecutor({ transportEntry, subgraph, cwd, logger }: import("@graphql-mesh/transport-common").TransportGetSubgraphExecutorOptions<gRPCTransportOptions>): MaybePromise<import("@graphql-mesh/transport-common").Executor>;
+};
+export default _default;

package/typings/patchLongJs.d.cts

@@ -0,0 +1 @@
+export {};

package/typings/patchLongJs.d.ts

@@ -0,0 +1 @@
+export {};

package/typings/utils.d.cts

@@ -0,0 +1,4 @@
+import type { ResolverData } from '@graphql-mesh/string-interpolation';
+import type { GraphQLScalarType } from 'graphql';
+export declare function addMetaDataToCall(callFn: any, input: any, resolverData: ResolverData, metaData: Record<string, string | string[] | Buffer>, isResponseStream?: boolean): Promise<unknown>;
+export declare function addExecutionLogicToScalar(nonExecutableScalar: GraphQLScalarType, actualScalar: GraphQLScalarType): void;

package/typings/utils.d.ts

@@ -0,0 +1,4 @@
+import type { ResolverData } from '@graphql-mesh/string-interpolation';
+import type { GraphQLScalarType } from 'graphql';
+export declare function addMetaDataToCall(callFn: any, input: any, resolverData: ResolverData, metaData: Record<string, string | string[] | Buffer>, isResponseStream?: boolean): Promise<unknown>;
+export declare function addExecutionLogicToScalar(nonExecutableScalar: GraphQLScalarType, actualScalar: GraphQLScalarType): void;