@hyperweb/telescope 1.15.0

package/src/commands/download.ts

@@ -0,0 +1,120 @@
+import * as shell from "shelljs";
+import { readFileSync } from "fs";
+import { clone, cloneAll, extractProto } from "../protod/recursive";
+import { removeFolder } from "../protod/utils";
+import { DownloadOptions } from "../protod/types";
+import deepmerge from "deepmerge";
+import { presetProtoDirMapping } from "../protod/config";
+
+export default async (argv: { [key: string]: string | string[] } | DownloadOptions) => {
+  if (!shell.which("git")) {
+    shell.echo("Sorry, this script requires git");
+    return shell.exit(1);
+  }
+
+  let configJson: DownloadOptions;
+
+  if ('config' in argv || 'git-repo' in argv) {
+    const config = Array.isArray(argv["config"])
+      ? argv["config"][0]
+      : argv["config"];
+
+    if (config) {
+      try {
+        const configText = readFileSync(config, {
+          encoding: "utf8",
+        });
+        configJson = JSON.parse(configText);
+      } catch (ex) {
+        console.log(ex);
+        throw new Error("Must provide a .json file for --config.");
+      }
+    } else {
+      configJson = {};
+    }
+
+    const gitRepos = Array.isArray(argv["git-repo"])
+      ? argv["git-repo"]
+      : [argv["git-repo"]];
+
+    if (argv["git-repo"] && gitRepos && gitRepos.length > 0) {
+      configJson.repos = gitRepos.map((gitRepo) => {
+        const [owner, repo, branch] = gitRepo.split("/");
+
+        if (!owner || !repo) {
+          shell.echo(
+            "wrong `git-repo` format (i.e. <owner>/<repository> or <owner>/<repository>/<branch>).\n"
+          );
+          return shell.exit(1);
+        }
+
+        return { owner, repo, branch };
+      });
+    }
+
+    const targets = Array.isArray(argv["targets"])
+      ? argv["targets"]
+      : argv["targets"]?.split(",");
+    if (targets && targets.length > 0) {
+      configJson.targets = targets;
+    }
+
+    let outDir = Array.isArray(argv["out"]) ? argv["out"][0] : argv["out"];
+    if (outDir) {
+      configJson.outDir = outDir;
+    }
+
+    let sshOpt = argv["ssh"];
+    configJson.ssh = configJson.ssh || !!sshOpt;
+  } else {
+    configJson = argv as DownloadOptions;
+  }
+
+  if (!configJson.repos || configJson.repos.length === 0) {
+    shell.echo(
+      "missing `repos` configuration, you can set through `--git-repo` argument or set repos field in config file.\n"
+    );
+    return shell.exit(1);
+  }
+
+  if (!configJson.targets || configJson.targets.length === 0) {
+    shell.echo("there must be 'targets' file patterns.\n");
+    shell.exit(1);
+  }
+
+  if (!configJson.protoDirMapping) {
+    configJson.protoDirMapping = {};
+  }
+
+  configJson.protoDirMapping = deepmerge(
+    presetProtoDirMapping,
+    configJson.protoDirMapping
+  );
+
+  if (!configJson.outDir) {
+    shell.echo(
+      "out directory is not specified, downloading to `proto` folder by default.\n"
+    );
+    configJson.outDir = "proto";
+  }
+
+  if (configJson.deleteTempRepoDir) {
+    removeFolder(configJson.tempRepoDir);
+  }
+
+  const result = await cloneAll({
+    repos: configJson.repos,
+    gitModulesDir: "./git-modules",
+    ssh: configJson.ssh,
+    protoDirMapping: configJson.protoDirMapping,
+  });
+
+  if (result) {
+    removeFolder(configJson.outDir);
+    extractProto({
+      sources: result,
+      targets: configJson.targets,
+      outDir: configJson.outDir,
+    });
+  }
+};

package/src/commands/generate.ts

