@hyperweb/telescope 1.15.0

package/src/generators/create-rpc-msg-client-scoped.ts

@@ -0,0 +1,147 @@
+import * as dotty from 'dotty';
+import { createEmptyProtoRef, getNestedProto } from '@cosmology/proto-parser';
+import { join } from 'path';
+import { TelescopeBuilder } from '../builder';
+import { createScopedRpcFactory, createScopedGrpcWebMsgFactory, createRpcMsgExtension, importStmt } from '@cosmology/ast';
+import { ProtoRef } from '@cosmology/types';
+import { fixlocalpaths, getRelativePath } from '../utils';
+import { Bundler } from '../bundler';
+import { aggregateImports, getDepsFromQueries, getImportStatements } from '../imports';
+import { TelescopeParseContext } from '../build';
+import { pascal } from 'case';
+
+export const plugin = (
+    builder: TelescopeBuilder,
+    bundler: 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
+        );
+    });
+};
+
+const getFileName = (dir, filename) => {
+    filename = filename.replace(/\.ts$/, '');
+    const localname = join(dir, filename + '.tx');
+    return localname + '.ts';
+};
+
+const makeRPC = (
+    builder: TelescopeBuilder,
+    bundler: Bundler,
+    rpc: {
+        dir: string;
+        filename?: string;
+        packages: string[];
+        addToBundle: boolean;
+        methodNameQuery?: string;
+        methodNameTx?: string;
+        isAll?: boolean;
+    }
+) => {
+    const dir = rpc.dir;
+    const packages = rpc.packages;
+    const methodName = rpc.methodNameTx ?? 'createRPCMsgClient'
+    const localname = getFileName(dir, rpc.filename ?? 'rpc');
+
+    const obj = {};
+    builder.rpcMsgClients.forEach(file => {
+
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        if (!packages.includes(file.package)) {
+            return;
+        }
+
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = getRelativePath(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+
+    const ctx = new TelescopeParseContext(
+        createEmptyProtoRef(dir, localname),
+        builder.store,
+        builder.options
+    );
+
+    let rpcast;
+    let msgExt: any = [];
+    let txRpcImport: any = [];
+    switch (builder.options?.rpcClients?.type) {
+        case "grpc-gateway":
+        // TODO no working scoped clients for grpc-gateway right now
+        case "tendermint":
+            // TODO add addUtil to generic context
+            ctx.proto.addUtil('Rpc');
+
+            rpcast = createScopedRpcFactory(
+                obj,
+                methodName,
+                'MsgClientImpl', // make option later,
+                ctx.options
+            );
+
+            if(rpc.isAll && ctx.proto.pluginValue('env') === 'v-next' && ctx.proto.pluginValue('rpcClients.extensions') && ctx.proto.pluginValue('stargateClients.addGetTxRpc')) {
+              const txRpcName = 'getSigning' + pascal(bundler.bundle.base + 'TxRpc');
+
+              txRpcImport = importStmt([txRpcName], `./client${ctx.options.restoreImportExtension ?? ""}`)
+
+              msgExt = createRpcMsgExtension(ctx.proto, txRpcName);
+            }
+            break;
+        case "grpc-web":
+            ctx.proto.addUtil('grpc');
+            ctx.proto.addUtil('NodeHttpTransport');
+
+            rpcast = createScopedGrpcWebMsgFactory(
+                obj,
+                methodName,
+                'MsgClientImpl', // make option later,
+                ctx.options
+            );
+            break;
+        default:
+            break;
+    }
+
+    const serviceImports = getDepsFromQueries(
+        ctx.queries,
+        localname
+    );
+
+    const imports = aggregateImports(ctx, serviceImports, localname);
+
+    const importStmts = getImportStatements(
+        localname,
+        [...fixlocalpaths(imports)],
+        builder.options
+    );
+
+    const prog = []
+        .concat(txRpcImport)
+        .concat(importStmts)
+        .concat(rpcast)
+        .concat(msgExt);
+
+    const filename = bundler.getFilename(localname);
+    bundler.writeAst(prog, filename);
+    if (rpc.addToBundle) {
+        bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname)
+    }
+};

package/src/generators/create-rpc-msg-clients.ts

@@ -0,0 +1,165 @@
+import { buildAllImports, getDepsFromQueries } from '../imports';
+import { Bundler } from '../bundler';
+import { createRpcClientClass, createRpcClientInterface, createGRPCGatewayMsgClass, GetDesc, getMethodDesc, grpcWebRpcInterface, createGrpcWebMsgInterface, createGrpcWebMsgClass, getGrpcWebImpl, createRpcClientImpl } from '@cosmology/ast';
+import { getNestedProto } from '@cosmology/proto-parser';
+import { parse } from '../parse';
+import { TelescopeBuilder } from '../builder';
+import { camel, getQueryMethodNames, swapKeyValue } from '@cosmology/utils';
+import { BundlerFile } from 'src/types';
+
+export const plugin = (
+    builder: TelescopeBuilder,
+    bundler: Bundler
+) => {
+    // if (!builder.options.rpcClients.enabled) {
+    //     return;
+    // }
+    const instantRpcBundlerFiles: {
+      [key: string]: BundlerFile[]
+    } = {};
+
+    const mutationContexts = bundler
+        .contexts
+        .filter(context => context.mutations.length > 0);
+
+    const clients = mutationContexts.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 useCamelCase = c.proto.pluginValue("rpcClients.camelCase");
+
+        const localname = bundler.getLocalFilename(c.ref, 'rpc.msg');
+        const filename = bundler.getFilename(localname);
+        const ctx = bundler.getFreshContext(c);
+
+        // get mutations, services
+        parse(ctx);
+
+        const proto = getNestedProto(c.ref.traversed);
+        // hard-coding, for now, only Msg service
+        if (!proto?.Msg || proto.Msg?.type !== 'Service') {
+            return;
+        }
+
+        ////////
+        const asts = [];
+        const bundlerFile: BundlerFile = {
+          proto: c.ref.filename,
+          package: c.ref.proto.package,
+          localname,
+          filename,
+          isMsg: true
+        };
+        switch (c.proto.pluginValue("rpcClients.type")) {
+            case 'grpc-gateway':
+                asts.push(createGRPCGatewayMsgClass(ctx.generic, proto.Msg))
+                break;
+            case 'grpc-web':
+                asts.push(createGrpcWebMsgInterface(ctx.generic, proto.Msg))
+                asts.push(createGrpcWebMsgClass(ctx.generic, proto.Msg))
+                asts.push(GetDesc(ctx.generic, proto.Msg))
+                const Desces = getMethodDesc(ctx.generic, proto.Msg);
+                for (let i = 0; i < Desces.length; i++) {
+                    const element = Desces[i];
+                    asts.push(element);
+                }
+                asts.push(grpcWebRpcInterface())
+                asts.push(getGrpcWebImpl(ctx.generic))
+                break;
+            case 'tendermint':
+            default:
+                asts.push(createRpcClientInterface(ctx.generic, proto.Msg))
+
+                const svc = proto.Msg;
+                const instantOps = c.options.rpcClients?.instantOps ?? [];
+
+                instantOps.forEach((item) => {
+                  let nameMapping = {
+                    ...swapKeyValue(item.nameMapping?.All ?? {}),
+                    ...swapKeyValue(item.nameMapping?.Msg ?? {})
+                  };
+
+                  // get all query methods
+                  const patterns = item.include?.patterns;
+                  const serviceTypes = item.include?.serviceTypes;
+
+                  if(serviceTypes && !serviceTypes.includes("Tx")){
+                    return
+                  }
+
+                  const methodKeys = getQueryMethodNames(
+                    bundlerFile.package,
+                    Object.keys(svc.methods ?? {}),
+                    patterns,
+                    useCamelCase ? camel : String
+                  );
+
+                  if(!methodKeys || !methodKeys.length){
+                    return
+                  }
+
+                  asts.push(
+                    createRpcClientInterface(
+                      ctx.generic,
+                      svc,
+                      item.className,
+                      methodKeys,
+                      nameMapping
+                    )
+                  );
+
+                  bundlerFile.instantExportedMethods = methodKeys.map((key) => svc.methods[key]);
+
+                  if(!instantRpcBundlerFiles[item.className]){
+                    instantRpcBundlerFiles[item.className] = [];
+                  }
+
+                  instantRpcBundlerFiles[item.className].push({...bundlerFile});
+                });
+
+                asts.push(createRpcClientClass(ctx.generic, proto.Msg))
+
+                const env = c.proto.pluginValue('env');
+                if(env === 'v-next'){
+                  asts.push(createRpcClientImpl(ctx.generic, svc));
+                }
+        }
+
+        ////////
+
+        const serviceImports = getDepsFromQueries(
+            ctx.mutations,
+            localname
+        );
+
+        // TODO we do NOT need all imports...
+        const imports = buildAllImports(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body)
+            .concat(asts);
+
+
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+
+        return {
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+
+    }).filter(Boolean);
+
+    bundler.addRPCMsgClients(clients);
+
+    Object.keys(instantRpcBundlerFiles).forEach((className)=>{
+      bundler.addStateManagers(`instantRpc_${className}`, instantRpcBundlerFiles[className]);
+    })
+};

package/src/generators/create-rpc-ops-bundle.ts

@@ -0,0 +1,155 @@
+import { aggregateImports, getImportStatements } from "../imports";
+import { join, dirname, extname, basename } from "path";
+import { TelescopeBuilder } from "../builder";
+import {
+  createInstantRpcInterface,
+  createInstantRpcClass,
+} from "@cosmology/ast";
+import { ImportUsage, ProtoRef } from "@cosmology/types";
+import { TelescopeParseContext } from "../build";
+import { writeAstToFile } from "../utils/files";
+import { fixlocalpaths } from "../utils";
+import * as dotty from "dotty";
+import { createEmptyProtoRef } from "@cosmology/proto-parser";
+import { camel, makeUseHookName, makeUsePkgHookName } from "@cosmology/utils";
+import { variableSlug } from "@cosmology/utils";
+import { swapKeyValue } from "@cosmology/utils";
+import { buildImports } from "@cosmology/utils";
+import { BundlerFile } from "src/types";
+
+export const plugin = (builder: TelescopeBuilder) => {
+  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: ProtoRef = createEmptyProtoRef(pkg, localname);
+
+  // create context
+  const context = new 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 = fixlocalpaths(aggregateImports(context, {}, localname));
+  const importStmts = getImportStatements(localname, imports, builder.options);
+
+  // construct the AST
+  const prog = [].concat(importStmts).concat(buildImports(pkgImports)).concat(ast);
+
+  // write the file.
+  const filename = join(builder.outPath, localname);
+  builder.files.push(localname);
+
+  writeAstToFile(builder.outPath, builder.options, prog, filename);
+};
+
+// bundlerFiles.filter(file => file.localname.indexOf("rpc.msg") !== -1)
+
+function createRpcOpsAst(
+  context: TelescopeParseContext,
+  className: string,
+  pkgImports: ImportUsage[],
+  nameMapping,
+  bundlerFiles: BundlerFile[]
+) {
+  const extendInterfaces = [];
+  const instantMapping: {
+    [key: string]: {
+      methodName: string;
+      importedVarName: string;
+      comment?: string | undefined;
+    };
+  } = {};
+  const camelRpcMethods = context.generic.pluginValue("rpcClients.camelCase");
+
+
+  let txNameMapping = {
+    ...swapKeyValue(nameMapping?.All ?? {}),
+    ...swapKeyValue(nameMapping?.Msg ?? {})
+  };
+
+  let queryNameMapping = {
+    ...swapKeyValue(nameMapping?.All ?? {}),
+    ...swapKeyValue(nameMapping?.Query ?? {})
+  };
+
+  bundlerFiles.forEach((bundlerFile) => {
+    const isMsg = bundlerFile.isMsg;
+    const currentNameMapping = isMsg ? txNameMapping : queryNameMapping;
+
+    const path = `./${bundlerFile.localname.replace(/\.ts$/, "")}`;
+    const importedVarName = 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 ? 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 [
+    createInstantRpcInterface(className, extendInterfaces),
+    createInstantRpcClass(context.generic, className, instantMapping),
+  ];
+}

package/src/generators/create-rpc-query-client-all.ts

@@ -0,0 +1,173 @@
+import * as dotty from 'dotty';
+import { getNestedProto, isRefIncluded, createEmptyProtoRef } from '@cosmology/proto-parser';
+import { join } from 'path';
+import { TelescopeBuilder } from '../builder';
+import { createScopedRpcTmFactory, createScopedGrpcWebFactory, createScopedGrpcGatewayFactory } from '@cosmology/ast';
+import { ProtoRef } from '@cosmology/types';
+import { fixlocalpaths, getRelativePath } from '../utils';
+import { Bundler } from '../bundler';
+import { TelescopeParseContext } from '../build';
+import { aggregateImports, getDepsFromQueries, getImportStatements } from '../imports';
+
+export const plugin = (
+    builder: TelescopeBuilder,
+    bundler: 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
+        );
+    }
+
+};
+
+const getFileName = (dir, filename) => {
+    filename = filename.replace(/\.ts$/, '');
+    const localname = join(dir, filename + '.query');
+    return localname + '.ts';
+};
+
+const makeAllRPCBundles = (
+    builder: TelescopeBuilder,
+    bundler: 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: ProtoRef) => {
+        const proto = 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: ProtoRef) => {
+        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: ProtoRef) => {
+        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 (!isRefIncluded(createEmptyProtoRef(file.package, file.proto), {
+            packages,
+        })) {
+            return;
+        }
+
+        const f = localname;
+        const f2 = file.localname;
+        const importPath = getRelativePath(f, f2);
+        dotty.put(obj, file.package, importPath);
+    });
+
+    const ctx = new TelescopeParseContext(
+        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 = createScopedGrpcGatewayFactory(
+                ctx.proto,
+                obj,
+                "createGrpcGateWayClient"
+                // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "tendermint":
+            // TODO add addUtil to generic context
+            ctx.proto.addUtil('Rpc');
+
+            rpcast = createScopedRpcTmFactory(
+                ctx.proto,
+                obj,
+                methodName
+                // 'QueryClientImpl' // make option later
+            );
+            break;
+        case "grpc-web":
+            rpcast = createScopedGrpcWebFactory(
+                ctx.proto,
+                obj,
+                "createGrpcWebClient"
+            );
+            break;
+        default:
+            break;
+    }
+
+
+    const serviceImports = getDepsFromQueries(
+        ctx.queries,
+        localname
+    );
+
+    const imports = aggregateImports(ctx, serviceImports, localname);
+
+    const importStmts = getImportStatements(
+        localname,
+        [...fixlocalpaths(imports)],
+        builder.options
+    );
+
+    const prog = []
+        .concat(importStmts)
+        .concat(rpcast);
+
+    const writeFilename = bundler.getFilename(localname);
+    bundler.writeAst(prog, writeFilename);
+    bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname)
+
+};