@hyperweb/telescope 1.15.0

package/src/generators/create-custom-stargate-clients.ts

@@ -0,0 +1,128 @@
+import { Bundler } from '../bundler';
+import { TelescopeBuilder } from '../builder';
+import { join, dirname, relative } from 'path';
+import {
+    importNamespace,
+    GenericParseContext,
+    createStargateClient,
+    createStargateClientOptions,
+    createStargateClientProtoRegistry,
+    createStargateClientAminoRegistry,
+    createGetTxRpc
+} from '@cosmology/ast';
+import { ProtoRef } from '@cosmology/types';
+import { camel, pascal } from 'case';
+import { duplicateImportPathsWithExt, variableSlug, toPosixPath, isPackageIncluded } from '@cosmology/utils';
+import { buildAllImportsFromGenericContext } from '../imports';
+import { writeAstToFile } from '../utils/files';
+import { BundlerFile } from '../types';
+
+export const plugin = (
+    builder: TelescopeBuilder,
+    allRegistries: BundlerFile[],
+    allConverters: BundlerFile[]
+) => {
+    builder.options.rpcClients.clientStyle.customClientOption.map((currentClient) => {
+
+        if (!allRegistries || !allRegistries.length) {
+            return;
+        }
+
+        const registryImports = [];
+        const converterImports = [];
+
+        const clientFile = currentClient.fileName
+        builder.files.push(clientFile);
+        const ctxRef: ProtoRef = {
+            absolute: '/',
+            filename: '/',
+            proto: {
+                imports: [],
+                package: currentClient.name,
+                root: {},
+            }
+        };
+        const ctx = new GenericParseContext(ctxRef, null, builder.options);
+
+        const registryVariables = [];
+        const converterVariables = [];
+        const filteredRegistries = allRegistries.filter(item =>
+            isPackageIncluded(item.package, currentClient.include.patterns)
+        );
+        filteredRegistries.forEach(registry => {
+            let rel = relative(dirname(clientFile), registry.localname);
+            if (!rel.startsWith('.')) rel = `./${rel}`;
+            rel = toPosixPath(rel)
+            const variable = variableSlug(registry.localname);
+            registryVariables.push(variable);
+            registryImports.push(importNamespace(variable, rel));
+        });
+
+        const filteredConverters = allConverters.filter(item =>
+            isPackageIncluded(item.package, currentClient.include.patterns)
+        );
+        filteredConverters.forEach(converter => {
+            let rel = relative(dirname(clientFile), converter.localname);
+            if (!rel.startsWith('.')) rel = `./${rel}`;
+            rel = toPosixPath(rel)
+            const variable = variableSlug(converter.localname);
+            converterVariables.push(variable);
+            converterImports.push(importNamespace(variable, rel));
+        });
+        const name = 'get' + pascal(currentClient.name + 'SigningClient');
+        const txRpcName = 'get' + pascal(currentClient.name + 'SigningTxRpc');
+        const prefix = camel(currentClient.name);
+        const aminos = createStargateClientAminoRegistry({
+            context: ctx,
+            aminos: converterVariables,
+            aminoConverters: prefix + 'AminoConverters'
+        });
+        const protos = createStargateClientProtoRegistry({
+            context: ctx,
+            registries: registryVariables,
+            protoTypeRegistry: prefix + 'ProtoRegistry'
+        });
+        const clientOptions = createStargateClientOptions({
+            context: ctx,
+            name: name + 'Options',
+            protoTypeRegistry: prefix + 'ProtoRegistry',
+            aminoConverters: prefix + 'AminoConverters'
+        });
+        const clientBody = createStargateClient({
+            context: ctx,
+            name,
+            options: name + 'Options',
+        });
+
+        let getTxRpc;
+
+        if (ctx.pluginValue("stargateClients.addGetTxRpc")) {
+            getTxRpc = createGetTxRpc(ctx, txRpcName, name);
+        }
+
+        const imports = buildAllImportsFromGenericContext(ctx, clientFile);
+
+        let importDecls = [...imports, ...registryImports, ...converterImports];
+
+        importDecls = 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 = toPosixPath(cProg[i].source?.value)
+            }
+        }
+
+        if (getTxRpc) {
+            cProg = cProg.concat(getTxRpc);
+        }
+        const clientOutFile = join(builder.outPath, clientFile);
+        writeAstToFile(builder.outPath, builder.options, cProg, clientOutFile);
+    })
+};

package/src/generators/create-helpers.ts

