@omnigraph/grpc 0.0.0

package/cjs/directives.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grpcRootJsonDirective = exports.EnumDirective = exports.grpcConnectivityStateDirective = exports.grpcMethodDirective = void 0;
+const graphql_1 = require("graphql");
+const transport_common_1 = require("@graphql-mesh/transport-common");
+exports.grpcMethodDirective = new graphql_1.GraphQLDirective({
+    name: 'grpcMethod',
+    locations: [graphql_1.DirectiveLocation.FIELD_DEFINITION],
+    args: {
+        subgraph: {
+            type: graphql_1.GraphQLString,
+        },
+        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: {
+        subgraph: {
+            type: graphql_1.GraphQLString,
+        },
+        rootJsonName: {
+            type: graphql_1.GraphQLString,
+        },
+        objPath: {
+            type: graphql_1.GraphQLString,
+        },
+    },
+});
+exports.EnumDirective = new graphql_1.GraphQLDirective({
+    name: 'enum',
+    locations: [graphql_1.DirectiveLocation.ENUM_VALUE],
+    args: {
+        subgraph: {
+            type: graphql_1.GraphQLString,
+        },
+        value: {
+            type: graphql_1.GraphQLString,
+        },
+    },
+});
+exports.grpcRootJsonDirective = new graphql_1.GraphQLDirective({
+    name: 'grpcRootJson',
+    locations: [graphql_1.DirectiveLocation.OBJECT],
+    args: {
+        subgraph: {
+            type: graphql_1.GraphQLString,
+        },
+        name: {
+            type: graphql_1.GraphQLString,
+        },
+        rootJson: {
+            type: transport_common_1.ObjMapScalar,
+        },
+        loadOptions: {
+            type: transport_common_1.ObjMapScalar,
+        },
+    },
+    isRepeatable: true,
+});

package/cjs/gRPCLoader.js

@@ -0,0 +1,465 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gRPCLoader = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const graphql_compose_1 = require("graphql-compose");
+const graphql_scalars_1 = require("graphql-scalars");
+const directives_js_1 = require("./directives.js");
+const grpc_js_1 = require("@grpc/grpc-js");
+const protobufjs_1 = tslib_1.__importDefault(require("protobufjs"));
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const node_path_1 = require("node:path");
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const utils_js_1 = require("./utils.js");
+const utils_1 = require("@graphql-tools/utils");
+const index_js_1 = tslib_1.__importDefault(require("protobufjs/ext/descriptor/index.js"));
+const grpc_reflection_js_1 = require("@ardatan/grpc-reflection-js");
+const disposablestack_1 = require("@whatwg-node/disposablestack");
+const { Root } = protobufjs_1.default;
+const QUERY_METHOD_PREFIXES = ['get', 'list', 'search'];
+class gRPCLoader {
+    constructor(subgraphName, baseDir, logger, config) {
+        this.subgraphName = subgraphName;
+        this.baseDir = baseDir;
+        this.logger = logger;
+        this.config = config;
+        this.schemaComposer = new graphql_compose_1.SchemaComposer();
+        this.asyncDisposableStack = new disposablestack_1.AsyncDisposableStack;
+    }
+    [Symbol.asyncDispose]() {
+        return this.asyncDisposableStack.disposeAsync();
+    }
+    async buildSchema() {
+        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.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 descriptorSets = await this.getDescriptorSets(creds);
+        const directives = [];
+        for (const { name: rootJsonName, rootJson } of descriptorSets) {
+            const rootLogger = this.logger.child(rootJsonName);
+            this.logger.debug(`Building the schema structure based on the root object`);
+            this.visit({
+                nested: rootJson,
+                name: '',
+                currentPath: [],
+                rootJsonName,
+                rootJson,
+                rootLogger,
+            });
+            this.schemaComposer.addDirective(directives_js_1.grpcRootJsonDirective);
+            directives.push({
+                name: 'grpcRootJson',
+                args: {
+                    subgraph: this.subgraphName,
+                    name: rootJsonName,
+                    rootJson,
+                },
+            });
+        }
+        this.schemaComposer.Query.setDirectives(directives);
+        // graphql-compose doesn't add @defer and @stream to the schema
+        graphql_1.specifiedDirectives.forEach(directive => this.schemaComposer.addDirective(directive));
+        if (!this.schemaComposer.hasDirective('stream')) {
+            this.schemaComposer.addDirective(utils_1.GraphQLStreamDirective);
+        }
+        this.logger.debug(`Building the final GraphQL Schema`);
+        const schema = this.schemaComposer.buildSchema();
+        const schemaExtensions = schema.extensions = schema.extensions || {};
+        const directiveExtensions = schemaExtensions.directives = schemaExtensions.directives || {};
+        directiveExtensions.transport = {
+            subgraph: this.subgraphName,
+            kind: 'grpc',
+            location: this.config.endpoint,
+            options: {
+                requestTimeout: this.config.requestTimeout,
+                credentialsSsl: this.config.credentialsSsl,
+                useHTTPS: this.config.useHTTPS,
+                metaData: this.config.metaData,
+            },
+        };
+        return schema;
+    }
+    processReflection(creds) {
+        this.logger.debug(`Using the reflection`);
+        const reflectionEndpoint = string_interpolation_1.stringInterpolator.parse(this.config.endpoint, { env: process.env });
+        this.logger.debug(`Creating gRPC Reflection Client`);
+        const reflectionClient = new grpc_reflection_js_1.Client(reflectionEndpoint, creds);
+        this.asyncDisposableStack.defer(() => reflectionClient.grpcClient.close());
+        return reflectionClient.listServices().then(services => (services.filter(service => service && !service?.startsWith('grpc.'))
+            .map(service => {
+            this.logger.debug(`Resolving root of Service: ${service} from the reflection response`);
+            return reflectionClient.fileContainingSymbol(service);
+        })));
+    }
+    async processDescriptorFile() {
+        let fileName;
+        let options;
+        if (typeof this.config.source === 'object') {
+            fileName = this.config.source.file;
+            options = {
+                ...this.config.source.load,
+                includeDirs: this.config.source.load.includeDirs?.map(includeDir => (0, node_path_1.isAbsolute)(includeDir) ? includeDir : (0, node_path_1.join)(this.baseDir, includeDir)),
+            };
+        }
+        else {
+            fileName = this.config.source;
+        }
+        fileName = string_interpolation_1.stringInterpolator.parse(fileName, { env: process.env });
+        const absoluteFilePath = (0, node_path_1.isAbsolute)(fileName)
+            ? fileName
+            : (0, node_path_1.join)(this.baseDir, fileName);
+        this.logger.debug(`Using the descriptor set from ${absoluteFilePath} `);
+        const descriptorSetBuffer = await cross_helpers_1.fs.promises.readFile(absoluteFilePath);
+        this.logger.debug(`Reading ${absoluteFilePath} `);
+        let decodedDescriptorSet;
+        if (absoluteFilePath.endsWith('json')) {
+            this.logger.debug(`Parsing ${absoluteFilePath} as json`);
+            const descriptorSetJSON = JSON.parse(descriptorSetBuffer.toString());
+            decodedDescriptorSet = index_js_1.default.FileDescriptorSet.fromObject(descriptorSetJSON);
+        }
+        else {
+            decodedDescriptorSet = index_js_1.default.FileDescriptorSet.decode(descriptorSetBuffer);
+        }
+        this.logger.debug(`Creating root from descriptor set`);
+        const rootFromDescriptor = Root.fromDescriptor(decodedDescriptorSet);
+        if (options.includeDirs) {
+            if (!Array.isArray(options.includeDirs)) {
+                return Promise.reject(new Error('The includeDirs option must be an array'));
+            }
+            (0, utils_js_1.addIncludePathResolver)(rootFromDescriptor, options.includeDirs);
+        }
+        return rootFromDescriptor;
+    }
+    async processProtoFile() {
+        this.logger.debug(`Using proto file(s)`);
+        let protoRoot = new Root();
+        let fileGlob;
+        let options = {
+            keepCase: true,
+            alternateCommentMode: true,
+        };
+        if (typeof this.config.source === 'object') {
+            fileGlob = this.config.source.file;
+            options = {
+                ...options,
+                ...this.config.source.load,
+                includeDirs: this.config.source.load?.includeDirs?.map(includeDir => (0, node_path_1.isAbsolute)(includeDir) ? includeDir : (0, node_path_1.join)(this.baseDir, includeDir)),
+            };
+            if (options.includeDirs) {
+                if (!Array.isArray(options.includeDirs)) {
+                    throw new Error('The includeDirs option must be an array');
+                }
+                (0, utils_js_1.addIncludePathResolver)(protoRoot, options.includeDirs);
+            }
+        }
+        else {
+            fileGlob = this.config.source;
+        }
+        fileGlob = string_interpolation_1.stringInterpolator.parse(fileGlob, { env: process.env });
+        const fileNames = await (0, globby_1.default)(fileGlob, {
+            cwd: this.baseDir,
+        });
+        this.logger.debug(`Loading proto files(${fileGlob}); \n ${fileNames.join('\n')} `);
+        protoRoot = await protoRoot.load(fileNames.map(filePath => (0, node_path_1.isAbsolute)(filePath) ? filePath : (0, node_path_1.join)(this.baseDir, filePath)), options);
+        this.logger.debug(`Adding proto content to the root`);
+        return protoRoot;
+    }
+    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 if (filePath.endsWith('proto')) {
+                rootPromises.push(this.processProtoFile());
+            }
+        }
+        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,
+                }),
+            };
+        }));
+    }
+    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 = (0, node_path_1.isAbsolute)(this.config.credentialsSsl.privateKey)
+                ? this.config.credentialsSsl.privateKey
+                : (0, node_path_1.join)(this.baseDir, this.config.credentialsSsl.privateKey);
+            const absoluteCertChainPath = (0, node_path_1.isAbsolute)(this.config.credentialsSsl.certChain)
+                ? this.config.credentialsSsl.certChain
+                : (0, node_path_1.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 = (0, node_path_1.isAbsolute)(this.config.credentialsSsl.rootCA)
+                    ? this.config.credentialsSsl.rootCA
+                    : (0, node_path_1.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();
+    }
+    visit({ nested, name, currentPath, rootJsonName, rootJson, rootLogger: logger, }) {
+        const pathWithName = [...currentPath, ...name.split('.')].filter(Boolean);
+        if ('nested' in nested) {
+            for (const key in nested.nested) {
+                logger.debug(`Visiting ${currentPath}.nested[${key}]`);
+                const currentNested = nested.nested[key];
+                this.visit({
+                    nested: currentNested,
+                    name: key,
+                    currentPath: pathWithName,
+                    rootJsonName,
+                    rootJson,
+                    rootLogger: logger,
+                });
+            }
+        }
+        const typeName = pathWithName.join('__');
+        if ('values' in nested) {
+            const enumValues = {};
+            const commentMap = nested.comments;
+            for (const [key, value] of Object.entries(nested.values)) {
+                logger.debug(`Visiting ${currentPath}.nested.values[${key}]`);
+                enumValues[key] = {
+                    directives: [
+                        {
+                            name: 'enum',
+                            args: {
+                                subgraph: this.subgraphName,
+                                value: JSON.stringify(value),
+                            },
+                        },
+                    ],
+                    description: commentMap?.[key],
+                };
+            }
+            this.schemaComposer.addDirective(directives_js_1.EnumDirective);
+            this.schemaComposer.createEnumTC({
+                name: typeName,
+                values: enumValues,
+                description: nested.comment,
+            });
+        }
+        else if ('fields' in nested) {
+            const inputTypeName = typeName + '_Input';
+            const outputTypeName = typeName;
+            const description = nested.comment;
+            const fieldEntries = Object.entries(nested.fields);
+            if (fieldEntries.length) {
+                const inputTC = this.schemaComposer.createInputTC({
+                    name: inputTypeName,
+                    description,
+                    fields: {},
+                });
+                const outputTC = this.schemaComposer.createObjectTC({
+                    name: outputTypeName,
+                    description,
+                    fields: {},
+                });
+                for (const [fieldName, { type, rule, comment, keyType }] of fieldEntries) {
+                    logger.debug(`Visiting ${currentPath}.nested.fields[${fieldName}]`);
+                    const baseFieldTypePath = type.split('.');
+                    inputTC.addFields({
+                        [fieldName]: {
+                            type: () => {
+                                let fieldInputTypeName;
+                                if (keyType) {
+                                    fieldInputTypeName = 'JSON';
+                                }
+                                else {
+                                    const fieldTypePath = (0, utils_js_1.walkToFindTypePath)(rootJson, pathWithName, baseFieldTypePath);
+                                    fieldInputTypeName = (0, utils_js_1.getTypeName)(this.schemaComposer, fieldTypePath, true);
+                                }
+                                return rule === 'repeated' ? `[${fieldInputTypeName}]` : fieldInputTypeName;
+                            },
+                            description: comment,
+                        },
+                    });
+                    outputTC.addFields({
+                        [fieldName]: {
+                            type: () => {
+                                let fieldTypeName;
+                                if (keyType) {
+                                    fieldTypeName = 'JSON';
+                                }
+                                else {
+                                    const fieldTypePath = (0, utils_js_1.walkToFindTypePath)(rootJson, pathWithName, baseFieldTypePath);
+                                    fieldTypeName = (0, utils_js_1.getTypeName)(this.schemaComposer, fieldTypePath, false);
+                                }
+                                return rule === 'repeated' ? `[${fieldTypeName}]` : fieldTypeName;
+                            },
+                            description: comment,
+                        },
+                    });
+                }
+            }
+            else {
+                this.schemaComposer.createScalarTC({
+                    ...graphql_scalars_1.GraphQLJSON.toConfig(),
+                    name: inputTypeName,
+                    description,
+                });
+                this.schemaComposer.createScalarTC({
+                    ...graphql_scalars_1.GraphQLJSON.toConfig(),
+                    name: outputTypeName,
+                    description,
+                });
+            }
+        }
+        else if ('methods' in nested) {
+            const objPath = pathWithName.join('.');
+            for (const methodName in nested.methods) {
+                const method = nested.methods[methodName];
+                const rootFieldName = [...pathWithName, methodName].join('_');
+                const fieldConfigTypeFactory = () => {
+                    const baseResponseTypePath = method.responseType?.split('.');
+                    if (baseResponseTypePath) {
+                        const responseTypePath = (0, utils_js_1.walkToFindTypePath)(rootJson, pathWithName, baseResponseTypePath);
+                        return (0, utils_js_1.getTypeName)(this.schemaComposer, responseTypePath, false);
+                    }
+                    return 'Void';
+                };
+                const fieldConfig = {
+                    type: () => {
+                        const typeName = fieldConfigTypeFactory();
+                        if (method.responseStream) {
+                            return `[${typeName}]`;
+                        }
+                        return typeName;
+                    },
+                    description: method.comment,
+                };
+                const fieldConfigArgs = {
+                    input: () => {
+                        if (method.requestStream) {
+                            return 'File';
+                        }
+                        const baseRequestTypePath = method.requestType?.split('.');
+                        if (baseRequestTypePath) {
+                            const requestTypePath = (0, utils_js_1.walkToFindTypePath)(rootJson, pathWithName, baseRequestTypePath);
+                            const requestTypeName = (0, utils_js_1.getTypeName)(this.schemaComposer, requestTypePath, true);
+                            return requestTypeName;
+                        }
+                        return undefined;
+                    },
+                };
+                fieldConfig.args = fieldConfigArgs;
+                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;
+                this.schemaComposer.addDirective(directives_js_1.grpcMethodDirective);
+                rootTypeComposer.addFields({
+                    [rootFieldName]: {
+                        ...fieldConfig,
+                        directives: [
+                            {
+                                name: 'grpcMethod',
+                                args: {
+                                    subgraph: this.subgraphName,
+                                    rootJsonName,
+                                    objPath,
+                                    methodName,
+                                    responseStream: !!method.responseStream,
+                                },
+                            },
+                        ],
+                    },
+                });
+                if (method.responseStream) {
+                    this.schemaComposer.Subscription.addFields({
+                        [rootFieldName]: {
+                            args: fieldConfigArgs,
+                            description: method.comment,
+                            type: fieldConfigTypeFactory,
+                            directives: [
+                                {
+                                    name: 'grpcMethod',
+                                    args: {
+                                        subgraph: this.subgraphName,
+                                        rootJsonName,
+                                        objPath,
+                                        methodName,
+                                        responseStream: true,
+                                    },
+                                },
+                            ],
+                        },
+                    });
+                }
+            }
+            const connectivityStateFieldName = pathWithName.join('_') + '_connectivityState';
+            this.schemaComposer.addDirective(directives_js_1.grpcConnectivityStateDirective);
+            this.schemaComposer.Query.addFields({
+                [connectivityStateFieldName]: {
+                    type: 'ConnectivityState',
+                    args: {
+                        tryToConnect: {
+                            type: 'Boolean',
+                        },
+                    },
+                    directives: [
+                        {
+                            name: 'grpcConnectivityState',
+                            args: {
+                                subgraph: this.subgraphName,
+                                rootJsonName,
+                                objPath,
+                            },
+                        },
+                    ],
+                },
+            });
+        }
+    }
+}
+exports.gRPCLoader = gRPCLoader;

