@hyperweb/telescope 1.15.0

package/module/bundle.js

@@ -0,0 +1,128 @@
+import { isRefExcluded, createEmptyProtoRef } from '@cosmology/proto-parser';
+import { importNamespace } from '@cosmology/ast';
+import * as dotty from 'dotty';
+import { join, relative, dirname } from 'path';
+import { toPosixPath } from '@cosmology/utils';
+// TODO move to store
+export const getPackages = (store) => {
+    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) => {
+    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) => {
+    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) => {
+    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) => {
+    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) => {
+    return contexts.map((ctx) => {
+        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, 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, 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/module/bundler.js

@@ -0,0 +1,96 @@
+import { resolve, join, dirname, relative, extname } from "path";
+import { TelescopeParseContext } from "./build";
+import { createFileBundle } from "./bundle";
+import { writeAstToFile } from "./utils/files";
+import { toPosixPath } from "@cosmology/utils";
+export class Bundler {
+    builder;
+    contexts = [];
+    bundle;
+    files;
+    converters = [];
+    lcdClients = [];
+    rpcQueryClients = [];
+    rpcMsgClients = [];
+    registries = [];
+    stateManagers = {};
+    constructor(builder, bundle) {
+        this.builder = builder;
+        this.bundle = bundle;
+        this.files = [bundle.bundleFile];
+    }
+    addStateManagers(type, files) {
+        const state = this.stateManagers[type];
+        if (!state) {
+            this.stateManagers[type] = [];
+        }
+        [].push.apply(this.stateManagers[type], files);
+        this.builder.addStateManagers(type, files);
+    }
+    addLCDClients(files) {
+        [].push.apply(this.lcdClients, files);
+        this.builder.addLCDClients(files);
+    }
+    addRPCQueryClients(files) {
+        [].push.apply(this.rpcQueryClients, files);
+        this.builder.addRPCQueryClients(files);
+    }
+    addRPCMsgClients(files) {
+        [].push.apply(this.rpcMsgClients, files);
+        this.builder.addRPCMsgClients(files);
+    }
+    addRegistries(files) {
+        [].push.apply(this.registries, files);
+        this.builder.addRegistries(files);
+    }
+    addConverters(files) {
+        [].push.apply(this.converters, files);
+        this.builder.addConverters(files);
+    }
+    getFreshContext(context) {
+        return new TelescopeParseContext(context.ref, context.store, this.builder.options);
+    }
+    getLocalFilename(ref, suffix) {
+        return suffix
+            ? ref.filename.replace(/\.proto$/, `.${suffix}.ts`)
+            : ref.filename.replace(/\.proto$/, `.ts`);
+    }
+    getFilename(localname) {
+        return resolve(join(this.builder.outPath, localname));
+    }
+    writeAst(program, filename) {
+        writeAstToFile(this.builder.outPath, this.builder.options, program, filename);
+    }
+    // addToBundle adds the path into the namespaced bundle object
+    addToBundle(context, localname) {
+        createFileBundle(this.builder.options, context.ref.proto.package, localname, this.bundle.bundleFile, this.bundle.importPaths, this.bundle.bundleVariables);
+    }
+    addToBundleToPackage(packagename, localname) {
+        createFileBundle(this.builder.options, packagename, localname, this.bundle.bundleFile, this.bundle.importPaths, this.bundle.bundleVariables);
+    }
+    addExportObjToBundle(pkg, localname, exportedIdentifiers, isHelperFunc) {
+        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/module/cli.js

@@ -0,0 +1,44 @@
+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/module/cmds.js

@@ -0,0 +1,22 @@
+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 };

package/module/commands/download.js

@@ -0,0 +1,94 @@
+import * as shell from "shelljs";
+import { readFileSync } from "fs";
+import { cloneAll, extractProto } from "../protod/recursive";
+import { removeFolder } from "../protod/utils";
+import deepmerge from "deepmerge";
+import { presetProtoDirMapping } from "../protod/config";
+export default async (argv) => {
+    if (!shell.which("git")) {
+        shell.echo("Sorry, this script requires git");
+        return shell.exit(1);
+    }
+    let configJson;
+    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;
+    }
+    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/module/commands/generate.js

@@ -0,0 +1,123 @@
+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 = {};
+    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/module/commands/install.js

@@ -0,0 +1,141 @@
+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);
+};