@hyperweb/telescope 1.15.0

package/src/generators/create-mobx-bundle.ts

@@ -0,0 +1,31 @@
+import { TelescopeBuilder } from '../builder';
+import { createMobxQueryFactory } from '@cosmology/ast';
+import * as dotty from 'dotty';
+import { commonBundlePlugin } from '../utils';
+
+export const plugin = (builder: TelescopeBuilder) => {
+  // if mobx is enabled
+  // generate stores.ts based on query hooks generated in each package.
+  // eg: __fixtures__/output1/stores.ts
+  if (!builder.options.mobx?.enabled) {
+    return;
+  }
+
+  // get mapping of packages and rpc query filenames.
+  const obj = {};
+  const bundlerFiles = builder.stateManagers["mobx"];
+
+  if (!bundlerFiles || !bundlerFiles.length) {
+    return;
+  }
+
+  bundlerFiles.map((queryClient) => {
+    const path = `./${queryClient.localname.replace(/\.ts$/, '')}`;
+    dotty.put(obj, queryClient.package, path);
+  });
+
+  commonBundlePlugin(builder, 'mobx.stores.ts', obj, (context, obj) => {
+    // generate code for createRpcQueryHooks and imports of related packages.
+    return createMobxQueryFactory(context, obj);
+  });
+};

package/src/generators/create-msg-funcs.ts

