@hyperweb/telescope 1.15.0

package/module/imports.js

@@ -0,0 +1,382 @@
+import * as t from "@babel/types";
+import { SymbolNames, importStmt, } from "@cosmology/ast";
+import { UTILS, getRelativePath, UTIL_HELPERS } from "./utils";
+import { restoreExtension } from "@cosmology/utils";
+const importHashToArray = (hash) => {
+    return Object.entries(hash ?? {}).reduce((m, [path, names]) => {
+        names.forEach((name) => {
+            m.push({
+                type: "import",
+                name,
+                path,
+            });
+        });
+        return m;
+    }, []);
+};
+const getProtoImports = (context, filename) => {
+    return context.proto.imports
+        .map((usage) => {
+        if (filename === usage.import)
+            return;
+        const importPath = getRelativePath(filename, usage.import);
+        return {
+            type: "import",
+            name: usage.name,
+            importAs: usage.importedAs,
+            path: importPath,
+            protoPath: usage.import,
+        };
+    })
+        .filter(Boolean);
+};
+const getAminoImports = (context, filename) => {
+    return context.amino.imports
+        .map((usage) => {
+        if (filename === usage.import)
+            return;
+        const importPath = getRelativePath(filename, usage.import);
+        return {
+            type: "import",
+            name: usage.name,
+            importAs: usage.importedAs,
+            path: importPath,
+            protoPath: usage.import,
+        };
+    })
+        .filter(Boolean);
+};
+const getGenericImports = (context, filename) => {
+    return context.generic.imports
+        .map((usage) => {
+        if (filename === usage.import)
+            return;
+        const importPath = getRelativePath(filename, usage.import);
+        return {
+            type: "import",
+            name: usage.name,
+            importAs: usage.importedAs,
+            path: importPath,
+            protoPath: usage.import,
+        };
+    })
+        .filter(Boolean);
+};
+const getParsedImports = (context, parsedImports, filename) => {
+    const imports = [];
+    Object.entries(parsedImports ?? {}).forEach(([path, names]) => {
+        if (filename === path)
+            return;
+        const importPath = getRelativePath(filename, path);
+        const aliases = context.ref?.traversed?.importNames?.[path];
+        names.forEach((name) => {
+            let importAs = name;
+            if (aliases && aliases[name]) {
+                importAs = aliases[name];
+            }
+            imports.push({
+                type: "import",
+                name,
+                importAs,
+                path: importPath,
+                protoPath: path,
+            });
+        });
+    });
+    return imports;
+};
+const importAs = (name, importAs, importPath) => {
+    return t.importDeclaration([t.importSpecifier(t.identifier(importAs), t.identifier(name))], t.stringLiteral(importPath));
+};
+// __helpers__
+export const getImportStatements = (filepath, list, options) => {
+    const imports = list.reduce((m, obj) => {
+        let editedPath = UTIL_HELPERS.includes(obj.path)
+            ? getRelativePath(filepath, `./${obj.path.replace(/__/g, "")}`)
+            : obj.path;
+        editedPath = restoreExtension(editedPath, options?.restoreImportExtension);
+        const clonedObj = { ...obj, path: editedPath };
+        m[clonedObj.path] = m[clonedObj.path] || [];
+        const exists = m[clonedObj.path].find((el) => el.type === clonedObj.type &&
+            el.path === clonedObj.path &&
+            el.name === clonedObj.name);
+        // MARKED AS NOT DRY [google.protobuf names]
+        // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
+        if (/\./.test(clonedObj.name)) {
+            clonedObj.name =
+                clonedObj.name.split(".")[clonedObj.name.split(".").length - 1];
+        }
+        if (!exists) {
+            m[clonedObj.path].push(clonedObj);
+        }
+        return m;
+    }, {});
+    return Object.entries(imports).reduce((m, [importPath, imports]) => {
+        const defaultImports = imports.filter((a) => a.type === "default");
+        if (defaultImports.length) {
+            if (defaultImports.length > 1)
+                throw new Error("more than one default name NOT allowed.");
+            m.push(t.importDeclaration([t.importDefaultSpecifier(t.identifier(defaultImports[0].name))], t.stringLiteral(defaultImports[0].path)));
+        }
+        const namedImports = imports.filter((a) => a.type === "import" && (!a.importAs || a.name === a.importAs));
+        if (namedImports.length) {
+            m.push(importStmt(namedImports.map((i) => i.name), namedImports[0].path));
+        }
+        const aliasNamedImports = imports.filter((a) => a.type === "import" && a.importAs && a.name !== a.importAs);
+        aliasNamedImports.forEach((imp) => {
+            m.push(importAs(imp.name, imp.importAs, imp.path));
+        });
+        const namespaced = imports.filter((a) => a.type === "namespace");
+        if (namespaced.length) {
+            if (namespaced.length > 1)
+                throw new Error("more than one namespaced name NOT allowed.");
+            m.push(t.importDeclaration([t.importNamespaceSpecifier(t.identifier(namespaced[0].name))], t.stringLiteral(namespaced[0].path)));
+        }
+        return m;
+    }, []);
+};
+const convertUtilsToImports = (context) => {
+    const list = [];
+    const utils = Object.keys({
+        ...context.amino.utils,
+        ...context.proto.utils,
+        ...context.generic.utils,
+    });
+    utils.forEach((util) => {
+        if (!UTILS.hasOwnProperty(util))
+            throw new Error("missing Util! ::" + util);
+        if (typeof UTILS[util] === "string") {
+            list.push({
+                type: "import",
+                path: UTILS[util],
+                name: util,
+            });
+        }
+        else {
+            list.push(UTILS[util]);
+        }
+    });
+    return list;
+};
+const convertUtilsToImportsGenric = (context) => {
+    const list = [];
+    const utils = Object.keys({
+        ...context.utils,
+    });
+    // MARKED AS NOT DRY - duplicate of above
+    utils.forEach((util) => {
+        if (!UTILS.hasOwnProperty(util))
+            throw new Error("missing Util! ::" + util);
+        if (typeof UTILS[util] === "string") {
+            list.push({
+                type: "import",
+                path: UTILS[util],
+                name: util,
+            });
+        }
+        else {
+            list.push(UTILS[util]);
+        }
+    });
+    return list;
+};
+export const buildAllImports = (context, allImports, filepath) => {
+    const imports = aggregateImports(context, allImports, filepath);
+    const importStmts = getImportStatements(filepath, imports, {
+        restoreImportExtension: context.options.restoreImportExtension,
+    });
+    return importStmts;
+};
+export const buildAllImportsFromGenericContext = (context, filepath) => {
+    const imports = convertUtilsToImportsGenric(context);
+    const importStmts = getImportStatements(filepath, imports, {
+        restoreImportExtension: context.options.restoreImportExtension,
+    });
+    return importStmts;
+};
+const addDerivativeTypesToImports = (context, imports) => {
+    const ref = context.ref;
+    return imports.reduce((m, obj) => {
+        // SDKType
+        // probably wont need this until we start generating osmonauts/helpers inline
+        if (obj.type === "import" && obj.path.startsWith(".")) {
+            let lookup = null;
+            try {
+                lookup = context.store.getImportFromRef(ref, obj.name);
+            }
+            catch (e) { }
+            const appendSuffix = (obj, baseType) => {
+                return {
+                    ...obj,
+                    orig: obj.name,
+                    name: SymbolNames[baseType](obj.name),
+                    importAs: SymbolNames[baseType](obj.importAs ?? obj.name),
+                    protoPath: obj.protoPath,
+                };
+            };
+            // MARKED AS NOT DRY [google.protobuf names]
+            // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
+            const removeProtoPrefix = (obj) => {
+                if (/\./.test(obj.name)) {
+                    obj.name = obj.name.split(".")[obj.name.split(".").length - 1];
+                    obj.importAs =
+                        obj.importAs.split(".")[obj.importAs.split(".").length - 1];
+                }
+                return obj;
+            };
+            const SDKTypeObject = removeProtoPrefix(appendSuffix(obj, "SDKType"));
+            const AminoTypeObject = removeProtoPrefix(appendSuffix(obj, "Amino"));
+            const EncodedTypeObject = removeProtoPrefix(appendSuffix(obj, "ProtoMsg"));
+            // const AminoTypeUrlObject = removeProtoPrefix(appendSuffix(obj, 'AminoType'));
+            if (lookup && ["Type", "Enum"].includes(lookup.obj.type)) {
+                const arr = [...m, obj];
+                if (context.options.aminoEncoding?.enabled &&
+                    !context.options.aminoEncoding.useLegacyInlineEncoding) {
+                    // check and see if this derived import has been required...
+                    const foundEnc = context.proto.derivedImports.find((a) => {
+                        if (a.type !== "ProtoMsg")
+                            return false;
+                        if (EncodedTypeObject.orig === a.symbol.symbolName) {
+                            // UNTIL you fix the ImportObjs to have ref...
+                            let rel = getRelativePath(a.symbol.ref, a.symbol.source);
+                            if (rel === EncodedTypeObject.path) {
+                                return true;
+                            }
+                        }
+                    });
+                    const foundAmino = context.proto.derivedImports.find((a) => {
+                        if (a.type !== "Amino")
+                            return false;
+                        if (AminoTypeObject.orig === a.symbol.symbolName &&
+                            a.symbol.ref &&
+                            a.symbol.source) {
+                            // UNTIL you fix the ImportObjs to have ref...
+                            let rel = getRelativePath(a.symbol.ref, a.symbol.source);
+                            if (rel === AminoTypeObject.path) {
+                                return true;
+                            }
+                        }
+                    });
+                    // we need Any types as defaults...
+                    if (foundEnc || EncodedTypeObject.orig === "Any") {
+                        arr.push(EncodedTypeObject);
+                    }
+                    if (foundAmino || AminoTypeObject.orig === "Any") {
+                        arr.push(AminoTypeObject);
+                    }
+                }
+                if (context.options.useSDKTypes) {
+                    // issue in output1 (probably legacy v1 amino transpiler)
+                    // ProposalSDKType wasn't being found in QueryProposalResponseSDKType
+                    arr.push(SDKTypeObject);
+                    // const foundSDK = context.proto.derivedImports.find(a => {
+                    //     if (a.type !== 'SDKType') return false;
+                    //     if (SDKTypeObject.orig === a.symbol.symbolName) {
+                    //         // UNTIL you fix the ImportObjs to have ref...
+                    //         let rel = getRelativePath(a.symbol.ref, a.symbol.source);
+                    //         if (rel === SDKTypeObject.path) {
+                    //             return true;
+                    //         }
+                    //     }
+                    // });
+                    // if (foundSDK) {
+                    //     arr.push(SDKTypeObject);
+                    // }
+                }
+                return arr;
+            }
+        }
+        return [...m, obj];
+    }, []);
+};
+export const aggregateImports = (context, allImports, filepath) => {
+    const protoImports = getProtoImports(context, filepath);
+    const aminoImports = getAminoImports(context, filepath);
+    const genericImports = getGenericImports(context, filepath);
+    const parsedImports = getParsedImports(context, context.amino.ref.traversed.parsedImports, filepath);
+    const additionalImports = importHashToArray(allImports);
+    const utilities = convertUtilsToImports(context);
+    let list = []
+        .concat(parsedImports)
+        .concat(utilities)
+        .concat(protoImports)
+        .concat(aminoImports)
+        .concat(genericImports)
+        .concat(additionalImports);
+    if (context.options.useSDKTypes ||
+        (context.options.aminoEncoding?.enabled &&
+            !context.options.aminoEncoding?.useLegacyInlineEncoding)) {
+        list = addDerivativeTypesToImports(context, list);
+    }
+    list = list.filter((imp) => {
+        const alias = context.store.getTypeAlias(imp.orig || imp.name, imp.protoPath);
+        return !alias;
+    });
+    return list;
+};
+export const getImportsFromMutations = (mutations) => {
+    return mutations.map((mutation) => {
+        return {
+            import: mutation.messageImport,
+            name: mutation.message,
+        };
+    });
+};
+// TODO implement ServiceQuery type (it is the same)
+export const getImportsFromQueries = (queries) => {
+    return queries.reduce((m, query) => {
+        const req = {
+            import: query.messageImport,
+            name: query.message,
+        };
+        const res = {
+            import: query.responseImport,
+            name: query.response,
+        };
+        return [...m, req, res];
+    }, []);
+};
+export const getDepsFromMutations = (mutations, filename) => {
+    return getImportsFromMutations(mutations)
+        .map((imp) => {
+        const f = filename;
+        const f2 = imp.import;
+        if (f === f2)
+            return;
+        const importPath = getRelativePath(f, f2);
+        return {
+            ...imp,
+            importPath,
+        };
+    })
+        .filter(Boolean)
+        .reduce((m, v) => {
+        m[v.importPath] = m[v.importPath] ?? [];
+        if (!m[v.importPath].includes(v.name)) {
+            m[v.importPath].push(v.name);
+        }
+        return m;
+    }, {});
+};
+export const getDepsFromQueries = (queries, filename) => {
+    return getImportsFromQueries(queries)
+        .map((imp) => {
+        const f = filename;
+        const f2 = imp.import;
+        if (f === f2)
+            return;
+        const importPath = getRelativePath(f, f2);
+        return {
+            ...imp,
+            importPath,
+        };
+    })
+        .filter(Boolean)
+        .reduce((m, v) => {
+        m[v.importPath] = m[v.importPath] ?? [];
+        if (!m[v.importPath].includes(v.name)) {
+            m[v.importPath].push(v.name);
+        }
+        return m;
+    }, {});
+};