@@ -0,0 +1,156 @@
+import * as shell from 'shelljs';
+import { prompt } from '../prompt';
+import dargs from 'dargs';
+import { crossGlob as glob } from '@cosmology/utils';
+
+const fs = require('fs');
+const path = require('path');
+const repo = 'https://github.com/hyperweb-io/telescope-module-boilerplate.git';
+
+export default async argv => {
+    if (!shell.which('git')) {
+        shell.echo('Sorry, this script requires git');
+        return shell.exit(1);
+    }
+
+    let results: { [key: string]: any } = {};
+
+    const argsFromCommand = process.argv.slice(2);
+    argsFromCommand.forEach((arg, index) => {
+        if (arg.startsWith('--')) {
+            let key = arg.slice(2).replace(/-/g, '').toUpperCase();
+            key = `__${key}__`;
+            const value = argsFromCommand[index + 1] && !argsFromCommand[index + 1].startsWith('--') ? argsFromCommand[index + 1] : '';
+
+            if (Array.isArray(value)) {
+                results[key] = value.split(',');
+            } else {
+                results[key] = value;
+            }
+        }
+    });
+    const { name } = results.__MODULENAME__ ? { name: results.__MODULENAME__ } : await prompt([
+        {
+            type: 'string',
+            name: 'name',
+            message: 'Enter your new module name',
+        }
+    ], argv);
+    shell.exec(`git clone ${repo} ${name}`);
+    shell.cd(name);
+
+    let questions = JSON.parse(fs.readFileSync(`.questions.json`));
+    questions = questions.filter(question => !(question.name in results));
+
+    const fullname = shell
+        .exec('git config --global user.name', { silent: true })
+        .trim();
+    const email = shell
+        .exec('git config --global user.email', { silent: true })
+        .trim();
+
+    // @__USERNAME__/__MODULENAME__
+    // __PACKAGE_IDENTIFIER__
+    const args = dargs(
+        {
+            _: [],
+            ...argv,
+            __MODULENAME__: name,
+            __USERFULLNAME__: fullname,
+            __USEREMAIL__: email,
+        },
+        { allowCamelCase: true }
+    );
+
+    const answerResults = await prompt(questions, args);
+    results = { ...results, answerResults }
+
+    const license = results.__LICENSE__ ?? await prompt(
+        [
+            {
+                name: '__LICENSE__',
+                message: 'Which license?',
+                choices: ['MIT', 'closed'],
+                type: 'list',
+                required: true,
+            },
+        ],
+        []
+    );
+
+    let scopedResults;
+    if (results.__ACCESS__ === 'public') {
+        if (results.__USENPMSCOPED__ !== undefined) {
+            scopedResults = { scoped: true }
+        } else {
+            scopedResults = await prompt(
+                [
+                    {
+                        type: 'confirm',
+                        name: 'scoped',
+                        message: 'use npm scopes?',
+                        required: true,
+                    },
+                ],
+                []
+            );
+        }
+    }
+
+    const files = []
+        .concat(glob(process.cwd() + '/**/.*'))
+        .concat(glob(process.cwd() + '/**/*'));
+
+    for (let i = 0; i < files.length; i++) {
+        const templateFile = files[i];
+        if (fs.lstatSync(templateFile).isDirectory()) continue;
+
+        let content = fs.readFileSync(templateFile).toString();
+        if (
+            path.basename(templateFile) === 'LICENSE' &&
+            license.__LICENSE__ === 'closed'
+        ) {
+            content = `Copyright (c) ${new Date().getFullYear()} __USERFULLNAME__ <__USEREMAIL__> - All Rights Reserved
+Unauthorized copying via any medium is strictly prohibited
+Proprietary and confidential`;
+        }
+
+        Object.keys(results).forEach(key => {
+            if (/^__/.test(key)) {
+                content = content.replace(new RegExp(key, 'g'), results[key]);
+            }
+        });
+        if (results.__ACCESS__ === 'public') {
+            if (scopedResults.scoped) {
+                content = content.replace(
+                    /__PACKAGE_IDENTIFIER__/g,
+                    `@${results.__USERNAME__}/${results.__MODULENAME__}`
+                );
+            } else {
+                content = content.replace(
+                    /__PACKAGE_IDENTIFIER__/g,
+                    `${results.__MODULENAME__}`
+                );
+            }
+        } else {
+            content = content.replace(
+                /__PACKAGE_IDENTIFIER__/g,
+                `@${results.__USERNAME__}/${results.__MODULENAME__}`
+            );
+        }
+
+        fs.writeFileSync(templateFile, content);
+    }
+
+    shell.rm('-rf', '.git');
+    shell.rm('-rf', '.questions.json');
+
+    console.log(`
+
+       |||
+      (o o)
+  ooO--(_)--Ooo-
+
+  ✨ Great work!
+  `);
+};

