@hyperweb/telescope 1.15.0

package/src/protod/utils.spec.ts

@@ -0,0 +1,68 @@
+import {
+  findAllProtoFiles,
+  getMainBranchName,
+  isPathExist,
+  parseProtoFile,
+} from "./utils";
+
+import { join } from "path";
+
+const TEST_DATA_FOLDER = "test-data";
+const TEST_DATA_NONE_FOLDER = "test-data-none";
+let testData = join(__dirname, TEST_DATA_FOLDER);
+let testDataNone = join(__dirname, TEST_DATA_NONE_FOLDER);
+
+const testSwitch = false;
+
+describe("Test `getMainBranchName`", () => {
+  (testSwitch ? it : it.skip)("`cosmos-proto` should return `main`", async () => {
+    const branch = await getMainBranchName(
+      "https://github.com/cosmos/cosmos-proto.git"
+    );
+    expect(branch).toBe("main");
+  });
+
+  (testSwitch ? it : it.skip)("`ics23` should return `master`", async () => {
+    const branch = await getMainBranchName(
+      "https://github.com/cosmos/ics23.git"
+    );
+    expect(branch).toBe("master");
+  });
+});
+
+describe("Test `parseProtoFile`", () => {
+  it("should successfully parse `./test-data/model.proto`", () => {
+    const [dep1, dep2] = parseProtoFile(join(testData, "/model.proto"));
+    expect(dep1).toBe("google/api/field_behavior.proto");
+    expect(dep2).toBe("google/api/resource.proto");
+  });
+});
+
+describe("Test `isPathExist`", () => {
+  it("`./test-data/buf.lock` should exist", () => {
+    const result = isPathExist(join(testData, "/buf.lock"));
+    expect(result).toBe(true);
+  });
+
+  it("`./test-data/fake/buf.lock` should not exist", () => {
+    const result = isPathExist(join(testData, "/fake/buf.lock"));
+    expect(result).toBe(false);
+  });
+
+  it("`./test-data` should exist", () => {
+    const result = isPathExist(testData);
+    expect(result).toBe(true);
+  });
+
+  it("`./test-data-none` should not exist", () => {
+    const result = isPathExist(testDataNone);
+    expect(result).toBe(false);
+  });
+});
+
+describe("Test `findAllProtoFiles`", () => {
+  it("`./test-data` should contain 2 proto files", () => {
+    const files = findAllProtoFiles(testData);
+    expect(files.length).toBe(2);
+  });
+});

package/src/protod/utils.ts

@@ -0,0 +1,90 @@
+import { exec as _exec } from "shelljs";
+import fs from "fs";
+import { bufInfo } from "./config";
+import { Repo } from "./types";
+import { crossGlob as glob } from '@cosmology/utils';
+
+export function exec(command: string, verbose = false) {
+  const { code, stdout, stderr } = _exec(command);
+  if (code === 0) {
+    if (verbose) {
+      console.log(stdout);
+    }
+  } else {
+    console.error(`Failed: ${command}`);
+    throw new Error(stderr);
+  }
+
+  return { stdout };
+}
+
+export async function getMainBranchName(url: string) {
+  console.log(`Checking main branch for ${url}`)
+
+  const { stdout } = exec(`git ls-remote -h ${url} main`);
+  if (stdout) {
+    return "main";
+  }
+  const { stdout: stdout2 } = exec(`git ls-remote -h ${url} master`);
+  if (stdout2) {
+    return "master";
+  }
+  throw new Error("Can't find `main` or `master` branch");
+}
+
+export function getCorrespondingGit(bufRepo: Repo): Repo[] {
+  const bufItem = bufInfo.find(
+    (repo) => repo.owner === bufRepo.owner && repo.repo === bufRepo.repo
+  );
+  if (bufItem) {
+    return bufItem.git;
+  } else {
+    return [bufRepo];
+  }
+}
+
+export function parseProtoFile(filePath: string): string[] {
+  if (!isPathExist(filePath)) {
+    console.warn(`No such file ${filePath}`);
+    return [];
+  }
+
+  let proto;
+
+  try {
+    proto = fs.readFileSync(filePath, "utf8");
+  } catch (error) {
+    console.log(filePath);
+    throw new Error(error);
+  }
+
+  const deps: string[] = [];
+  proto?.split("\n").forEach((line) => {
+    if (line.trim().startsWith("import ")) {
+      const dep = /import\s"(.+)";?/.exec(line)?.[1];
+      if (!dep) {
+        throw Error(`Failed to parse line: ${line}`);
+      }
+      deps.push(dep);
+    }
+  });
+  return deps;
+}
+
+export function isPathExist(path: string): boolean {
+  return fs.existsSync(path);
+}
+
+export function findAllProtoFiles(dir: string): string[] {
+  return glob(`${dir}/**/*.proto`, {
+    ignore: `${dir}/node_modules/**`,
+  });
+}
+
+export function removeFolder(dir: string) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+export function makeDir(dir: string) {
+  fs.mkdirSync(dir, { recursive: true });
+}