@@ -0,0 +1,196 @@
+import { join, dirname } from "path";
+import { mkdirp } from "mkdirp";
+import { TelescopeBuilder } from "../builder";
+import pkg from "../../package.json";
+import { writeContentToFile } from "../utils/files";
+import {
+  external,
+  externalComet,
+  externalIcJs,
+  getHelper,
+  getHelperForBigint,
+  getReactQueryHelper,
+  getVueQueryHelperHooks,
+  mobx,
+  grpcGateway,
+  grpcWeb,
+  pinia,
+  varint,
+  utf8,
+  getHelperForBinary,
+  getRegistryHelper,
+  getTypesHelper,
+  jsonSafe,
+  decimal,
+  getHelperFuncTypes,
+  getHelperFuncTypesForInterface,
+  getReactQueryHelperHooks,
+  getReactQueryHelperHooksIcJs,
+} from "../helpers";
+
+const version = process.env.NODE_ENV === "test" ? "latest" : pkg.version;
+const header = `/**
+* This file and any referenced files were automatically generated by ${pkg.name}@${version}
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or npm scripts command that is used to regenerate this bundle.
+*/
+\n`;
+
+const write = (
+  builder: TelescopeBuilder,
+  indexFile: string,
+  content: string
+) => {
+  const indexOutFile = join(builder.outPath, indexFile);
+  mkdirp.sync(dirname(indexOutFile));
+  writeContentToFile(
+    builder.outPath,
+    builder.options,
+    header + content,
+    indexOutFile
+  );
+};
+
+export const plugin = (builder: TelescopeBuilder) => {
+  write(
+    builder,
+    "helpers.ts",
+    builder.options.prototypes.typingsFormat.num64 === "bigint"
+      ? getHelperForBigint(builder.options)
+      : getHelper(builder.options)
+  );
+
+  // should be exported
+  if (
+    builder.options.stargateClients.addGetTxRpc ||
+    builder.options.includeExternalHelpers ||
+    builder.options.reactQuery?.enabled ||
+    builder.options?.helperFunctions?.enabled
+  ) {
+    // also react-query needs these...
+    builder.files.push("extern.ts");
+
+    if (builder.options?.helperFunctions?.enabled) {
+      write(builder, "extern.ts", externalIcJs);
+    } else {
+      write(
+        builder,
+        "extern.ts",
+        builder.options.rpcClients?.useConnectComet || builder.options.rpcClients?.useMakeClient ? externalComet : external
+      );
+    }
+  }
+
+  if (builder.options.helperFunctions?.enabled) {
+    builder.files.push("helper-func-types.ts");
+    if (builder.options.interfaces?.enabled && builder.options.helperFunctions?.useGlobalDecoderRegistry) {
+      write(builder, "helper-func-types.ts", getHelperFuncTypesForInterface(builder.options));
+    } else {
+      write(builder, "helper-func-types.ts", getHelperFuncTypes(builder.options));
+    }
+  }
+
+  if (
+    builder.options.reactQuery?.enabled ||
+    (builder.options?.helperFunctions?.enabled &&
+      builder.options?.helperFunctions?.hooks?.react)
+  ) {
+    builder.files.push("react-query.ts");
+
+    if (
+      builder.options?.helperFunctions?.enabled &&
+      builder.options?.helperFunctions?.hooks?.react
+    ) {
+      if (builder.options?.useInterchainJs) {
+        write(
+          builder,
+          "react-query.ts",
+          getReactQueryHelperHooksIcJs(builder.options)
+        );
+      } else {
+        write(
+          builder,
+          "react-query.ts",
+          getReactQueryHelperHooks(builder.options)
+        );
+      }
+    } else {
+      write(builder, "react-query.ts", getReactQueryHelper(builder.options));
+    }
+  }
+
+  if (
+    builder.options?.helperFunctions?.enabled &&
+      builder.options?.helperFunctions?.hooks?.vue
+  ) {
+    builder.files.push("vue-query.ts");
+
+    write(
+      builder,
+      "vue-query.ts",
+      getVueQueryHelperHooks(builder.options)
+    );
+  }
+
+  if (builder.options.mobx?.enabled) {
+    builder.files.push("mobx.ts");
+    write(builder, "mobx.ts", mobx);
+  }
+
+  if (builder.options.pinia?.enabled) {
+    builder.files.push("pinia-endpoint.ts");
+    write(builder, "pinia-endpoint.ts", pinia);
+  }
+
+  if (builder.options.rpcClients?.type === "grpc-gateway") {
+    builder.files.push("grpc-gateway.ts");
+    write(builder, "grpc-gateway.ts", grpcGateway);
+  }
+
+  if (builder.options.rpcClients?.type === "grpc-web") {
+    builder.files.push("grpc-web.ts");
+    write(builder, "grpc-web.ts", grpcWeb);
+  }
+
+  if (builder.options.prototypes.typingsFormat.customTypes.useEnhancedDecimal) {
+    builder.files.push("decimals.ts");
+    write(builder, "decimals.ts", decimal);
+  }
+
+  if (
+    !builder.options.prototypes.typingsFormat.toJsonUnknown &&
+    builder.options.prototypes.methods.toJSON
+  ) {
+    builder.files.push("json-safe.ts");
+    write(builder, "json-safe.ts", jsonSafe);
+  }
+
+  if (builder.options.prototypes.typingsFormat.num64 === "bigint") {
+    builder.files.push("varint.ts");
+    write(builder, "varint.ts", varint);
+
+    builder.files.push("utf8.ts");
+    write(builder, "utf8.ts", utf8);
+
+    builder.files.push("binary.ts");
+    write(builder, "binary.ts", getHelperForBinary(builder.options));
+  }
+
+  if (
+    builder.options.prototypes?.typingsFormat?.useTelescopeGeneratedType ||
+    (builder.options.interfaces?.enabled &&
+      (builder.options.interfaces?.useGlobalDecoderRegistry || builder.options.helperFunctions?.useGlobalDecoderRegistry)) ||
+    builder.options.helperFunctions?.enabled
+  ) {
+    builder.files.push("types.ts");
+    write(builder, "types.ts", getTypesHelper(builder.options));
+  }
+
+  if (
+    builder.options.interfaces?.enabled &&
+    (builder.options.interfaces?.useGlobalDecoderRegistry || builder.options.helperFunctions?.useGlobalDecoderRegistry)
+  ) {
+    builder.files.push("registry.ts");
+    write(builder, "registry.ts", getRegistryHelper(builder.options));
+  }
+};