package/src/commands/install.ts

@@ -0,0 +1,154 @@
+import { resolve, join, dirname, basename, extname } from 'path';
+import { mkdirp } from 'mkdirp';
+import { crossGlob as glob } from '@cosmology/utils';
+import { rimrafSync as rimraf } from 'rimraf';
+import { exec } from 'shelljs';
+import { prompt } from '../prompt';
+import { parse } from 'parse-package-name';
+import { tmpdir } from 'os';
+import { readFileSync, writeFileSync } from 'fs';
+
+const TMPDIR = tmpdir();
+const rnd = () =>
+    Math.random().toString(36).substring(2, 15) +
+    Math.random().toString(36).substring(2, 15);
+
+const getPackages = (names) => {
+    return names.map(pkg => {
+        const { name, version } = parse(pkg);
+        return `${name}@${version}`
+    }).join(' ');
+};
+
+export default async (argv) => {
+
+    // don't prompt if we got this...
+    if (argv._.length) {
+        argv.pkg = argv._;
+    }
+
+    // current dir/package
+    const cur = process.cwd();
+    let thisPackage;
+    try {
+        thisPackage = JSON.parse(readFileSync(join(cur, 'package.json'), 'utf-8'));
+    } catch (e) {
+        throw new Error('make sure you are inside of a telescope package!');
+    }
+
+    // what are we installing?
+    let { pkg } = await prompt([
+        {
+            type: 'checkbox',
+            name: 'pkg',
+            message:
+                'which packages do you want to support?',
+            choices: [
+                'amino',
+                'akash',
+                // 'axelar',
+                'bcna',
+                // 'bitsong', // Error: namespace and package not supported, yet.
+                // 'canto',
+                // 'cht',
+                'comdex',
+                'confio',
+                'cosmos',
+                'cosmos_proto',
+                'cosmwasm',
+                // 'cronos',
+                // 'cyber',
+                // 'desmos',
+                // 'echelon',
+                // 'em',
+                // 'eve',
+                // 'evmos',
+                // 'galaxy',
+                'gogoproto',
+                'google',
+                'ibc',
+                'injective',
+                'juno',
+                // 'kava',
+                // 'likechain',
+                // 'lumenx',
+                'omniflix',
+                // 'oracle',
+                'osmosis',
+                // 'panacea',
+                'passage3d',
+                'persistence',
+                // 'provenance',
+                // 'pylons',
+                'regen',
+                // 'scavenge',
+                // 'sentinel',
+                // 'shentu',
+                // 'sifnode',
+                'stargaze',
+                'tendermint',
+                'umee',
+                // 'uptake',
+                // 'vidulum',
+            ].map(name => {
+                return {
+                    name,
+                    value: `@protobufs/${name}`
+                }
+            })
+        }
+    ], argv);
+
+    // install
+    if (!Array.isArray(pkg)) pkg = [pkg];
+    const tmp = join(TMPDIR, rnd());
+    mkdirp.sync(tmp);
+    process.chdir(tmp);
+    exec(`npm install ${getPackages(pkg)} --production --prefix ./protobufs`);
+
+    // protos
+    const pkgs = glob('./protobufs/**/package.json');
+    const cmds = pkgs
+        .filter((f) => { return f !== './protobufs/package.json' })
+        .map((f) => resolve(join(tmp, f)))
+        .map((conf) => {
+            const extDir = dirname(conf);
+            const dir = extDir.split('node_modules/')[1];
+            const dst = basename(dir);
+
+            const files = glob(`${extDir}/**/*`, { nodir: true });
+            files.forEach(f => {
+                if (extname(f) === '.proto'
+                    || f === 'package.json'
+                    || /license/i.test(f)
+                    || /readme/i.test(f)) return;
+                rimraf(f);
+            });
+            return [extDir, resolve(join(cur, 'proto', dst)), dir];
+        });
+
+    // move protos
+    for (const [src, dst, pkg] of cmds) {
+        rimraf(dst);
+        console.log(`installing ${pkg}...`);
+        mkdirp.sync(dirname(dst));
+        exec(`mv ${src} ${dst}`);
+    }
+
+    // package
+    const packageInfo = JSON.parse(readFileSync('./protobufs/package.json', 'utf-8'));
+    const deps = packageInfo.dependencies ?? {};
+    thisPackage.devDependencies = thisPackage.devDependencies ?? {};
+    thisPackage.devDependencies = {
+        ...thisPackage.devDependencies,
+        ...deps
+    };
+
+    thisPackage.devDependencies = Object.fromEntries(Object.entries(thisPackage.devDependencies).sort());
+
+    writeFileSync(join(cur, 'package.json'), JSON.stringify(thisPackage, null, 2));
+
+    // cleanup
+    rimraf(tmp);
+    process.chdir(cur);
+};

