@hyperweb/telescope 1.15.0

package/src/builder.ts

@@ -0,0 +1,302 @@
+import { ProtoStore } from '@cosmology/proto-parser';
+import { TelescopeParseContext } from './build';
+import { TelescopeOptions, defaultTelescopeOptions } from '@cosmology/types';
+import { toPosixPath } from '@cosmology/utils';
+import { bundlePackages } from './bundle';
+import { BundlerFile, TelescopeInput } from './types';
+import { Bundler } from './bundler';
+import deepmerge from 'deepmerge';
+import { resolve } from 'path';
+
+import { plugin as createTypes } from './generators/create-types';
+import { plugin as createAminoConverters } from './generators/create-amino-converters';
+import { plugin as createRegistries } from './generators/create-registries';
+import { plugin as createLCDClients } from './generators/create-lcd-clients';
+import { plugin as createAggregatedLCDClient } from './generators/create-aggregated-lcd-client';
+import { plugin as createLCDClientsScoped } from './generators/create-lcd-client-scoped';
+import { plugin as createLCDClientsAll } from './generators/create-lcd-client-all';
+import { plugin as createRPCQueryClientsScoped } from './generators/create-rpc-query-client-scoped';
+import { plugin as createRPCQueryClientsAll } from './generators/create-rpc-query-client-all';
+import { plugin as createRPCMsgClientsScoped } from './generators/create-rpc-msg-client-scoped';
+import { plugin as createRPCMsgClientsAll } from './generators/create-rpc-msg-client-all';
+import { plugin as createRPCQueryClients } from './generators/create-rpc-query-clients';
+import { plugin as createRPCMsgClients } from './generators/create-rpc-msg-clients';
+import { plugin as createQueryFuncs } from './generators/create-query-funcs';
+import { plugin as createMsgFuncs } from './generators/create-msg-funcs';
+import { plugin as createReactQueryBundle } from './generators/create-react-query-bundle';
+import { plugin as createMobxBundle } from './generators/create-mobx-bundle';
+import { plugin as createStargateClients } from './generators/create-stargate-clients';
+import { plugin as createCustomStargateClients } from './generators/create-custom-stargate-clients';
+import { plugin as createAllStargateClients } from './generators/create-all-stargate-clients';
+import { plugin as createSdkModuleStargateClients } from './generators/create-sdk-module-stargate-clients';
+import { plugin as createBundle } from './generators/create-bundle';
+import { plugin as createIndex } from './generators/create-index';
+import { plugin as createHelpers } from './generators/create-helpers';
+import { plugin as createCosmWasmBundle } from './generators/create-cosmwasm-bundle';
+import { plugin as createPiniaStore } from './generators/create-pinia-store';
+import { plugin as createPiniaStoreBundle } from './generators/create-pinia-store-bundle';
+import { plugin as createRpcOpsBundle } from './generators/create-rpc-ops-bundle';
+import { plugin as customizeUtils } from './generators/customize-utils';
+import { plugin as createRootReadme } from './generators/create-root-readme';
+import { plugin as createMcpServer } from './generators/create-mcp-server';
+
+const sanitizeOptions = (options: TelescopeOptions): TelescopeOptions => {
+  // If an element at the same key is present for both x and y, the value from y will appear in the result.
+  options = deepmerge(defaultTelescopeOptions, options ?? {});
+  // correct the path for windows
+  if (options.cosmwasm) {
+    options.cosmwasm.outPath = toPosixPath(options.cosmwasm.outPath);
+    options.cosmwasm.contracts = options.cosmwasm.contracts.map(
+      (item: { name: string; dir: string }) => {
+        item.dir = toPosixPath(item.dir);
+        return item;
+      }
+    );
+  }
+  // strip off leading slashes
+  options.tsDisable.files = options.tsDisable.files.map((file) =>
+    file.startsWith('/') ? file : file.replace(/^\//, '')
+  );
+  options.eslintDisable.files = options.eslintDisable.files.map((file) =>
+    file.startsWith('/') ? file : file.replace(/^\//, '')
+  );
+  // uniq bc of deepmerge
+  options.rpcClients.enabledServices = [
+    ...new Set([...options.rpcClients.enabledServices]),
+  ];
+  return options;
+};
+
+export class TelescopeBuilder {
+  store: ProtoStore;
+  protoDirs: string[];
+  outPath: string;
+  options: TelescopeOptions;
+  contexts: TelescopeParseContext[] = [];
+  files: string[] = [];
+
+  readonly converters: BundlerFile[] = [];
+  readonly lcdClients: BundlerFile[] = [];
+  readonly rpcQueryClients: BundlerFile[] = [];
+  readonly rpcMsgClients: BundlerFile[] = [];
+  readonly registries: BundlerFile[] = [];
+  readonly stateManagers: Record<string, BundlerFile[]> = {};
+
+  // Function mapping storage: package -> service -> method -> functionName
+  readonly functionMappings: Record<string, Record<string, Record<string, {
+    functionName: string;
+    hookName: string;
+    comment?: string;
+    requestType: string;
+    responseType: string;
+    sourceFilename?: string;
+    hookSourceFilename?: string;
+    typeSourceFilename?: string;
+  }>>> = {};
+
+  constructor({
+    protoDirs,
+    outPath,
+    store,
+    options,
+  }: TelescopeInput & { store?: ProtoStore }) {
+    const fixedDirs = protoDirs.map((directory) => {
+      return toPosixPath(directory);
+    });
+
+    this.protoDirs = fixedDirs;
+    this.outPath = resolve(toPosixPath(outPath));
+    this.options = sanitizeOptions(options);
+    this.store = store ?? new ProtoStore(fixedDirs, this.options);
+    this.store.traverseAll();
+
+  }
+
+  context(ref) {
+    const ctx = new TelescopeParseContext(ref, this.store, this.options);
+    this.contexts.push(ctx);
+    return ctx;
+  }
+
+  addFunctionMapping(
+    packageName: string,
+    serviceName: string,
+    methodName: string,
+    functionName: string,
+    hookName: string,
+    comment?: string,
+    requestType?: string,
+    responseType?: string,
+    sourceFilename?: string,
+    hookSourceFilename?: string,
+    typeSourceFilename?: string
+  ) {
+    if (!this.functionMappings[packageName]) {
+      this.functionMappings[packageName] = {};
+    }
+    if (!this.functionMappings[packageName][serviceName]) {
+      this.functionMappings[packageName][serviceName] = {};
+    }
+
+    this.functionMappings[packageName][serviceName][methodName] = {
+      functionName,
+      hookName,
+      comment,
+      requestType,
+      responseType,
+      sourceFilename,
+      hookSourceFilename,
+      typeSourceFilename
+    };
+  }
+
+  getFunctionMappings() {
+    return this.functionMappings;
+  }
+
+  addStateManagers(type: string, files: BundlerFile[]) {
+    const state = this.stateManagers[type];
+
+    if (!state) {
+      this.stateManagers[type] = [];
+    }
+
+    [].push.apply(this.stateManagers[type], files);
+  }
+
+  addRPCQueryClients(files: BundlerFile[]) {
+    [].push.apply(this.rpcQueryClients, files);
+  }
+
+  addRPCMsgClients(files: BundlerFile[]) {
+    [].push.apply(this.rpcMsgClients, files);
+  }
+
+  addLCDClients(files: BundlerFile[]) {
+    [].push.apply(this.lcdClients, files);
+  }
+
+  addRegistries(files: BundlerFile[]) {
+    [].push.apply(this.registries, files);
+  }
+
+  addConverters(files: BundlerFile[]) {
+    [].push.apply(this.converters, files);
+  }
+
+
+
+
+  async build() {
+    // check warnings
+    if (
+      !this.options.aminoEncoding?.enabled &&
+      (this.options.prototypes?.methods?.fromAmino ||
+        this.options.prototypes?.methods?.toAmino)
+    ) {
+      console.warn(
+        "There could be compilation errors in generated code, because 'aminoEncoding.enabled: false' means amino types wouldn't be created, but 'toAmino' or 'fromAmino' need amino types."
+      );
+    }
+
+    if (!this.options.prototypes.methods.fromPartial) {
+      console.warn(
+        "The 'fromPartial' option will be deprecated in a future version. Encoder objects need fromPartial to be a creator function to create instance of the type. So it should always be left on, otherwise there could be compilation errors in generated code."
+      );
+    }
+
+    customizeUtils(this);
+
+    const allConverters = [];
+    const allRegistries = [];
+    // [x] get bundle of all packages
+    const bundles = bundlePackages(this.store).map((bundle) => {
+      // store bundleFile in filesToInclude
+      const bundler = new Bundler(this, bundle);
+
+
+      // [x] write out all TS files for package
+      createTypes(this, bundler);
+
+      // [x] write out one amino helper for all contexts w/mutations
+      createAminoConverters(this, bundler);
+
+      // [x] write out one registry helper for all contexts w/mutations
+      createRegistries(this, bundler);
+
+      // [x] write out one registry helper for all contexts w/mutations
+      createLCDClients(this, bundler);
+
+      createQueryFuncs(this, bundler);
+      createRPCQueryClients(this, bundler);
+      createMsgFuncs(this, bundler);
+      createRPCMsgClients(this, bundler);
+      createPiniaStore(this, bundler);
+
+      if (this.options.rpcClients.clientStyle.useUpdatedClientStyle) {
+        // generate sdk-module client file
+        if (this.options.rpcClients.clientStyle.type.includes('sdk-module-client') && this.options.rpcClients.clientStyle.sdkModuleClientOption.includes(bundler.bundle.base)) {
+          createSdkModuleStargateClients(this, bundler)
+        }
+
+        // store registry and converter for all/custom client generation
+        if (bundler.registries) {
+          allRegistries.push(...bundler.registries)
+        }
+        if (bundler.converters) {
+          allConverters.push(...bundler.converters)
+        }
+      } else {
+        // [x] write out one client for each base package, referencing the last two steps
+        createStargateClients(this, bundler);
+      }
+      return bundler;
+    });
+
+    if (this.options.rpcClients.clientStyle.useUpdatedClientStyle) {
+      // generate cutsom client file
+      if (this.options.rpcClients.clientStyle.type.includes('custom-client') && this.options.rpcClients.clientStyle.customClientOption && this.options.rpcClients.clientStyle.customClientOption.length !== 0) {
+        createCustomStargateClients(this, allRegistries, allConverters)
+      }
+      // generate all module client file
+      if (this.options.rpcClients.clientStyle.type.includes('all-client')) {
+        createAllStargateClients(this, allRegistries, allConverters)
+      }
+    }
+
+    // post run plugins
+    bundles.forEach((bundler) => {
+      createLCDClientsAll(this, bundler);
+      createLCDClientsScoped(this, bundler);
+      createRPCQueryClientsAll(this, bundler);
+      createRPCQueryClientsScoped(this, bundler);
+      createRPCMsgClientsAll(this, bundler);
+      createRPCMsgClientsScoped(this, bundler);
+      createBundle(this, bundler);
+    });
+
+    createRpcOpsBundle(this);
+    createReactQueryBundle(this);
+    createMobxBundle(this);
+    createAggregatedLCDClient(this);
+    await createCosmWasmBundle(this);
+
+    createHelpers(this);
+    createPiniaStoreBundle(this);
+
+    // finally, write one index file with all files, exported
+    createIndex(this);
+    createRootReadme(this);
+
+    // Generate MCP server at the very end after all files are written
+    if (this.options.mcpServer?.enabled && bundles.length > 0) {
+      // Use the first bundle that has contexts (typically the main aggregated bundle)
+      const primaryBundle = bundles.find(bundler => bundler.contexts.length > 0);
+      if (primaryBundle) {
+        createMcpServer(this, primaryBundle);
+      }
+    }
+
+    console.log(`✨ files transpiled in '${this.outPath}'`);
+  }
+}

package/src/bundle.ts

@@ -0,0 +1,160 @@
+import { ProtoStore, isRefExcluded, createEmptyProtoRef } from '@cosmology/proto-parser';
+import { importNamespace } from '@cosmology/ast';
+import * as dotty from 'dotty';
+import { TelescopeBuilder } from './index';
+import { join, relative, dirname } from 'path';
+import { TelescopeParseContext } from './build';
+import { TelescopeOptions } from '@cosmology/types';
+import { toPosixPath } from '@cosmology/utils';
+
+// TODO move to store
+export const getPackages = (store: ProtoStore) => {
+    return store.getProtos().reduce((m, proto) => {
+        if (proto.proto.package) {
+            m[proto.proto.package] = m[proto.proto.package] || []
+            m[proto.proto.package].push(proto);
+        }
+        return m;
+    }, {});
+}
+
+export const getPackagesBundled = (store: ProtoStore) => {
+    const objectified = {};
+    const pkgs = getPackages(store);
+    Object.keys(pkgs).forEach(key => {
+        if (isRefExcluded(createEmptyProtoRef(key), store.options.prototypes?.excluded)) return;
+        const files = pkgs[key];
+        dotty.put(objectified, key, {
+            pkg: key,
+            files: files.filter(file => {
+                return !isRefExcluded(createEmptyProtoRef(key, file.filename), store.options.prototypes?.excluded);
+            })
+        });
+    });
+    return objectified;
+
+}
+
+export const bundlePackages = (store: ProtoStore) => {
+    const allPackages = getPackagesBundled(store);
+    return Object.keys(allPackages).map(base => {
+        const pkgs = allPackages[base];
+        const bundleVariables = {};
+        const bundleFile = toPosixPath(join(base, 'bundle.ts'));
+        const importPaths = [];
+        parsePackage(store.options, pkgs, bundleFile, importPaths, bundleVariables);
+        return {
+            bundleVariables,
+            bundleFile,
+            importPaths,
+            base
+        };
+    });
+};
+
+// TODO review bundle registry methods
+export const bundleRegistries = (telescope: TelescopeBuilder) => {
+    const withMutations = telescope.contexts.filter(
+        ctx => ctx.mutations.length
+    );
+    const obj = withMutations.reduce((m, ctx) => {
+        m[ctx.ref.proto.package] = m[ctx.ref.proto.package] ?? [];
+        m[ctx.ref.proto.package].push(ctx);
+        return m;
+    }, {});
+
+    return Object.entries(obj)
+        .map(([pkg, serviceProtos]) => {
+            return {
+                package: pkg,
+                contexts: serviceProtos
+            };
+        });
+}
+
+export const bundleBaseRegistries = (telescope: TelescopeBuilder) => {
+    const withMutations = telescope.contexts.filter(
+        ctx => ctx.mutations.length
+    );
+    const obj = withMutations.reduce((m, ctx) => {
+        const base = ctx.ref.proto.package.split('.')[0];
+        m[base] = m[base] ?? {};
+        m[base][ctx.ref.proto.package] = m[base][ctx.ref.proto.package] ?? [];
+        m[base][ctx.ref.proto.package].push(ctx);
+        return m;
+    }, {});
+
+    return Object.entries(obj)
+        .map(([pkg, withServices]) => {
+
+            const serviceProtos = Object.entries(withServices)
+                .map(([pkg, withServices]) => {
+                    return {
+                        package: pkg,
+                        contexts: withServices
+                    }
+                });
+
+
+            return {
+                base: pkg,
+                pkgs: serviceProtos
+            };
+        });
+};
+
+export const parseContextsForRegistry = (contexts: TelescopeParseContext[]) => {
+    return contexts.map((ctx: TelescopeParseContext) => {
+        const responses = ctx.mutations.map(m => m.response)
+        const imports = ctx.mutations.reduce((m, msg) => {
+            m[msg.messageImport] = m[msg.messageImport] ?? [];
+            m[msg.messageImport].push(msg.message);
+            return m;
+        }, {})
+
+        return {
+            filename: ctx.ref.filename,
+            imports,
+            objects: ctx.types
+                .filter(type => !type.isNested)
+                .filter(type => !responses.includes(type.name))
+                .map(type => type.name)
+        }
+    });
+};
+
+export const parsePackage = (
+    options: TelescopeOptions,
+    obj,
+    bundleFile,
+    importPaths,
+    bundleVariables
+) => {
+    if (!obj) return;
+    if (obj.pkg && obj.files) {
+        obj.files.forEach(file => {
+            createFileBundle(options, obj.pkg, file.filename, bundleFile, importPaths, bundleVariables);
+        });
+        return;
+    }
+    Object.keys(obj).forEach(mini => {
+        parsePackage(options, obj[mini], bundleFile, importPaths, bundleVariables);
+    })
+}
+
+let counter = 0;
+export const createFileBundle = (
+    options: TelescopeOptions,
+    pkg,
+    filename,
+    bundleFile,
+    importPaths,
+    bundleVariables
+) => {
+    let rel = relative(dirname(bundleFile), filename);
+    if (!rel.startsWith('.')) rel = `./${rel}`;
+    const variable = `_${counter++}`;
+    importPaths.push(importNamespace(variable, toPosixPath(rel)));
+    dotty.put(bundleVariables, pkg + '.__export', true);
+    dotty.put(bundleVariables, pkg + '.' + variable, true);
+}

package/src/bundler.ts

@@ -0,0 +1,153 @@
+import * as t from "@babel/types";
+import { resolve, join, dirname, relative, extname } from "path";
+import { TelescopeParseContext } from "./build";
+import { createFileBundle } from "./bundle";
+import { TelescopeBuilder } from "./builder";
+import { ProtoRef } from "@cosmology/types";
+import { Bundle, BundlerFile } from "./types";
+import { writeAstToFile } from "./utils/files";
+import { toPosixPath } from "@cosmology/utils";
+
+export class Bundler {
+  builder: TelescopeBuilder;
+
+  contexts: TelescopeParseContext[] = [];
+  bundle: Bundle;
+  files: string[];
+
+  readonly converters: BundlerFile[] = [];
+  readonly lcdClients: BundlerFile[] = [];
+  readonly rpcQueryClients: BundlerFile[] = [];
+  readonly rpcMsgClients: BundlerFile[] = [];
+  readonly registries: BundlerFile[] = [];
+  readonly stateManagers: Record<string, BundlerFile[]> = {};
+
+  constructor(builder: TelescopeBuilder, bundle: Bundle) {
+    this.builder = builder;
+    this.bundle = bundle;
+    this.files = [bundle.bundleFile];
+  }
+
+  addStateManagers(type: string, files: BundlerFile[]) {
+    const state = this.stateManagers[type];
+
+    if (!state) {
+      this.stateManagers[type] = [];
+    }
+
+    [].push.apply(this.stateManagers[type], files);
+
+    this.builder.addStateManagers(type, files);
+  }
+
+  addLCDClients(files: BundlerFile[]) {
+    [].push.apply(this.lcdClients, files);
+    this.builder.addLCDClients(files);
+  }
+
+  addRPCQueryClients(files: BundlerFile[]) {
+    [].push.apply(this.rpcQueryClients, files);
+    this.builder.addRPCQueryClients(files);
+  }
+
+  addRPCMsgClients(files: BundlerFile[]) {
+    [].push.apply(this.rpcMsgClients, files);
+    this.builder.addRPCMsgClients(files);
+  }
+
+  addRegistries(files: BundlerFile[]) {
+    [].push.apply(this.registries, files);
+    this.builder.addRegistries(files);
+  }
+
+  addConverters(files: BundlerFile[]) {
+    [].push.apply(this.converters, files);
+    this.builder.addConverters(files);
+  }
+
+  getFreshContext(context: TelescopeParseContext) {
+    return new TelescopeParseContext(
+      context.ref,
+      context.store,
+      this.builder.options
+    );
+  }
+
+  getLocalFilename(ref: ProtoRef, suffix?: string) {
+    return suffix
+      ? ref.filename.replace(/\.proto$/, `.${suffix}.ts`)
+      : ref.filename.replace(/\.proto$/, `.ts`);
+  }
+
+  getFilename(localname: string) {
+    return resolve(join(this.builder.outPath, localname));
+  }
+
+  writeAst(program: t.Statement[], filename: string) {
+    writeAstToFile(
+      this.builder.outPath,
+      this.builder.options,
+      program,
+      filename
+    );
+  }
+
+  // addToBundle adds the path into the namespaced bundle object
+  addToBundle(context: TelescopeParseContext, localname: string) {
+    createFileBundle(
+      this.builder.options,
+      context.ref.proto.package,
+      localname,
+      this.bundle.bundleFile,
+      this.bundle.importPaths,
+      this.bundle.bundleVariables
+    );
+  }
+
+  addToBundleToPackage(packagename: string, localname: string) {
+    createFileBundle(
+      this.builder.options,
+      packagename,
+      localname,
+      this.bundle.bundleFile,
+      this.bundle.importPaths,
+      this.bundle.bundleVariables
+    );
+  }
+
+  addExportObjToBundle(
+    pkg: string,
+    localname: string,
+    exportedIdentifiers: string[],
+    isHelperFunc?: boolean
+  ) {
+    if (!this.bundle.exportObjs) {
+      this.bundle.exportObjs = [];
+    }
+
+    let rel = relative(dirname(this.bundle.bundleFile), localname);
+    if (!rel.startsWith(".")) rel = `./${rel}`;
+    rel = toPosixPath(rel);
+    rel = rel.replace(extname(rel), "");
+
+    const existing = this.bundle.exportObjs.find(
+      (e) => e.localname === localname
+    );
+
+    if (existing) {
+      // use Set to avoid duplicates
+      existing.exportedIdentifiers = [
+        ...new Set([...existing.exportedIdentifiers, ...exportedIdentifiers]),
+      ];
+      return;
+    }
+
+    this.bundle.exportObjs.push({
+      localname,
+      relativePath: rel,
+      exportedIdentifiers: [...new Set(exportedIdentifiers)],
+      isHelperFunc,
+      pkg,
+    });
+  }
+}

package/src/cli.js

@@ -0,0 +1,51 @@
+import { prompt } from './prompt';
+import { Commands as commands } from './cmds';
+import { Contracts as contracts } from './cmds';
+import * as pkg from '../package.json';
+
+export const cli = async (argv) => {
+  if (argv.v || argv.version) {
+    console.log(pkg.version);
+    return;
+  }
+
+  if (argv.contract) {
+    const { cmd } = await prompt(
+      [
+        {
+          _: true,
+          type: 'fuzzy',
+          name: 'cmd',
+          message: 'what do you want to do?',
+          choices: Object.keys(contracts)
+        }
+      ],
+      argv
+    );
+    if (typeof contracts[cmd] === 'function') {
+      await contracts[cmd](argv);
+    } else {
+      console.log('command not found.');
+    }
+    return;
+  }
+
+  console.log(`Telescope ${pkg.version}`);
+  const { cmd } = await prompt(
+    [
+      {
+        _: true,
+        type: 'fuzzy',
+        name: 'cmd',
+        message: 'what do you want to do?',
+        choices: Object.keys(commands)
+      }
+    ],
+    argv
+  );
+  if (typeof commands[cmd] === 'function') {
+    await commands[cmd](argv);
+  } else {
+    console.log('command not found.');
+  }
+};

package/src/cmds.js

@@ -0,0 +1,25 @@
+import _commands_generate from './commands/generate';
+import _commands_install from './commands/install';
+import _commands_download from './commands/download';
+import _commands_transpile from './commands/transpile';
+const Commands = {};
+Commands['generate'] = _commands_generate;
+Commands['install'] = _commands_install;
+Commands['download'] = _commands_download;
+Commands['transpile'] = _commands_transpile;
+
+export { Commands };
+
+import _contracts_generate from './contracts/generate';
+import _contracts_install from './contracts/install';
+import _contracts_message_composer from './contracts/message-composer';
+import _contracts_react_query from './contracts/react-query';
+import _contracts_recoil from './contracts/recoil';
+const Contracts = {};
+Contracts['generate'] = _contracts_generate;
+Contracts['install'] = _contracts_install;
+Contracts['message-composer'] = _contracts_message_composer;
+Contracts['react-query'] = _contracts_react_query;
+Contracts['recoil'] = _contracts_recoil;
+
+export { Contracts };