package/src/generators/create-index.ts

@@ -0,0 +1,72 @@
+import { getRelativePath } from "../utils";
+import { join, dirname } from "path";
+import { mkdirp } from "mkdirp";
+import { TelescopeBuilder } from "../builder";
+import * as t from "@babel/types";
+import generate from "@babel/generator";
+//@ts-ignore
+import pkg from "../../package.json";
+import { writeContentToFile } from "../utils/files";
+
+const version = process.env.NODE_ENV === "test" ? "latest" : pkg.version;
+
+export const plugin = (builder: TelescopeBuilder) => {
+  if (!builder.options.bundle.enabled) {
+    return;
+  }
+
+  // finally, write one index file with all files, exported
+  const indexFile = "index.ts";
+  const indexOutFile = join(builder.outPath, indexFile);
+  const stmts = builder.files.map((file) =>
+    t.exportAllDeclaration(
+      t.stringLiteral(
+        getRelativePath(indexFile, file, builder.options.restoreImportExtension)
+      )
+    )
+  );
+  const finalAst = t.program(stmts);
+  const indexContent = generate(finalAst).code;
+  mkdirp.sync(dirname(indexOutFile));
+
+  const header = `/**
+  * This file and any referenced files were automatically generated by ${pkg.name}@${version}
+  * DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+    * and run the transpile command or npm scripts command that is used to regenerate this bundle.
+  */
+ \n`;
+
+  writeContentToFile(
+    builder.outPath,
+    builder.options,
+    header + indexContent,
+    indexOutFile
+  );
+
+  if (
+    builder.options.bundle.enabled &&
+    builder.options.bundle.type === "module"
+  ) {
+    const typePackageMapping = builder.store.getTypesInMultipleFiles();
+    const servicePackageMapping = builder.store.getHelperFuncsInMultipleFiles();
+
+    const typePackageMappingMap = typePackageMapping.reduce((obj, type) => {
+      const pkg = builder.store.getTypeFilesMapping(type);
+      obj[type] = pkg.join(", ");
+      return obj;
+    }, {});
+
+    // console.log("types in multiple files:", JSON.stringify(typePackageMappingMap, null, 2));
+
+    const servicePackageMappingMap = servicePackageMapping.reduce(
+      (obj, service) => {
+        const pkg = builder.store.getHelperFuncFilesMapping(service);
+        obj[service] = pkg.join(", ");
+        return obj;
+      },
+      {}
+    );
+
+    // console.log("services in multiple files:", JSON.stringify(servicePackageMappingMap, null, 2));
+  }
+};

package/src/generators/create-lcd-client-all.ts