@@ -0,0 +1,219 @@
+import { buildAllImports, getDepsFromQueries } from "../imports";
+import { Bundler } from "../bundler";
+import { createMsgHelperCreator, createMsgHooks, createVueMsgHooks } from "@cosmology/ast";
+import { getNestedProto } from "@cosmology/proto-parser";
+import { parse } from "../parse";
+import { TelescopeBuilder } from "../builder";
+import {
+  camel,
+  getHelperFuncName,
+  getQueryMethodNames,
+  swapKeyValue,
+} from "@cosmology/utils";
+import { BundlerFile } from "../types";
+import { ProtoService, TX_SVC_TYPES } from "@cosmology/types";
+import { getExportedTypeNames } from "../utils/files";
+
+export const plugin = (builder: TelescopeBuilder, bundler: Bundler) => {
+  const mutationContexts = bundler.contexts.filter(
+    (context) => context.mutations.length > 0
+  );
+
+  const clients = mutationContexts
+    .map((c) => {
+      const enabled = c.proto.pluginValue("helperFunctions.enabled");
+      if (!enabled) return;
+
+      const serviceTypes = c.proto.pluginValue(
+        "helperFunctions.include.serviceTypes"
+      );
+
+      if (serviceTypes && !serviceTypes.includes("Tx")) {
+        return;
+      }
+
+      if (c.proto.isExcluded()) return;
+
+      const localname = bundler.getLocalFilename(c.ref, "rpc.func");
+      const localnameReact = bundler.getLocalFilename(c.ref, `rpc.react`);
+      const localnameVue = bundler.getLocalFilename(c.ref, `rpc.vue`);
+      const filename = bundler.getFilename(localname);
+      const filenameReact = bundler.getFilename(localnameReact);
+      const filenameVue = bundler.getFilename(localnameVue);
+
+      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 reactAsts = [];
+      const vueAsts = [];
+      const helperCreatorNameList = [];
+
+      const bundlerFile: BundlerFile = {
+        proto: c.ref.filename,
+        package: c.ref.proto.package,
+        localname,
+        filename,
+        isMsg: true,
+      };
+
+      TX_SVC_TYPES.forEach((svcKey) => {
+        if (proto[svcKey]) {
+          const svc: ProtoService = proto[svcKey];
+          const patterns = c.proto.pluginValue(
+            "helperFunctions.include.patterns"
+          );
+          const nameMappers = c.proto.pluginValue(
+            "helperFunctions.nameMappers"
+          );
+
+          const methodKeys = getQueryMethodNames(
+            bundlerFile.package,
+            Object.keys(proto[svcKey].methods ?? {}),
+            patterns || ["**"],
+            String
+          );
+
+          // see if the function is excluded.
+          if (!methodKeys || !methodKeys.length) {
+            return;
+          }
+
+          // for each method key, create creators, hooks.
+          methodKeys.forEach((methodKey) => {
+            // get helperCreatorName
+            // get hookName
+            const { creator: helperCreatorName, hook: hookName } =
+              getHelperFuncName(
+                bundlerFile.package,
+                methodKey,
+                [nameMappers?.Msg, nameMappers?.All],
+                "unchanged"
+              );
+
+            helperCreatorNameList.push(helperCreatorName);
+
+            const genCustomHooks = c.proto.pluginValue(
+              "helperFunctions.hooks.react"
+            );
+
+            const genCustomHooksVue = c.proto.pluginValue(
+              "helperFunctions.hooks.vue"
+            );
+
+            // Store the mapping in builder
+            builder.addFunctionMapping(
+              bundlerFile.package,
+              svcKey,
+              methodKey,
+              helperCreatorName,
+              hookName,
+              svc.methods[methodKey].comment,
+              svc.methods[methodKey].requestType,
+              svc.methods[methodKey].responseType,
+              localname, // function source file
+              genCustomHooks ? localnameReact : undefined, // hook source file (React)
+              bundler.getLocalFilename(c.ref) // type source file (main types file)
+            );
+
+            // gen helper funcs
+            asts.push(
+              createMsgHelperCreator(
+                ctx.generic,
+                svc.methods[methodKey],
+                helperCreatorName
+              )
+            );
+
+            if (genCustomHooks) {
+              // gen custom react hooks
+              reactAsts.push(
+                createMsgHooks(
+                  ctx.generic,
+                  svc.methods[methodKey],
+                  helperCreatorName,
+                  hookName
+                )
+              );
+            }
+
+            if (genCustomHooksVue) {
+              // gen custom vue hooks
+              vueAsts.push(
+                createVueMsgHooks(
+                  ctx.generic,
+                  svc.methods[methodKey],
+                  helperCreatorName,
+                  hookName
+                )
+              );
+            }
+
+          });
+        }
+      });
+
+      if (!asts.length) {
+        return;
+      }
+
+      const serviceImports = getDepsFromQueries(ctx.mutations, localname);
+      const serviceImportsReact = getDepsFromQueries(ctx.mutations, localnameReact);
+      const serviceImportsVue = getDepsFromQueries(ctx.mutations, localnameVue);
+
+      // add imports from func file like query.rpc.func.ts without the .ts extension
+      const funcFileName = "./".concat(localname.substring(localname.lastIndexOf("/") + 1).replace(/\.ts$/, ""));
+      serviceImportsReact[funcFileName] = helperCreatorNameList;
+      serviceImportsVue[funcFileName] = helperCreatorNameList;
+
+      const imports = buildAllImports(ctx, serviceImports, localname);
+      const importsReact = buildAllImports(ctx, serviceImportsReact, localnameReact);
+      const importsVue = buildAllImports(ctx, serviceImportsVue, localnameReact);
+
+      const prog = [].concat(imports).concat(ctx.body).concat(asts);
+      const progReact = [].concat(importsReact).concat(reactAsts);
+      const progVue = [].concat(importsVue).concat(vueAsts);
+
+      const exportedTypeNames = getExportedTypeNames(prog);
+      const exportedTypeNamesReact = getExportedTypeNames(progReact);
+      const exportedTypeNamesVue = getExportedTypeNames(progVue);
+
+      exportedTypeNames.forEach((name) => {
+        builder.store.setHelperFuncFilesMapping(name, localname);
+      });
+      exportedTypeNamesReact.forEach((name) => {
+        builder.store.setHelperFuncFilesMapping(name, localnameReact);
+      });
+      exportedTypeNamesVue.forEach((name) => {
+        builder.store.setHelperFuncFilesMapping(name, localnameVue);
+      });
+
+      bundler.writeAst(prog, filename);
+      bundler.addExportObjToBundle(c.ref.proto.package, localname, exportedTypeNames, true);
+      if (reactAsts.length) {
+        bundler.writeAst(progReact, filenameReact);
+        bundler.addExportObjToBundle(c.ref.proto.package, localnameReact, exportedTypeNamesReact, true);
+      }
+      if (vueAsts.length) {
+        bundler.writeAst(progVue, filenameVue);
+        bundler.addExportObjToBundle(c.ref.proto.package, localnameVue, exportedTypeNamesVue, true);
+      }
+      bundler.addToBundle(c, localname);
+
+      return {
+        package: c.ref.proto.package,
+        localname,
+        filename,
+      };
+    })
+    .filter(Boolean);
+};

