@hyperweb/telescope 1.15.0

package/main/generators/create-rpc-ops-bundle.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const build_1 = require("../build");
+const files_1 = require("../utils/files");
+const utils_1 = require("../utils");
+const dotty = __importStar(require("dotty"));
+const proto_parser_1 = require("@cosmology/proto-parser");
+const utils_2 = require("@cosmology/utils");
+const utils_3 = require("@cosmology/utils");
+const utils_4 = require("@cosmology/utils");
+const utils_5 = require("@cosmology/utils");
+const plugin = (builder) => {
+    if (!builder.options.rpcClients?.enabled ||
+        !builder.options.rpcClients?.instantOps?.length) {
+        return;
+    }
+    const localname = "service-ops.ts";
+    // get mapping of packages and rpc query filenames.
+    // create proto ref for context
+    const pkg = "@root";
+    const ref = (0, proto_parser_1.createEmptyProtoRef)(pkg, localname);
+    // create context
+    const context = new build_1.TelescopeParseContext(ref, builder.store, builder.options);
+    const pkgImports = [];
+    const ast = builder.options.rpcClients.instantOps.reduce((ast, instantOpsConfig) => {
+        const bundlerFiles = builder.stateManagers[`instantRpc_${instantOpsConfig.className}`];
+        if (!bundlerFiles || !bundlerFiles.length) {
+            return ast;
+        }
+        let nameMapping = instantOpsConfig.nameMapping;
+        return ast.concat(createRpcOpsAst(context, instantOpsConfig.className, pkgImports, nameMapping, bundlerFiles));
+    }, []);
+    // generate imports added by context.addUtil
+    const imports = (0, utils_1.fixlocalpaths)((0, imports_1.aggregateImports)(context, {}, localname));
+    const importStmts = (0, imports_1.getImportStatements)(localname, imports, builder.options);
+    // construct the AST
+    const prog = [].concat(importStmts).concat((0, utils_5.buildImports)(pkgImports)).concat(ast);
+    // write the file.
+    const filename = (0, path_1.join)(builder.outPath, localname);
+    builder.files.push(localname);
+    (0, files_1.writeAstToFile)(builder.outPath, builder.options, prog, filename);
+};
+exports.plugin = plugin;
+// bundlerFiles.filter(file => file.localname.indexOf("rpc.msg") !== -1)
+function createRpcOpsAst(context, className, pkgImports, nameMapping, bundlerFiles) {
+    const extendInterfaces = [];
+    const instantMapping = {};
+    const camelRpcMethods = context.generic.pluginValue("rpcClients.camelCase");
+    let txNameMapping = {
+        ...(0, utils_4.swapKeyValue)(nameMapping?.All ?? {}),
+        ...(0, utils_4.swapKeyValue)(nameMapping?.Msg ?? {})
+    };
+    let queryNameMapping = {
+        ...(0, utils_4.swapKeyValue)(nameMapping?.All ?? {}),
+        ...(0, utils_4.swapKeyValue)(nameMapping?.Query ?? {})
+    };
+    bundlerFiles.forEach((bundlerFile) => {
+        const isMsg = bundlerFile.isMsg;
+        const currentNameMapping = isMsg ? txNameMapping : queryNameMapping;
+        const path = `./${bundlerFile.localname.replace(/\.ts$/, "")}`;
+        const importedVarName = (0, utils_3.variableSlug)(path);
+        if (pkgImports &&
+            !pkgImports.some((item) => item.importedAs === importedVarName)) {
+            pkgImports.push({
+                type: "typeImport",
+                name: importedVarName,
+                import: path,
+                importedAs: importedVarName,
+            });
+        }
+        extendInterfaces.push({
+            importedVarName: importedVarName,
+            interfaceName: className,
+        });
+        bundlerFile.instantExportedMethods?.forEach((method) => {
+            const methodName = camelRpcMethods ? (0, utils_2.camel)(method.name) : method.name;
+            const nameWithPkg = `${bundlerFile.package}.${methodName}`;
+            const methodAlias = currentNameMapping && currentNameMapping[nameWithPkg]
+                ? currentNameMapping[nameWithPkg]
+                : methodName;
+            dotty.put(instantMapping, methodAlias, {
+                methodName,
+                importedVarName,
+                isMsg
+            });
+        });
+    });
+    return [
+        (0, ast_1.createInstantRpcInterface)(className, extendInterfaces),
+        (0, ast_1.createInstantRpcClass)(context.generic, className, instantMapping),
+    ];
+}