@@ -0,0 +1,139 @@
+import * as dotty from 'dotty';
+import { getNestedProto, isRefIncluded, createEmptyProtoRef } from '@cosmology/proto-parser';
+import { join } from 'path';
+import { TelescopeBuilder } from '../builder';
+import { createScopedLCDFactory } from '@cosmology/ast';
+import { ALLOWED_RPC_SERVICES, ProtoRef } from '@cosmology/types';
+import { fixlocalpaths, getRelativePath } from '../utils';
+import { Bundler } from '../bundler';
+import { TelescopeParseContext } from '../build';
+import { aggregateImports, getImportStatements } from '../imports';
+
+export const plugin = (
+    builder: TelescopeBuilder,
+    bundler: Bundler
+) => {
+
+    // if not enabled, exit
+    if (!builder.options?.lcdClients?.enabled) {
+        return;
+    }
+
+    // if no scopes, do them all!
+    if (
+        !builder.options.lcdClients.scoped ||
+        !builder.options.lcdClients.scoped.length ||
+        !builder.options.lcdClients.scopedIsExclusive
+    ) {
+        return createAllLCDBundles(
+            builder,
+            bundler
+        );
+    }
+};
+
+const getFileName = (dir, filename) => {
+    const localname = join(dir, filename ?? 'lcd.ts');
+    if (localname.endsWith('.ts')) return localname;
+    return localname + '.ts';
+};
+
+const createAllLCDBundles = (
+    builder: TelescopeBuilder,
+    bundler: Bundler
+) => {
+
+    if (!builder.options.lcdClients.bundle) return;
+
+    const dir = bundler.bundle.base;
+    const filename = 'lcd.ts'
+
+    // 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 = 'createLCDClient'
+    const localname = getFileName(dir, filename);
+
+    const obj = {};
+    builder.lcdClients.forEach(file => {
+
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        // if (!packages.includes(file.package)) {
+        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
+    );
+
+    const lcdast = createScopedLCDFactory(
+        ctx.proto,
+        obj,
+        methodName,
+        'LCDQueryClient' // make option later
+    );
+
+    const imports = aggregateImports(ctx, {}, localname);
+
+    const importStmts = getImportStatements(
+        localname,
+        [...fixlocalpaths(imports)],
+        builder.options
+    );
+
+    const prog = []
+        .concat(importStmts)
+        .concat(lcdast);
+
+    const writeFilename = bundler.getFilename(localname);
+    bundler.writeAst(prog, writeFilename);
+
+    bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname)
+
+};

package/src/generators/create-lcd-client-scoped.ts

@@ -0,0 +1,109 @@
+import * as dotty from 'dotty';
+import { getNestedProto, isRefIncluded, createEmptyProtoRef } from '@cosmology/proto-parser';
+import { join } from 'path';
+import { TelescopeBuilder } from '../builder';
+import { createScopedLCDFactory } from '@cosmology/ast';
+import { ALLOWED_RPC_SERVICES, ProtoRef } from '@cosmology/types';
+import { fixlocalpaths, getRelativePath } from '../utils';
+import { Bundler } from '../bundler';
+import { TelescopeParseContext } from '../build';
+import { aggregateImports, getImportStatements } from '../imports';
+
+export const plugin = (
+    builder: TelescopeBuilder,
+    bundler: Bundler
+) => {
+
+    // if not enabled, exit
+    if (!builder.options?.lcdClients?.enabled) {
+        return;
+    }
+
+    // we have scopes!
+    builder.options.lcdClients.scoped?.forEach(lcd => {
+        if (lcd.dir !== bundler.bundle.base) return;
+        makeLCD(
+            builder,
+            bundler,
+            lcd
+        );
+    });
+};
+
+const getFileName = (dir, filename) => {
+    const localname = join(dir, filename ?? 'lcd.ts');
+    if (localname.endsWith('.ts')) return localname;
+    return localname + '.ts';
+};
+
+const makeLCD = (
+    builder: TelescopeBuilder,
+    bundler: Bundler,
+    lcd: {
+        dir: string;
+        filename?: string;
+        packages: string[];
+        protos?: string[];
+        addToBundle: boolean;
+        methodName?: string;
+    }
+) => {
+    const dir = lcd.dir;
+    const packages = lcd.packages;
+    const protos = lcd.protos;
+    const methodName = lcd.methodName ?? 'createLCDClient'
+    const localname = getFileName(dir, lcd.filename);
+
+    const obj = {};
+    builder.lcdClients.forEach(file => {
+
+        // ADD all option
+        // which defaults to including cosmos
+        // and defaults to base for each
+        // if (!packages.includes(file.package)) {
+        if (!isRefIncluded(createEmptyProtoRef(file.package, file.proto), {
+            packages,
+            protos
+        })) {
+            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
+    );
+
+    const lcdast = createScopedLCDFactory(
+        ctx.proto,
+        obj,
+        methodName,
+        'LCDQueryClient' // make option later
+    );
+
+    const imports = aggregateImports(ctx, {}, localname);
+
+    const importStmts = getImportStatements(
+        localname,
+        [...fixlocalpaths(imports)],
+        builder.options
+    );
+
+    const prog = []
+        .concat(importStmts)
+        .concat(lcdast);
+
+    const filename = bundler.getFilename(localname);
+    bundler.writeAst(prog, filename);
+
+    if (lcd.addToBundle) {
+        bundler.addToBundleToPackage(`${dir}.ClientFactory`, localname)
+    }
+};