package/src/generators/create-pinia-store-bundle.ts

@@ -0,0 +1,35 @@
+import { aggregateImports, getImportStatements } from '../imports';
+import { join } from 'path';
+import { TelescopeBuilder } from '../builder';
+
+import { ProtoRef } from '@cosmology/types';
+import { TelescopeParseContext } from '../build';
+import { writeAstToFile } from '../utils/files';
+import { commonBundlePlugin, fixlocalpaths } from '../utils';
+import * as dotty from 'dotty';
+import { createPiniaStoreFactory } from '@cosmology/ast';
+
+export const plugin = (builder: TelescopeBuilder) => {
+  // if not enabled, exit
+  if (!builder.options?.pinia?.enabled) {
+    return;
+  }
+
+  // get mapping of packages and rpc query filenames.
+  const obj = {};
+  const bundlerFiles = builder.stateManagers['pinia'];
+
+  if (!bundlerFiles || !bundlerFiles.length) {
+    return;
+  }
+
+  bundlerFiles.map((queryClient) => {
+    const path = `./${queryClient.localname.replace(/\.ts$/, '')}`;
+    dotty.put(obj, queryClient.package, path);
+  });
+
+  commonBundlePlugin(builder, 'pinia.store.ts', obj, (context, obj) => {
+    // generate code for createRpcQueryHooks and imports of related packages.
+    return createPiniaStoreFactory(context, obj);
+  });
+};

package/src/generators/create-pinia-store.ts

@@ -0,0 +1,121 @@
+import { Statement } from '@babel/types';
+import { Bundler } from '../bundler';
+import { TelescopeBuilder } from '../builder';
+import {
+  buildAllImports,
+  getDepsFromQueries,
+  getImportStatements
+} from '../imports';
+import { parse } from '../parse';
+import { getNestedProto, isRefIncluded } from '@cosmology/proto-parser';
+
+import { createPiniaStore } from '@cosmology/ast';
+
+export const plugin = (builder: TelescopeBuilder, bundler: Bundler) => {
+  if (!builder.options.pinia?.enabled) {
+    return;
+  }
+
+  // get mapping of packages and rpc query filenames.
+
+  if (!builder.options.lcdClients?.enabled) {
+    return;
+  }
+
+  const queryContexts = bundler.contexts.filter(
+    (context) => context.queries.length > 0 || context.services.length > 0
+  );
+
+  if (queryContexts.length > 0) {
+    const piniaBundlerFiles = [];
+
+    // [x] write out one registry helper for all contexts w/mutations
+    queryContexts.forEach((c) => {
+      const enabled = c.proto.pluginValue('lcdClients.enabled');
+      if (!enabled) return;
+
+      const includePinia =
+        c.proto.pluginValue('pinia.enabled') &&
+        isRefIncluded(c.ref, c.proto.pluginValue('pinia.include'));
+      if (!includePinia) return;
+
+      if (c.proto.isExcluded()) return;
+
+      const ctx = bundler.getFreshContext(c);
+
+      // get mutations, services
+      parse(ctx);
+
+      const proto = getNestedProto(c.ref.traversed);
+
+      //// Anything except Msg Service OK...
+      const allowedRpcServices =
+        builder.options.rpcClients.enabledServices.filter((a) => a !== 'Msg');
+
+      let name, getImportsFrom;
+
+      // get imports
+      allowedRpcServices.forEach((svcKey) => {
+        if (proto[svcKey]) {
+          if (svcKey === 'Query') {
+            getImportsFrom = ctx.queries;
+          } else {
+            getImportsFrom = ctx.services;
+          }
+          name = svcKey;
+        }
+      });
+
+      const localname = bundler.getLocalFilename(c.ref, 'pinia.store');
+      const filename = bundler.getFilename(localname);
+
+      const bundlerFile = {
+        package: c.ref.proto.package,
+        localname,
+        filename
+      };
+
+      let ast = null;
+
+      allowedRpcServices.forEach((svcKey) => {
+        if (proto[svcKey]) {
+          ast = createPiniaStore(ctx.generic, proto[svcKey]);
+        }
+      });
+
+      if (!ast) {
+        return;
+      }
+
+      piniaBundlerFiles.push(bundlerFile);
+
+      const serviceImports = getDepsFromQueries(getImportsFrom, localname);
+
+      const imports = buildAllImports(ctx, serviceImports, localname);
+
+      const piniaImport = getImportStatements('pinia', [
+        {
+          type: 'import',
+          name: 'defineStore',
+          path: 'pinia'
+        },
+        {
+          type: 'import',
+          name: 'LCDQueryClient',
+          path: './query.lcd'
+        }
+      ],
+      builder.options);
+
+      const prog = []
+        .concat([...imports, ...piniaImport])
+        .concat(ctx.body)
+        .concat(ast);
+
+      bundler.writeAst(prog, filename);
+      bundler.addToBundle(c, localname);
+    });
+
+    bundler.addStateManagers('pinia', piniaBundlerFiles);
+  }
+};