package/module/index.js

@@ -0,0 +1,8 @@
+import { TelescopeBuilder } from './builder';
+export * from './builder';
+export * from './bundler';
+export * from './types';
+export default async (input) => {
+    const builder = new TelescopeBuilder(input);
+    await builder.build();
+};

package/module/parse.js

@@ -0,0 +1,185 @@
+import { ALLOWED_RPC_SERVICES } from '@cosmology/types';
+import { getObjectName } from '@cosmology/proto-parser';
+import { getKeyTypeEntryName } from '@cosmology/ast';
+import { getRoot } from './utils';
+export const parse = (context) => {
+    const root = getRoot(context.ref);
+    parseRecur({
+        context,
+        obj: root.root,
+        scope: [],
+        isNested: false
+    });
+};
+export const getParsedObjectName = (ref, obj, scope) => {
+    const _scope = [...scope];
+    const root = getRoot(ref);
+    const allButPackage = _scope.splice(root.package.split('.').length);
+    // pull off "this" name
+    allButPackage.pop();
+    return getObjectName(obj.name, [root.package, ...allButPackage]);
+};
+// TODO potentially move this back to ast or proto bc the ast lib references MapEntries...
+// Creating those BindingsEntry interfaces
+const makeKeyTypeObj = (ref, field, scope) => {
+    const root = getRoot(ref);
+    const scoped = [...scope].splice(root.package.split('.').length);
+    const adhocObj = {
+        type: 'Type',
+        comment: undefined,
+        fields: {
+            key: {
+                id: 1,
+                type: field.keyType,
+                scope: [...scoped],
+                parsedType: {
+                    name: field.keyType,
+                    type: field.keyType
+                },
+                comment: undefined,
+                options: {
+                    "(telescope:map_entry_type_field)": true
+                }
+            },
+            value: {
+                id: 2,
+                type: field.type,
+                scope: [...scoped],
+                parsedType: {
+                    name: field.parsedType.name,
+                    type: field.parsedType.type
+                },
+                comment: undefined,
+                options: {
+                    "(telescope:map_entry_type_field)": true
+                }
+            }
+        }
+    };
+    return adhocObj;
+};
+export const parseType = (context, obj, 
+// scope already has the name of "this" field at the end of it
+scope, isNested = false) => {
+    obj.keyTypes.forEach(field => {
+        const keyTypeObject = makeKeyTypeObj(context.ref, field, [...scope]);
+        const name = getParsedObjectName(context.ref, {
+            name: getKeyTypeEntryName(obj.name, field.name)
+        }, [...scope]);
+        context.addType(name, keyTypeObject, true);
+    });
+    // parse nested names
+    let name = obj.name;
+    if (isNested) {
+        name = getParsedObjectName(context.ref, obj, [...scope]);
+    }
+    context.addType(name, obj, isNested);
+    // render nested LAST
+    if (obj.nested) {
+        Object.keys(obj.nested).forEach(key => {
+            // isNested = true;
+            parseRecur({
+                context,
+                obj: obj.nested[key],
+                scope: [...scope, key],
+                isNested: true
+            });
+        });
+    }
+};
+export const parseEnum = (context, obj, scope, isNested = false) => {
+    let name = obj.name;
+    let enumObj = {
+        ...obj,
+        package: context.ref.proto.package
+    };
+    // parse nested names
+    if (isNested) {
+        name = getParsedObjectName(context.ref, enumObj, scope);
+    }
+    context.addType(name, enumObj, isNested);
+};
+export const parseService = (context, obj, scope, isNested = false) => {
+    const methodHash = obj.methods;
+    if (!ALLOWED_RPC_SERVICES.includes(obj.name)) {
+        return;
+    }
+    Object.entries(methodHash)
+        .forEach(([key, value]) => {
+        const lookup = context.store.get(context.ref, value.requestType);
+        if (!lookup) {
+            console.warn(`cannot find ${value.requestType}`);
+            throw new Error('undefined symbol for service.');
+        }
+        const lookupResponse = context.store.get(context.ref, value.responseType);
+        if (!lookupResponse) {
+            console.warn(`cannot find ${value.responseType}`);
+            throw new Error('undefined symbol for service.');
+        }
+        const serviceInfo = {
+            methodName: key,
+            package: context.ref.proto.package,
+            message: lookup.importedName,
+            messageImport: lookup.import ?? context.ref.filename,
+            response: lookupResponse.importedName,
+            responseImport: lookupResponse.import ?? context.ref.filename,
+            comment: value.comment
+        };
+        switch (obj.name) {
+            case 'Msg':
+                context.addMutation(serviceInfo);
+                break;
+            case 'Query':
+                context.addQuery(serviceInfo);
+                break;
+            default:
+                context.addService(serviceInfo);
+                break;
+        }
+    });
+};
+export const parseRecur = ({ context, obj, scope, isNested }) => {
+    switch (obj.type) {
+        case 'Type':
+            return parseType(context, obj, scope, isNested);
+        case 'Enum':
+            return parseEnum(context, obj, scope, isNested);
+        case 'Service':
+            return parseService(context, obj, scope, isNested);
+        case 'Field':
+            console.log(obj);
+            return;
+        case 'Root':
+        case 'Namespace':
+            if (obj.nested) {
+                return Object.keys(obj.nested).forEach(key => {
+                    parseRecur({
+                        context,
+                        obj: obj.nested[key],
+                        scope: [...scope, key],
+                        isNested
+                    });
+                });
+            }
+            else {
+                throw new Error('parseRecur() cannot find protobufjs Type');
+            }
+        default:
+        // if (obj.type === 'string') return;
+        // if (obj.type === 'bool') return;
+        // if (obj.type === 'HttpRule') return;
+        // if (obj.type === 'InterfaceDescriptor') return;
+        // if (obj.type === 'ScalarDescriptor') return;
+        // if (obj.type === 'ModuleDescriptor') return;
+        // if (obj.type === 'TableDescriptor') return;
+        // if (obj.type === 'SingletonDescriptor') return;
+        // if (obj.type === 'ModuleSchemaDescriptor') return;
+        // if (obj.type === 'google.api.FieldBehavior') return;
+        // if (obj.type === 'google.api.ResourceReference') return;
+        // if (obj.type === 'google.api.ResourceDescriptor') return;
+        // if (obj.type === 'google.api.RoutingRule') return;
+        // if (obj.type === 'google.api.VisibilityRule') return;
+        // if (obj.type === 'google.longrunning.OperationInfo') return;
+        // throw new Error('parseRecur() cannot find protobufjs Type')
+    }
+};