package/main/generators/create-rpc-query-client-all.js

@@ -0,0 +1,137 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const dotty = __importStar(require("dotty"));
+const proto_parser_1 = require("@cosmology/proto-parser");
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const utils_1 = require("../utils");
+const build_1 = require("../build");
+const imports_1 = require("../imports");
+const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.rpcClients?.enabled) {
+        return;
+    }
+    if (builder.options?.rpcClients?.inline) {
+        return;
+    }
+    // if no scopes, do them all!
+    if (!builder.options.rpcClients.scoped ||
+        !builder.options.rpcClients.scoped.length ||
+        !builder.options.rpcClients.scopedIsExclusive) {
+        return makeAllRPCBundles(builder, bundler);
+    }
+};
+exports.plugin = plugin;
+const getFileName = (dir, filename) => {
+    filename = filename.replace(/\.ts$/, '');
+    const localname = (0, path_1.join)(dir, filename + '.query');
+    return localname + '.ts';
+};
+const makeAllRPCBundles = (builder, bundler) => {
+    if (!builder.options.rpcClients.bundle)
+        return;
+    const dir = bundler.bundle.base;
+    const filename = 'rpc';
+    // refs with services
+    const refs = builder.store.getProtos().filter((ref) => {
+        const proto = (0, proto_parser_1.getNestedProto)(ref.traversed);
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients.enabledServices.filter(a => a !== 'Msg');
+        const found = allowedRpcServices.some(svc => {
+            return proto?.[svc] &&
+                proto[svc]?.type === 'Service';
+        });
+        if (!found) {
+            return;
+        }
+        return true;
+    });
+    const check = refs.filter((ref) => {
+        const [base] = ref.proto.package.split('.');
+        return base === bundler.bundle.base;
+    });
+    if (!check.length) {
+        // if there are no services
+        // exit the plugin
+        return;
+    }
+    const packages = refs.reduce((m, ref) => {
+        const [base] = ref.proto.package.split('.');
+        if (base === 'cosmos' || base === bundler.bundle.base)
+            return [...new Set([...m, ref.proto.package])];
+        return m;
+    }, []);
+    const methodName = 'createRPCQueryClient';
+    const localname = getFileName(dir, filename ?? 'rpc');
+    const obj = {};
+    builder.rpcQueryClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        if (!(0, proto_parser_1.isRefIncluded)((0, proto_parser_1.createEmptyProtoRef)(file.package, file.proto), {
+            packages,
+        })) {
+            return;
+        }
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = (0, utils_1.getRelativePath)(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+    const ctx = new build_1.TelescopeParseContext((0, proto_parser_1.createEmptyProtoRef)(dir, localname), builder.store, builder.options);
+    //based on rpc type to generate client from client factory
+    let rpcast;
+    switch (builder.options?.rpcClients?.type) {
+        case "grpc-gateway":
+            rpcast = (0, ast_1.createScopedGrpcGatewayFactory)(ctx.proto, obj, "createGrpcGateWayClient"
+            // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "tendermint":
+            // TODO add addUtil to generic context
+            ctx.proto.addUtil('Rpc');
+            rpcast = (0, ast_1.createScopedRpcTmFactory)(ctx.proto, obj, methodName
+            // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "grpc-web":
+            rpcast = (0, ast_1.createScopedGrpcWebFactory)(ctx.proto, obj, "createGrpcWebClient");
+            break;
+        default:
+            break;
+    }
+    const serviceImports = (0, imports_1.getDepsFromQueries)(ctx.queries, localname);
+    const imports = (0, imports_1.aggregateImports)(ctx, serviceImports, localname);
+    const importStmts = (0, imports_1.getImportStatements)(localname, [...(0, utils_1.fixlocalpaths)(imports)], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(rpcast);
+    const writeFilename = bundler.getFilename(localname);
+    bundler.writeAst(prog, writeFilename);
+    bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+};

package/main/generators/create-rpc-query-client-scoped.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const dotty = __importStar(require("dotty"));
+const proto_parser_1 = require("@cosmology/proto-parser");
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const utils_1 = require("../utils");
+const build_1 = require("../build");
+const imports_1 = require("../imports");
+const plugin = (builder, bundler) => {
+    // if not enabled, exit
+    if (!builder.options?.rpcClients?.enabled) {
+        return;
+    }
+    if (builder.options?.rpcClients?.inline) {
+        return;
+    }
+    // we have scopes!
+    builder.options.rpcClients.scoped?.forEach(rpc => {
+        if (rpc.dir !== bundler.bundle.base)
+            return;
+        makeRPC(builder, bundler, rpc);
+    });
+};
+exports.plugin = plugin;
+const getFileName = (dir, filename) => {
+    filename = filename.replace(/\.ts$/, '');
+    const localname = (0, path_1.join)(dir, filename + '.query');
+    return localname + '.ts';
+};
+const makeRPC = (builder, bundler, rpc) => {
+    const dir = rpc.dir;
+    const packages = rpc.packages;
+    const protos = rpc.protos;
+    const methodName = rpc.methodNameQuery ?? 'createRPCQueryClient';
+    const localname = getFileName(dir, rpc.filename ?? 'rpc');
+    const obj = {};
+    builder.rpcQueryClients.forEach(file => {
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        if (!(0, proto_parser_1.isRefIncluded)((0, proto_parser_1.createEmptyProtoRef)(file.package, file.proto), {
+            packages,
+            protos
+        })) {
+            return;
+        }
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = (0, utils_1.getRelativePath)(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+    const ctx = new build_1.TelescopeParseContext((0, proto_parser_1.createEmptyProtoRef)(dir, localname), builder.store, builder.options);
+    //based on rpc type to generate client from client factory
+    let rpcast;
+    switch (builder.options?.rpcClients?.type) {
+        case "grpc-gateway":
+            rpcast = (0, ast_1.createScopedGrpcGatewayFactory)(ctx.proto, obj, "createGrpcGateWayClient"
+            // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "tendermint":
+            // TODO add addUtil to generic context
+            ctx.proto.addUtil('Rpc');
+            rpcast = (0, ast_1.createScopedRpcTmFactory)(ctx.proto, obj, methodName
+            // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "grpc-web":
+            rpcast = (0, ast_1.createScopedGrpcWebFactory)(ctx.proto, obj, "createGrpcWebClient");
+            break;
+        default:
+            break;
+    }
+    const serviceImports = (0, imports_1.getDepsFromQueries)(ctx.queries, localname);
+    const imports = (0, imports_1.aggregateImports)(ctx, serviceImports, localname);
+    const importStmts = (0, imports_1.getImportStatements)(localname, [...(0, utils_1.fixlocalpaths)(imports)], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(rpcast);
+    const filename = bundler.getFilename(localname);
+    bundler.writeAst(prog, filename);
+    if (rpc.addToBundle) {
+        bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname);
+    }
+};

package/main/generators/create-rpc-query-clients.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const ast_1 = require("@cosmology/ast");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const parse_1 = require("../parse");
+const utils_1 = require("@cosmology/utils");
+const plugin = (builder, bundler) => {
+    const instantRpcBundlerFiles = {};
+    const reactQueryBundlerFiles = [];
+    const mobxBundlerFiles = [];
+    const clients = bundler.contexts.map(c => {
+        const enabled = c.proto.pluginValue('rpcClients.enabled');
+        if (!enabled)
+            return;
+        const inline = c.proto.pluginValue('rpcClients.inline');
+        if (inline)
+            return;
+        if (c.proto.isExcluded())
+            return;
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        (0, parse_1.parse)(ctx);
+        const proto = (0, proto_parser_1.getNestedProto)(c.ref.traversed);
+        //// Anything except Msg Service OK...
+        const allowedRpcServices = builder.options.rpcClients?.enabledServices?.filter(a => a !== 'Msg') ?? [];
+        const found = allowedRpcServices.some(svc => {
+            return proto?.[svc] &&
+                proto[svc]?.type === 'Service';
+        });
+        if (!found) {
+            return;
+        }
+        ///
+        let name, getImportsFrom;
+        allowedRpcServices.forEach(svcKey => {
+            if (proto[svcKey]) {
+                if (svcKey === 'Query') {
+                    getImportsFrom = ctx.queries;
+                }
+                else {
+                    getImportsFrom = ctx.services;
+                }
+                name = svcKey;
+            }
+        });
+        const localname = bundler.getLocalFilename(c.ref, `rpc.${name}`);
+        const filename = bundler.getFilename(localname);
+        const bundlerFile = {
+            proto: c.ref.filename,
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+        const asts = [];
+        switch (c.proto.pluginValue('rpcClients.type')) {
+            case 'grpc-gateway':
+                allowedRpcServices.forEach(svcKey => {
+                    if (proto[svcKey]) {
+                        const svc = proto[svcKey];
+                        asts.push((0, ast_1.createGRPCGatewayQueryClass)(ctx.generic, svc));
+                        asts.push((0, ast_1.createGRPCGatewayWrapperClass)(ctx.generic, svc));
+                    }
+                });
+                break;
+            case 'grpc-web':
+                allowedRpcServices.forEach(svcKey => {
+                    if (proto[svcKey]) {
+                        const svc = proto[svcKey];
+                        asts.push((0, ast_1.createGrpcWebQueryInterface)(ctx.generic, svc));
+                        asts.push((0, ast_1.createGrpcWebQueryClass)(ctx.generic, svc));
+                        // add descriptor for grpc-web
+                        asts.push((0, ast_1.GetDesc)(ctx.generic, proto[svcKey]));
+                        const Desces = (0, ast_1.getMethodDesc)(ctx.generic, proto[svcKey]);
+                        for (let i = 0; i < Desces.length; i++) {
+                            const element = Desces[i];
+                            asts.push(element);
+                        }
+                        asts.push((0, ast_1.grpcWebRpcInterface)());
+                        asts.push((0, ast_1.getGrpcWebImpl)(ctx.generic));
+                        /* Added the sameway as Tendermint implement, if modify below then modify this one too */
+                        // see if current file has been reactQuery enabled and included
+                        const includeReactQueryHooks = c.proto.pluginValue('reactQuery.enabled') && (0, proto_parser_1.isRefIncluded)(c.ref, c.proto.pluginValue('reactQuery.include'));
+                        if (includeReactQueryHooks) {
+                            [].push.apply(asts, (0, ast_1.createRpcQueryHookInterfaces)(ctx.generic, svc));
+                            [].push.apply(asts, (0, ast_1.createRpcQueryHookClientMap)(ctx.generic, svc));
+                            asts.push((0, ast_1.createRpcQueryHooks)(ctx.generic, proto[svcKey]));
+                            // get all query methods
+                            const patterns = c.proto.pluginValue('reactQuery.instantExport.include.patterns');
+                            bundlerFile.instantExportedMethods = (0, utils_1.getQueryMethodNames)(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns).map((key) => proto[svcKey].methods[key]);
+                            reactQueryBundlerFiles.push(bundlerFile);
+                        }
+                        // whether mobx plugin is enabled has been dealt with inside createMobxQueryStores
+                        const mobxQueryStoreAst = (0, ast_1.createMobxQueryStores)(ctx.generic, proto[svcKey]);
+                        if (mobxQueryStoreAst) {
+                            asts.push(mobxQueryStoreAst);
+                            mobxBundlerFiles.push(bundlerFile);
+                        }
+                    }
+                });
+                break;
+            case 'tendermint':
+            default:
+                allowedRpcServices.forEach(svcKey => {
+                    if (proto[svcKey]) {
+                        const svc = proto[svcKey];
+                        asts.push((0, ast_1.createRpcClientInterface)(ctx.generic, svc));
+                        const instantOps = c.options.rpcClients?.instantOps ?? [];
+                        const useCamelCase = c.options.rpcClients?.camelCase;
+                        instantOps.forEach((item) => {
+                            let nameMapping = {
+                                ...(0, utils_1.swapKeyValue)(item.nameMapping?.All ?? {}),
+                                ...(0, utils_1.swapKeyValue)(item.nameMapping?.Query ?? {})
+                            };
+                            // get all query methods
+                            const patterns = item.include?.patterns;
+                            const serviceTypes = item.include?.serviceTypes;
+                            if (serviceTypes && !serviceTypes.includes("Query")) {
+                                return;
+                            }
+                            const methodKeys = (0, utils_1.getQueryMethodNames)(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns, useCamelCase ? utils_1.camel : String);
+                            if (!methodKeys || !methodKeys.length) {
+                                return;
+                            }
+                            asts.push((0, ast_1.createRpcClientInterface)(ctx.generic, svc, item.className, methodKeys, nameMapping));
+                            bundlerFile.instantExportedMethods = methodKeys.map((key) => proto[svcKey].methods[key]);
+                            if (!instantRpcBundlerFiles[item.className]) {
+                                instantRpcBundlerFiles[item.className] = [];
+                            }
+                            instantRpcBundlerFiles[item.className].push({ ...bundlerFile });
+                        });
+                        asts.push((0, ast_1.createRpcClientClass)(ctx.generic, svc));
+                        if (c.proto.pluginValue('rpcClients.extensions')) {
+                            asts.push((0, ast_1.createRpcQueryExtension)(ctx.generic, svc));
+                        }
+                        else {
+                            const env = c.proto.pluginValue('env');
+                            if (env === 'v-next') {
+                                asts.push((0, ast_1.createRpcClientImpl)(ctx.generic, svc));
+                            }
+                        }
+                        // see if current file has been reactQuery enabled and included
+                        const includeReactQueryHooks = c.proto.pluginValue('reactQuery.enabled') && (0, proto_parser_1.isRefIncluded)(c.ref, c.proto.pluginValue('reactQuery.include'));
+                        const includeMobxHooks = c.proto.pluginValue('mobx.enabled') && (0, proto_parser_1.isRefIncluded)(c.ref, c.proto.pluginValue('mobx.include'));
+                        if (includeReactQueryHooks) {
+                            [].push.apply(asts, (0, ast_1.createRpcQueryHookInterfaces)(ctx.generic, svc));
+                        }
+                        // enable getQueryService for plugins using it.
+                        if (includeReactQueryHooks || includeMobxHooks) {
+                            [].push.apply(asts, (0, ast_1.createRpcQueryHookClientMap)(ctx.generic, svc));
+                        }
+                        // react query
+                        // generate react query parts if included.
+                        // eg: __fixtures__/output1/akash/audit/v1beta2/query.rpc.Query.ts
+                        // export interface UseAuditorAttributesQuery<TData> ...
+                        // const _queryClients: WeakMap ...
+                        // const getQueryService = ...
+                        // export const createRpcQueryHooks = ...
+                        // TODO use the imports and make separate files
+                        if (includeReactQueryHooks) {
+                            asts.push((0, ast_1.createRpcQueryHooks)(ctx.generic, proto[svcKey]));
+                            // get all query methods
+                            const patterns = c.proto.pluginValue('reactQuery.instantExport.include.patterns');
+                            bundlerFile.instantExportedMethods = (0, utils_1.getQueryMethodNames)(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns).map((key) => proto[svcKey].methods[key]);
+                            reactQueryBundlerFiles.push(bundlerFile);
+                        }
+                        // whether mobx plugin is enabled has been dealt with inside createMobxQueryStores
+                        const mobxQueryStoreAst = (0, ast_1.createMobxQueryStores)(ctx.generic, proto[svcKey]);
+                        if (mobxQueryStoreAst) {
+                            asts.push(mobxQueryStoreAst);
+                            mobxBundlerFiles.push(bundlerFile);
+                        }
+                    }
+                });
+        }
+        if (!asts.length) {
+            return;
+        }
+        const serviceImports = (0, imports_1.getDepsFromQueries)(getImportsFrom, localname);
+        // TODO we do NOT need all imports...
+        const imports = (0, imports_1.buildAllImports)(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body)
+            .concat(asts);
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+        return bundlerFile;
+    }).filter(Boolean);
+    bundler.addRPCQueryClients(clients);
+    Object.keys(instantRpcBundlerFiles).forEach((className) => {
+        bundler.addStateManagers(`instantRpc_${className}`, instantRpcBundlerFiles[className]);
+    });
+    bundler.addStateManagers("reactQuery", reactQueryBundlerFiles);
+    bundler.addStateManagers("mobx", mobxBundlerFiles);
+};
+exports.plugin = plugin;

package/main/generators/create-sdk-module-stargate-clients.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const case_1 = require("case");
+const utils_1 = require("@cosmology/utils");
+const imports_1 = require("../imports");
+const plugin = (builder, bundler) => {
+    if (!bundler.registries || !bundler.registries.length) {
+        return;
+    }
+    const registryImports = [];
+    const converterImports = [];
+    const clientFile = bundler.bundle.base.concat('-sdk-module-client.ts');
+    bundler.files.push(clientFile);
+    const ctxRef = {
+        absolute: '/',
+        filename: '/',
+        proto: {
+            imports: [],
+            package: bundler.bundle.base,
+            root: {},
+        }
+    };
+    const ctx = new ast_1.GenericParseContext(ctxRef, null, builder.options);
+    const registryVariables = [];
+    const converterVariables = [];
+    bundler.registries.forEach(registry => {
+        let rel = (0, path_1.relative)((0, path_1.dirname)(clientFile), registry.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = (0, utils_1.toPosixPath)(rel);
+        const variable = (0, utils_1.variableSlug)(registry.localname);
+        registryVariables.push(variable);
+        registryImports.push((0, ast_1.importNamespace)(variable, rel));
+    });
+    bundler.converters.forEach(converter => {
+        let rel = (0, path_1.relative)((0, path_1.dirname)(clientFile), converter.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = (0, utils_1.toPosixPath)(rel);
+        const variable = (0, utils_1.variableSlug)(converter.localname);
+        converterVariables.push(variable);
+        converterImports.push((0, ast_1.importNamespace)(variable, rel));
+    });
+    const name = 'getSigning' + (0, case_1.pascal)(bundler.bundle.base + 'Client');
+    const txRpcName = 'getSigning' + (0, case_1.pascal)(bundler.bundle.base + 'TxRpc');
+    const prefix = (0, case_1.camel)(bundler.bundle.base);
+    const aminos = (0, ast_1.createStargateClientAminoRegistry)({
+        context: ctx,
+        aminos: converterVariables,
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const protos = (0, ast_1.createStargateClientProtoRegistry)({
+        context: ctx,
+        registries: registryVariables,
+        protoTypeRegistry: prefix + 'ProtoRegistry'
+    });
+    const clientOptions = (0, ast_1.createStargateClientOptions)({
+        context: ctx,
+        name: name + 'Options',
+        protoTypeRegistry: prefix + 'ProtoRegistry',
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const clientBody = (0, ast_1.createStargateClient)({
+        context: ctx,
+        name,
+        options: name + 'Options',
+    });
+    let getTxRpc;
+    if (ctx.pluginValue("stargateClients.addGetTxRpc")) {
+        getTxRpc = (0, ast_1.createGetTxRpc)(ctx, txRpcName, name);
+    }
+    const imports = (0, imports_1.buildAllImportsFromGenericContext)(ctx, clientFile);
+    let importDecls = [...imports, ...registryImports, ...converterImports];
+    importDecls = (0, utils_1.duplicateImportPathsWithExt)(importDecls, builder.options.restoreImportExtension);
+    let cProg = importDecls
+        .concat(aminos)
+        .concat(protos)
+        .concat(clientOptions)
+        .concat(clientBody);
+    // replace all backslash path for windows
+    for (let i = 0; i < cProg.length; i++) {
+        if (cProg[i].source?.value) {
+            cProg[i].source.value = (0, utils_1.toPosixPath)(cProg[i].source?.value);
+        }
+    }
+    if (getTxRpc) {
+        cProg = cProg.concat(getTxRpc);
+    }
+    const clientOutFile = (0, path_1.join)(builder.outPath, clientFile);
+    bundler.writeAst(cProg, clientOutFile);
+};
+exports.plugin = plugin;