package/src/generators/create-query-funcs.ts

@@ -0,0 +1,224 @@
+import { buildAllImports, getDepsFromQueries } from "../imports";
+import { Bundler } from "../bundler";
+import { createQueryHelperCreator, createQueryHooks, createVueQueryHooks } from "@cosmology/ast";
+import { getNestedProto, isRefIncluded } from "@cosmology/proto-parser";
+import { parse } from "../parse";
+import { TelescopeBuilder } from "../builder";
+import { ProtoRoot, ProtoService, QUERY_SVC_TYPES } from "@cosmology/types";
+import {
+  camel,
+  getHelperFuncName,
+  getQueryMethodNames,
+  swapKeyValue,
+} from "@cosmology/utils";
+import { BundlerFile } from "../types";
+import { getExportedTypeNames } from "../utils/files";
+
+export const plugin = (builder: TelescopeBuilder, bundler: Bundler) => {
+  const clients = bundler.contexts
+    .map((c) => {
+      const enabled = c.proto.pluginValue("helperFunctions.enabled");
+      if (!enabled) return;
+
+      const serviceTypes = c.proto.pluginValue(
+        "helperFunctions.include.serviceTypes"
+      );
+
+      if (
+        serviceTypes &&
+        !serviceTypes.includes("Query") &&
+        !serviceTypes.includes("All")
+      ) {
+        return;
+      }
+
+      if (c.proto.isExcluded()) return;
+
+      const ctx = bundler.getFreshContext(c);
+
+      // get mutations, services
+      parse(ctx);
+
+      const proto = getNestedProto(c.ref.traversed as ProtoRoot);
+
+      //// Anything except Msg Service OK...
+      if (proto?.Msg) {
+        return;
+      }
+
+      let getImportsFrom;
+
+      if (proto.Query) {
+        getImportsFrom = ctx.queries;
+      } else {
+        getImportsFrom = ctx.services;
+      }
+      const localname = bundler.getLocalFilename(c.ref, `rpc.func`);
+      const localnameReact = bundler.getLocalFilename(c.ref, `rpc.react`);
+      const localnameVue = bundler.getLocalFilename(c.ref, `rpc.vue`);
+      const filename = bundler.getFilename(localname);
+      const filenameReact = bundler.getFilename(localnameReact);
+      const filenameVue = bundler.getFilename(localnameVue);
+
+      const bundlerFile: BundlerFile = {
+        proto: c.ref.filename,
+        package: c.ref.proto.package,
+        localname,
+        filename,
+      };
+
+      const asts = [];
+      const reactAsts = [];
+      const vueAsts = [];
+      const helperCreatorNameList = [];
+
+      QUERY_SVC_TYPES.forEach((svcKey) => {
+        if (proto[svcKey]) {
+          const svc: ProtoService = proto[svcKey];
+          const patterns = c.proto.pluginValue(
+            "helperFunctions.include.patterns"
+          );
+          const nameMappers = c.proto.pluginValue(
+            "helperFunctions.nameMappers"
+          );
+
+          const methodKeys = getQueryMethodNames(
+            bundlerFile.package,
+            Object.keys(proto[svcKey].methods ?? {}),
+            patterns || ["**"],
+            String
+          );
+
+          // see if the function is excluded.
+          if (!methodKeys || !methodKeys.length) {
+            return;
+          }
+
+          // for each method key, create creators, hooks.
+          methodKeys.forEach((methodKey) => {
+            // get helperCreatorName
+            // get hookName
+            const { creator: helperCreatorName, hook: hookName } =
+              getHelperFuncName(
+                bundlerFile.package,
+                methodKey,
+                [nameMappers?.Query, nameMappers?.All],
+                "get"
+              );
+            helperCreatorNameList.push(helperCreatorName);
+
+            const genCustomHooksReact = c.proto.pluginValue(
+              "helperFunctions.hooks.react"
+            );
+
+            const genCustomHooksVue = c.proto.pluginValue(
+              "helperFunctions.hooks.vue"
+            );
+
+            // Store the mapping in builder
+            builder.addFunctionMapping(
+              bundlerFile.package,
+              svcKey,
+              methodKey,
+              helperCreatorName,
+              hookName,
+              svc.methods[methodKey].comment,
+              svc.methods[methodKey].requestType,
+              svc.methods[methodKey].responseType,
+              localname,
+              genCustomHooksReact ? localnameReact : undefined,
+              bundler.getLocalFilename(c.ref)
+            );
+
+            // gen helper funcs
+            asts.push(
+              createQueryHelperCreator(
+                ctx.generic,
+                svc.methods[methodKey],
+                svc.name,
+                methodKey,
+                helperCreatorName
+              )
+            );
+
+            if (genCustomHooksReact) {
+              // gen custom react hooks
+              reactAsts.push(
+                createQueryHooks(
+                  ctx.generic,
+                  svc.methods[methodKey],
+                  methodKey,
+                  helperCreatorName,
+                  hookName
+                )
+              );
+            }
+
+            if (genCustomHooksVue) {
+              // gen custom vue hooks
+              vueAsts.push(
+                createVueQueryHooks(
+                  ctx.generic,
+                  svc.methods[methodKey],
+                  methodKey,
+                  helperCreatorName,
+                  hookName
+                )
+              );
+            }
+          });
+        }
+      });
+
+      if (!asts.length) {
+        return;
+      }
+
+      const serviceImports = getDepsFromQueries(getImportsFrom, localname);
+      const serviceImportsReact = getDepsFromQueries(getImportsFrom, localnameReact);
+      const serviceImportsVue = getDepsFromQueries(getImportsFrom, localnameVue);
+
+      // add imports from func file like query.rpc.func.ts without the .ts extension
+      const funcFileName = "./".concat(localname.substring(localname.lastIndexOf("/") + 1).replace(/\.ts$/, ""));
+      serviceImportsReact[funcFileName] = helperCreatorNameList;
+      serviceImportsVue[funcFileName] = helperCreatorNameList;
+
+      // TODO we do NOT need all imports...
+      const imports = buildAllImports(ctx, serviceImports, localname);
+      const importsReact = buildAllImports(ctx, serviceImportsReact, localnameReact);
+      const importsVue = buildAllImports(ctx, serviceImportsVue, localnameReact);
+
+      const prog = [].concat(imports).concat(ctx.body).concat(asts);
+      const progReact = [].concat(importsReact).concat(reactAsts);
+      const progVue = [].concat(importsVue).concat(vueAsts);
+
+      const exportedTypeNames = getExportedTypeNames(prog);
+      const exportedTypeNamesReact = getExportedTypeNames(progReact);
+      const exportedTypeNamesVue = getExportedTypeNames(progVue);
+
+      exportedTypeNames.forEach((name) => {
+        builder.store.setHelperFuncFilesMapping(name, localname);
+      });
+      exportedTypeNamesReact.forEach((name) => {
+        builder.store.setHelperFuncFilesMapping(name, localnameReact);
+      });
+      exportedTypeNamesVue.forEach((name) => {
+        builder.store.setHelperFuncFilesMapping(name, localnameVue);
+      });
+
+      bundler.writeAst(prog, filename);
+      bundler.addExportObjToBundle(c.ref.proto.package, localname, exportedTypeNames, true);
+      if (reactAsts.length) {
+        bundler.writeAst(progReact, filenameReact);
+        bundler.addExportObjToBundle(c.ref.proto.package, localnameReact, exportedTypeNamesReact, true);
+      }
+      if (vueAsts.length) {
+        bundler.writeAst(progVue, filenameVue);
+        bundler.addExportObjToBundle(c.ref.proto.package, localnameVue, exportedTypeNamesVue, true);
+      }
+      bundler.addToBundle(c, localname);
+
+      return bundlerFile;
+    })
+    .filter(Boolean);
+};