package/cjs/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGrpcSubgraph = loadGrpcSubgraph;
+const gRPCLoader_1 = require("./gRPCLoader");
+function loadGrpcSubgraph(name, options) {
+    return (ctx) => ({
+        name,
+        schema$: new gRPCLoader_1.gRPCLoader(name, ctx.cwd, ctx.logger, options).buildSchema(),
+    });
+}

package/cjs/package.json

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

package/cjs/scalars.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGrpcScalar = isGrpcScalar;
+exports.getGraphQLScalarForGrpc = getGraphQLScalarForGrpc;
+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 isGrpcScalar(type) {
+    return SCALARS.has(type);
+}
+function getGraphQLScalarForGrpc(scalarType) {
+    const gqlScalar = SCALARS.get(scalarType);
+    if (!gqlScalar) {
+        throw new Error(`Could not find GraphQL Scalar for type ${scalarType}`);
+    }
+    return SCALARS.get(scalarType);
+}

package/cjs/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addIncludePathResolver = addIncludePathResolver;
+exports.getTypeName = getTypeName;
+exports.walkToFindTypePath = walkToFindTypePath;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const scalars_js_1 = require("./scalars.js");
+const lodash_has_1 = tslib_1.__importDefault(require("lodash.has"));
+function addIncludePathResolver(root, includePaths) {
+    const originalResolvePath = root.resolvePath;
+    root.resolvePath = (origin, target) => {
+        if ((0, path_1.isAbsolute)(target)) {
+            return target;
+        }
+        for (const directory of includePaths) {
+            const fullPath = (0, path_1.join)(directory, target);
+            if ((0, fs_1.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 getTypeName(schemaComposer, pathWithName, isInput) {
+    if (pathWithName?.length) {
+        const baseTypeName = pathWithName.filter(Boolean).join('__');
+        if ((0, scalars_js_1.isGrpcScalar)(baseTypeName)) {
+            return (0, scalars_js_1.getGraphQLScalarForGrpc)(baseTypeName);
+        }
+        if (schemaComposer.isEnumType(baseTypeName)) {
+            return baseTypeName;
+        }
+        return isInput ? baseTypeName + '_Input' : baseTypeName;
+    }
+    return 'Void';
+}
+function walkToFindTypePath(rootJson, pathWithName, baseTypePath) {
+    const currentWalkingPath = [...pathWithName];
+    while (!(0, lodash_has_1.default)(rootJson.nested, currentWalkingPath.concat(baseTypePath).join('.nested.'))) {
+        if (!currentWalkingPath.length) {
+            break;
+        }
+        currentWalkingPath.pop();
+    }
+    return currentWalkingPath.concat(baseTypePath);
+}