package/module/prompt.js

@@ -0,0 +1,58 @@
+import { filter } from 'fuzzy';
+import { prompt as inquirerer } from 'inquirerer';
+export const getFuzzySearch = (list) => {
+    return (answers, input) => {
+        input = input || '';
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                const fuzzyResult = filter(input, list);
+                resolve(fuzzyResult.map(function (el) {
+                    return el.original;
+                }));
+            }, 25);
+        });
+    };
+};
+export const getFuzzySearchNames = (nameValueItemList) => {
+    const list = nameValueItemList.map(({ name, value }) => name);
+    return (answers, input) => {
+        input = input || '';
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                const fuzzyResult = filter(input, list);
+                resolve(fuzzyResult.map(function (el) {
+                    return nameValueItemList.find(({ name, value }) => el.original == name);
+                }));
+            }, 25);
+        });
+    };
+};
+const transform = (questions) => {
+    return questions.map((q) => {
+        if (q.type === 'fuzzy') {
+            const choices = q.choices;
+            delete q.choices;
+            return {
+                ...q,
+                type: 'autocomplete',
+                source: getFuzzySearch(choices)
+            };
+        }
+        else if (q.type === 'fuzzy:objects') {
+            const choices = q.choices;
+            delete q.choices;
+            return {
+                ...q,
+                type: 'autocomplete',
+                source: getFuzzySearchNames(choices)
+            };
+        }
+        else {
+            return q;
+        }
+    });
+};
+export const prompt = async (questions = [], argv = {}) => {
+    questions = transform(questions);
+    return await inquirerer(questions, argv);
+};