package/src/commands/transpile.ts

@@ -0,0 +1,198 @@
+import { prompt } from '../prompt';
+import telescope from '../index';
+import { writeFileSync, readFileSync } from 'fs';
+import { defaultTelescopeOptions } from '@cosmology/types';
+import * as path from 'path'
+import * as dotty from 'dotty';
+import deepmerge from 'deepmerge';
+
+export default async (argv: {
+  [key: string]: string | string[]
+}) => {
+  let options: {
+    [key: string]: unknown
+  } = {}
+  let protoDirs;
+  let outPath;
+  let data: any;
+  let overrideConfig = true;
+
+  if (argv.useDefaults) {
+    const defaultOptions = { ...defaultTelescopeOptions };
+
+    dotty.remove(defaultOptions, "aminoEncoding");
+    dotty.remove(defaultOptions, "packages");
+
+    options = defaultOptions;
+  } else {
+    options = {
+      // global options (can be overridden through plugins)
+      interfaces: {
+        enabled: false,
+        useByDefault: false,
+        useUnionTypes: false,
+      },
+
+      prototypes: {
+        enabled: true,
+        parser: {
+          keepCase: false
+        },
+        methods: {
+          fromJSON: false,
+          toJSON: false,
+          encode: true,
+          decode: true,
+          fromPartial: true,
+          toAmino: true,
+          fromAmino: true,
+          fromProto: true,
+          toProto: true
+        },
+        addTypeUrlToObjects: true,
+        addTypeUrlToDecoders: true,
+
+        typingsFormat: {
+          duration: 'duration',
+          timestamp: 'date',
+          useExact: false,
+          useDeepPartial: false,
+          num64: 'bigint',
+          customTypes: {
+            useCosmosSDKDec: true
+          }
+        },
+      },
+
+      bundle: {
+        enabled: true
+      },
+
+      stargateClients: {
+        enabled: true,
+        includeCosmosDefaultTypes: true
+      },
+
+      aminoEncoding: {
+        enabled: true,
+      },
+
+      lcdClients: {
+        enabled: true
+      },
+
+      rpcClients: {
+        enabled: true,
+        camelCase: true
+      }
+    }
+
+  }
+
+  const questions = [
+    {
+      _: true,
+      type: 'path',
+      name: 'protoDirs',
+      message: 'where is the proto directory?',
+      default: './proto'
+    },
+    {
+      _: true,
+      type: 'path',
+      name: 'outPath',
+      message: 'where is the output directory?',
+      default: './src/codegen'
+    }
+  ];
+
+  if (argv.config) {
+    overrideConfig = false;
+    const { config } = argv;
+    const configs = Array.isArray(config) ? config : [config];
+    const inputConfigFullPaths = configs.map(c => path.resolve(c));
+    let configJson;
+
+    for (const inputConfigPath of inputConfigFullPaths) {
+      try {
+        const configText = readFileSync(inputConfigPath, {
+          encoding: 'utf8'
+        })
+        if (configJson) {
+          configJson = deepmerge(configJson, JSON.parse(configText));
+        } else {
+          configJson = JSON.parse(configText);
+        }
+      } catch (ex) {
+        console.log(ex);
+        throw new Error("Must provide a .json file for --config.");
+      }
+    }
+
+    // append protoDirs in config to argv.protoDirs
+    argv.protoDirs = [
+      ...(argv.protoDirs
+        ? Array.isArray(argv.protoDirs)
+          ? argv.protoDirs
+          : [argv.protoDirs]
+        : []),
+      ...(configJson.protoDirs ?? []),
+    ];
+
+    if (configJson.outPath) {
+      argv.outPath = configJson.outPath;
+    }
+
+    // For now, useDefaults will be override by --config
+    if (configJson.options) {
+      options = configJson.options;
+    }
+  }
+
+  if (!argv.config && !argv.useDefaults) {
+    try {
+      //check if there's valid .telescope.json file to use
+      data = JSON.parse(readFileSync('./.telescope.json', {
+        encoding: 'utf8'
+      }))
+    } catch (e) { }
+
+    //if there's existing valid .telescope.json, use and keep the file
+    if (data?.protoDirs && data?.outPath && data?.options) {
+      overrideConfig = false
+      protoDirs = data.protoDirs
+      outPath = data.outPath
+      options = data.options
+    }
+  }
+  if (!protoDirs || !outPath) {
+    ({ protoDirs, outPath } = await prompt(questions, argv));
+  }
+
+  if (!Array.isArray(protoDirs)) {
+    protoDirs = [protoDirs];
+  }
+
+  // remove any duplicate protodirs
+  protoDirs = [...new Set(protoDirs)];
+
+  if (overrideConfig) {
+    writeFileSync(
+      process.cwd() + '/.telescope.json',
+      JSON.stringify(
+        {
+          protoDirs,
+          outPath,
+          options
+        }, null, 2)
+    );
+  }
+
+  await telescope({
+    protoDirs,
+    outPath,
+    options
+  });
+
+  console.log(`✨ transpilation successful!`);
+};

package/src/contracts/generate.ts

@@ -0,0 +1,33 @@
+import { prompt } from '../prompt';
+import { generateClient } from '@cosmwasm/ts-codegen';
+import { getContracts, getContractSchemata } from '../utils/contracts';
+
+export default async (argv) => {
+
+    const contracts = getContracts();
+
+    const questions = [
+        {
+            _: true,
+            type: 'checkbox',
+            name: 'schema',
+            message: 'which directory contains the the Rust contracts?',
+            choices: contracts
+        },
+        {
+            _: true,
+            type: 'path',
+            name: 'out',
+            message: 'where is the output directory?',
+            default: './src/contracts'
+        }
+    ];
+
+    let { schema, out } = await prompt(questions, argv);
+    if (!Array.isArray(schema)) schema = [schema];
+
+    const s = await getContractSchemata(schema, out, argv);
+    s.forEach(async ({ contractName, schemas, outPath }) => {
+        await generateClient(contractName, schemas, outPath);
+    });
+};