package/src/telescope.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { cli } from './cli';
+var argv = require('minimist')(process.argv.slice(2), {
+  boolean: ['ssh']
+});
+
+(async () => {
+  await cli(argv);
+})();

package/src/types.ts

@@ -0,0 +1,46 @@
+import { ImportDeclaration } from '@babel/types';
+import { ProtoServiceMethod, TelescopeOptions } from '@cosmology/types';
+export interface ExportObj {
+  pkg: string;
+  localname: string;
+  relativePath: string;
+  exportedIdentifiers: string[];
+  isHelperFunc?: boolean;
+}
+export interface Bundle {
+  bundleVariables: {};
+  bundleFile: string;
+  importPaths: ImportDeclaration[];
+  exportObjs?: ExportObj[];
+  base: string;
+}
+export interface BundlerFile {
+  proto?: string;
+  package?: string;
+  localname: string;
+  filename: string;
+  isMsg?: boolean;
+  instantExportedMethods?: ProtoServiceMethod[];
+}
+
+export interface ImportObj {
+  type: 'import' | 'default' | 'namespace' | string;
+  name: string;
+  path: string;
+  importAs?: string;
+  protoPath?: string;
+}
+export type UtilValue = ImportObj | string;
+
+export interface DerivedImportObj extends ImportObj {
+  orig: string;
+}
+export interface ImportHash {
+  [key: string]: string[];
+}
+
+export interface TelescopeInput {
+  protoDirs: string[];
+  outPath: string;
+  options: TelescopeOptions;
+}

package/src/utils/common-create-bundle.ts

@@ -0,0 +1,62 @@
+import { aggregateImports, getImportStatements } from '../imports';
+import { join } from 'path';
+import { TelescopeBuilder } from '../builder';
+import { GenericParseContext } from '@cosmology/ast';
+import { ProtoRef } from '@cosmology/types';
+import { TelescopeParseContext } from '../build';
+import { writeAstToFile } from '../utils/files';
+import { fixlocalpaths } from '../utils';
+import * as t from '@babel/types';
+import { createEmptyProtoRef } from '@cosmology/proto-parser';
+
+export const commonBundlePlugin = (
+  builder: TelescopeBuilder,
+  bundleFilename: string,
+  packageMappings: object,
+  astFn: (
+    context: GenericParseContext,
+    obj: object
+  ) => (
+    | t.ExportNamedDeclaration
+    | {
+      type: string;
+      importKind: string;
+      specifiers: {
+        type: string;
+        local: {
+          type: string;
+          name: string;
+        };
+      }[];
+      source: {
+        type: string;
+        value: string;
+      };
+    }
+  )[]
+) => {
+  const localname = bundleFilename;
+
+  // create proto ref for context
+  const pkg = '@root';
+  const ref: ProtoRef = createEmptyProtoRef(pkg, localname);
+
+  // create context
+  const pCtx = new TelescopeParseContext(ref, builder.store, builder.options);
+
+  // generate code for createRpcQueryHooks and imports of related packages.
+  const ast = astFn(pCtx.proto, packageMappings);
+
+  // generate imports added by context.addUtil
+  const imports = fixlocalpaths(aggregateImports(pCtx, {}, localname));
+  const importStmts = getImportStatements(localname, imports, builder.options);
+
+  // construct the AST
+  const prog = [].concat(importStmts).concat(ast);
+
+  // write the file.
+  const filename = join(builder.outPath, localname);
+  builder.files.push(localname);
+
+  writeAstToFile(builder.outPath, builder.options, prog, filename);
+};

package/src/utils/contracts.ts

@@ -0,0 +1,37 @@
+import { readSchemas } from '@cosmwasm/ts-codegen';
+import { pascal } from 'case';
+import { basename, dirname, join } from 'path';
+import { readFileSync, readdirSync } from 'fs';
+
+export const getDirectories = source =>
+    readdirSync(source, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+
+export const getContracts = () => {
+    const contracts = getDirectories('./contracts')
+        .map(contractDirname => {
+            return {
+                name: `${contractDirname}`,
+                value: `./contracts/${contractDirname}`
+            }
+        });
+    return contracts;
+};
+
+export const getContractSchemata = async (schemata: any[], out: string, argv) => {
+    const s = [];
+    for (let i = 0; i < schemata.length; i++) {
+        const path = schemata[i];
+        const pkg = JSON.parse(readFileSync(join(path, 'package.json'), 'utf-8'));
+        const name = basename(path);
+        const folder = basename(dirname(path));
+        const contractName = pascal(pkg.contract) || pascal(name);
+        const schemas = await readSchemas({ schemaDir: path });
+        const outPath = join(out, folder);
+        s.push({
+            contractName, schemas, outPath
+        });
+    }
+    return s;
+}

package/src/utils/files.ts

@@ -0,0 +1,145 @@
+import * as t from "@babel/types";
+import { parse, ParserPlugin } from "@babel/parser";
+import { TelescopeOptions } from "@cosmology/types";
+import { mkdirp } from "mkdirp";
+import { writeFileSync } from "fs";
+import { dirname } from "path";
+import minimatch from "minimatch";
+import generate from "@babel/generator";
+import { unused } from "./unused";
+import traverse from "@babel/traverse";
+import { toPosixPath } from "@cosmology/utils";
+
+export function getExportedTypeNames(program: t.Statement[]): string[] {
+  const exportedNames: string[] = [];
+  const ast = t.program(program);
+  const content = generate(ast).code;
+  const plugins: ParserPlugin[] = ["typescript"];
+  const newAst = parse(content, {
+    sourceType: "module",
+    plugins,
+  });
+
+  traverse(newAst, {
+    ExportNamedDeclaration(path) {
+      const node = path.node;
+
+      // Handle direct declarations (type aliases, interfaces, enums)
+      if (node.declaration) {
+        const decl = node.declaration;
+        const isTypeExport = node.exportKind === "type";
+        const isTypeDecl = [
+          "TSTypeAliasDeclaration",
+          "TSInterfaceDeclaration",
+          "TSEnumDeclaration",
+        ].includes(decl.type);
+
+        if (isTypeExport || isTypeDecl) {
+          if ("id" in decl && decl.id?.type === "Identifier") {
+            exportedNames.push(decl.id.name);
+          }
+        }
+
+        // Handle const declarations that might be types (e.g., const schemas)
+        if (decl.type === "VariableDeclaration" && decl.kind === "const") {
+          decl.declarations.forEach((declarator) => {
+            if (declarator.id?.type === "Identifier") {
+              exportedNames.push(declarator.id.name);
+            }
+          });
+        }
+      }
+
+      // Handle export specifiers (e.g., export { SomeType })
+      if (node.specifiers && node.specifiers.length > 0) {
+        const isTypeExport = node.exportKind === "type";
+        if (isTypeExport) {
+          node.specifiers.forEach((spec) => {
+            if (spec.type === "ExportSpecifier" && spec.exported.type === "Identifier") {
+              exportedNames.push(spec.exported.name);
+            }
+          });
+        }
+      }
+    },
+  });
+
+  return exportedNames;
+}
+
+export const writeAstToFile = (
+  outPath: string,
+  options: TelescopeOptions,
+  program: t.Statement[],
+  filename: string
+) => {
+  const ast = t.program(program);
+  const content = generate(ast).code;
+
+  if (options.removeUnusedImports) {
+    const plugins: ParserPlugin[] = ["typescript"];
+    const newAst = parse(content, {
+      sourceType: "module",
+      plugins,
+    });
+    traverse(newAst, unused);
+    const content2 = generate(newAst).code;
+    writeContentToFile(
+      toPosixPath(outPath),
+      options,
+      content2,
+      toPosixPath(filename)
+    );
+  } else {
+    writeContentToFile(
+      toPosixPath(outPath),
+      options,
+      content,
+      toPosixPath(filename)
+    );
+  }
+};
+
+export const writeContentToFile = (
+  outPath: string,
+  options: TelescopeOptions,
+  content: string,
+  filename: string
+) => {
+  let esLintPrefix = "";
+  let tsLintPrefix = "";
+
+  let nameWithoutPath = filename.replace(outPath, "");
+  // strip off leading slash
+  if (nameWithoutPath.startsWith("/"))
+    nameWithoutPath = nameWithoutPath.replace(/^\//, "");
+
+  options.tsDisable.patterns.forEach((pattern) => {
+    if (minimatch(nameWithoutPath, pattern)) {
+      tsLintPrefix = `//@ts-nocheck\n`;
+    }
+  });
+  options.eslintDisable.patterns.forEach((pattern) => {
+    if (minimatch(nameWithoutPath, pattern)) {
+      esLintPrefix = `/* eslint-disable */\n`;
+    }
+  });
+
+  if (
+    options.tsDisable.files.includes(nameWithoutPath) ||
+    options.tsDisable.disableAll
+  ) {
+    tsLintPrefix = `//@ts-nocheck\n`;
+  }
+
+  if (
+    options.eslintDisable.files.includes(nameWithoutPath) ||
+    options.eslintDisable.disableAll
+  ) {
+    esLintPrefix = `/* eslint-disable */\n`;
+  }
+
+  const text = tsLintPrefix + esLintPrefix + content;
+  mkdirp.sync(dirname(filename));
+  writeFileSync(filename, text);
+};

package/src/utils/index.ts

@@ -0,0 +1,150 @@
+import { ProtoRoot, ProtoRef } from '@cosmology/types';
+import { relative, dirname, extname } from 'path';
+import { ImportObj, UtilValue } from '../types';
+import { restoreExtension, toPosixPath } from '@cosmology/utils';
+
+export const getRoot = (ref: ProtoRef): ProtoRoot => {
+  if (ref.traversed) return ref.traversed;
+  return ref.proto;
+};
+
+// default example:
+// Long: { type: 'default', path: 'long', name: 'Long ' },
+// namespaced:
+// _m0: { type: 'namespace', path: 'protobufjs/minimal', name: '_m0' },
+export const UTILS: { [key: string]: UtilValue } = {
+  _m0: { type: 'namespace', path: 'protobufjs/minimal', name: '_m0' },
+  AminoHeight: '__helpers__',
+  AminoMsg: '@cosmjs/amino',
+  AminoTypes: '@cosmjs/stargate',
+  base64FromBytes: '__helpers__',
+  bytesFromBase64: '__helpers__',
+  BrowserHeaders: 'browser-headers',
+  connectComet: '@cosmjs/tendermint-rpc',
+  Decimal: '@cosmjs/math',
+  padDecimal: '__helpers__',
+  createProtobufRpcClient: '@cosmjs/stargate',
+  Pubkey: '@cosmjs/amino',
+  decodeBech32Pubkey: '@cosmjs/amino',
+  DeepPartial: '__helpers__',
+  defaultRegistryTypes: '@cosmjs/stargate',
+  encodeBech32Pubkey: '@cosmjs/amino',
+  Exact: '__helpers__',
+  fm: { type: 'namespace', path: '__grpc-gateway__', name: 'fm' },
+  encodePubkey: '@cosmjs/proto-signing',
+  decodePubkey: '@cosmjs/proto-signing',
+  fromBase64: '@cosmjs/encoding',
+  fromBech32: '@cosmjs/encoding',
+  fromDuration: '__helpers__',
+  fromHex: '@cosmjs/encoding',
+  fromJsonTimestamp: '__helpers__',
+  fromTimestamp: '__helpers__',
+  fromUtf8: '@cosmjs/encoding',
+  GeneratedType: '@cosmjs/proto-signing',
+  createTm34QueryClient: '__extern__',
+  createConnectCometQueryClient: '__extern__',
+  getRpcClient: '__extern__',
+  createRpcClient: '__extern__',
+  getRpcEndpointKey: '__extern__',
+  HttpEndpoint: '@cosmjs/tendermint-rpc',
+  isObject: '__helpers__',
+  isSet: '__helpers__',
+  LCDClient: '@cosmology/lcd',
+  Long: '__helpers__',
+  OfflineSigner: '@cosmjs/proto-signing',
+  omitDefault: '__helpers__',
+  ProtobufRpcClient: '@cosmjs/stargate',
+  QueryClient: '@cosmjs/stargate',
+  Registry: '@cosmjs/proto-signing',
+  Rpc: '__helpers__',
+  StdFee: '__types__',
+  TxRpc: '__types__',
+  BroadcastTxReq: '__types__',
+  BroadcastTxRes: '__types__',
+  DeliverTxResponse: '__types__',
+  EncodeObject: '__types__',
+  SigningClientParams: '__types__',
+  grpc: '@improbable-eng/grpc-web',
+  setPaginationParams: '__helpers__',
+  SigningStargateClient: '@cosmjs/stargate',
+  Tendermint34Client: '@cosmjs/tendermint-rpc',
+  toBase64: '@cosmjs/encoding',
+  toDuration: '__helpers__',
+  toTimestamp: '__helpers__',
+  toUtf8: '@cosmjs/encoding',
+  useQuery: '@tanstack/react-query',
+  ComputedRef: 'vue',
+  computed: 'vue',
+  Ref: 'vue',
+  useRpcEndpoint: '__react-query__',
+  useRpcClient: '__react-query__',
+  useTendermintClient: '__react-query__',
+  ReactQueryParams: '__react-query__',
+  buildUseMutation:'__react-query__',
+  UseQueryParams:'__react-query__',
+  buildUseQuery:'__react-query__',
+  UseQueryOptions: '@tanstack/react-query',
+  buildUseVueMutation:'__vue-query__',
+  buildUseVueQuery:'__vue-query__',
+  QueryStore: '__mobx__',
+  MobxResponse: '__mobx__',
+  useEndpoint: '__pinia-endpoint__',
+  JsonSafe: '__json-safe__',
+  override: 'mobx',
+  makeObservable: 'mobx',
+  NodeHttpTransport: '@improbable-eng/grpc-web-node-http-transport',
+  UnaryMethodDefinitionishR: '__grpc-web__',
+  UnaryMethodDefinitionish: '__grpc-web__',
+  BinaryReader: '__binary__',
+  BinaryWriter: '__binary__',
+  TelescopeGeneratedType: '__types__',
+  GlobalDecoderRegistry: '__registry__',
+  buildTx:'__helper-func-types__',
+  ISigningClient:'__helper-func-types__',
+  buildQuery:'__helper-func-types__',
+  EndpointOrRpc:'__helper-func-types__',
+  toConverters:'@interchainjs/cosmos/utils',
+  toEncoders:'@interchainjs/cosmos/utils'
+};
+
+export const UTIL_HELPERS = [
+  '__helpers__',
+  '__extern__',
+  '__react-query__',
+  '__vue-query__',
+  '__mobx__',
+  '__binary__',
+  '__pinia-endpoint__',
+  '__json-safe__',
+  '__grpc-gateway__',
+  '__grpc-web__',
+  '__types__',
+  '__registry__',
+  '__decimals__',
+  '__helper-func-types__'
+];
+
+export const fixlocalpaths = (imports: ImportObj[]) => {
+  return imports.map((imp) => {
+    const fixedPath = toPosixPath(imp.path);
+    return {
+      ...imp,
+      path:
+        UTIL_HELPERS.includes(imp.path) ||
+        imp.path.startsWith('.') ||
+        imp.path.startsWith('@')
+          ? fixedPath
+          : `./${fixedPath}`,
+    };
+  });
+};
+
+export const getRelativePath = (f1: string, f2: string, ext?: string) => {
+  const rel = relative(dirname(f1), f2);
+  let importPath = rel.replace(extname(rel), '');
+  if (!/^\./.test(importPath)) importPath = `./${importPath}`;
+  importPath = toPosixPath(importPath);
+  return restoreExtension(importPath, ext);
+};
+
+export * from './common-create-bundle';

package/src/utils/unused.ts

@@ -0,0 +1,52 @@
+//@ts-nocheck
+
+import * as t from '@babel/types';
+
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import/blob/c5454c21e94698a2464a12baa5590761932a71a8/License#L1
+
+export const unused = {
+  Program: {
+    exit: (path) => {
+      const UnRefBindings = new Map()
+      for (const [name, binding] of Object.entries(path.scope.bindings)) {
+        if (!binding.path.parentPath || binding.kind !== 'module') continue
+
+        const source = binding.path.parentPath.get('source')
+        const importName = source.node.value
+        if (
+          !t.isStringLiteral(source)
+        )
+          continue
+
+        const key = `${importName}(${source.node.loc &&
+          source.node.loc.start.line})`
+
+        if (!UnRefBindings.has(key)) {
+          UnRefBindings.set(key, binding)
+        }
+
+        if (binding.referenced) {
+          UnRefBindings.set(key, null)
+        } else {
+          const nodeType = binding.path.node.type
+          if (nodeType === 'ImportSpecifier') {
+            binding.path.remove()
+          } else if (nodeType === 'ImportDefaultSpecifier') {
+            binding.path.remove()
+          } else if (nodeType === 'ImportNamespaceSpecifier') {
+            binding.path.remove()
+          } else if (binding.path.parentPath) {
+            binding.path.parentPath.remove()
+          }
+        }
+      }
+
+      UnRefBindings.forEach((binding, key) => {
+        if (binding && binding.path.parentPath) {
+          binding.path.parentPath.remove()
+        }
+      })
+    }
+  }
+};