@hyperweb/telescope 1.15.0

package/module/generators/create-mobx-bundle.js

@@ -0,0 +1,25 @@
+import { createMobxQueryFactory } from '@cosmology/ast';
+import * as dotty from 'dotty';
+import { commonBundlePlugin } from '../utils';
+export const plugin = (builder) => {
+    // if mobx is enabled
+    // generate stores.ts based on query hooks generated in each package.
+    // eg: __fixtures__/output1/stores.ts
+    if (!builder.options.mobx?.enabled) {
+        return;
+    }
+    // get mapping of packages and rpc query filenames.
+    const obj = {};
+    const bundlerFiles = builder.stateManagers["mobx"];
+    if (!bundlerFiles || !bundlerFiles.length) {
+        return;
+    }
+    bundlerFiles.map((queryClient) => {
+        const path = `./${queryClient.localname.replace(/\.ts$/, '')}`;
+        dotty.put(obj, queryClient.package, path);
+    });
+    commonBundlePlugin(builder, 'mobx.stores.ts', obj, (context, obj) => {
+        // generate code for createRpcQueryHooks and imports of related packages.
+        return createMobxQueryFactory(context, obj);
+    });
+};

package/module/generators/create-msg-funcs.js

@@ -0,0 +1,128 @@
+import { buildAllImports, getDepsFromQueries } from "../imports";
+import { createMsgHelperCreator, createMsgHooks, createVueMsgHooks } from "@cosmology/ast";
+import { getNestedProto } from "@cosmology/proto-parser";
+import { parse } from "../parse";
+import { getHelperFuncName, getQueryMethodNames, } from "@cosmology/utils";
+import { TX_SVC_TYPES } from "@cosmology/types";
+import { getExportedTypeNames } from "../utils/files";
+export const plugin = (builder, bundler) => {
+    const mutationContexts = bundler.contexts.filter((context) => context.mutations.length > 0);
+    const clients = mutationContexts
+        .map((c) => {
+        const enabled = c.proto.pluginValue("helperFunctions.enabled");
+        if (!enabled)
+            return;
+        const serviceTypes = c.proto.pluginValue("helperFunctions.include.serviceTypes");
+        if (serviceTypes && !serviceTypes.includes("Tx")) {
+            return;
+        }
+        if (c.proto.isExcluded())
+            return;
+        const localname = bundler.getLocalFilename(c.ref, "rpc.func");
+        const localnameReact = bundler.getLocalFilename(c.ref, `rpc.react`);
+        const localnameVue = bundler.getLocalFilename(c.ref, `rpc.vue`);
+        const filename = bundler.getFilename(localname);
+        const filenameReact = bundler.getFilename(localnameReact);
+        const filenameVue = bundler.getFilename(localnameVue);
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        parse(ctx);
+        const proto = getNestedProto(c.ref.traversed);
+        // hard-coding, for now, only Msg service
+        if (!proto?.Msg || proto.Msg?.type !== "Service") {
+            return;
+        }
+        const asts = [];
+        const reactAsts = [];
+        const vueAsts = [];
+        const helperCreatorNameList = [];
+        const bundlerFile = {
+            proto: c.ref.filename,
+            package: c.ref.proto.package,
+            localname,
+            filename,
+            isMsg: true,
+        };
+        TX_SVC_TYPES.forEach((svcKey) => {
+            if (proto[svcKey]) {
+                const svc = proto[svcKey];
+                const patterns = c.proto.pluginValue("helperFunctions.include.patterns");
+                const nameMappers = c.proto.pluginValue("helperFunctions.nameMappers");
+                const methodKeys = getQueryMethodNames(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns || ["**"], String);
+                // see if the function is excluded.
+                if (!methodKeys || !methodKeys.length) {
+                    return;
+                }
+                // for each method key, create creators, hooks.
+                methodKeys.forEach((methodKey) => {
+                    // get helperCreatorName
+                    // get hookName
+                    const { creator: helperCreatorName, hook: hookName } = getHelperFuncName(bundlerFile.package, methodKey, [nameMappers?.Msg, nameMappers?.All], "unchanged");
+                    helperCreatorNameList.push(helperCreatorName);
+                    const genCustomHooks = c.proto.pluginValue("helperFunctions.hooks.react");
+                    const genCustomHooksVue = c.proto.pluginValue("helperFunctions.hooks.vue");
+                    // Store the mapping in builder
+                    builder.addFunctionMapping(bundlerFile.package, svcKey, methodKey, helperCreatorName, hookName, svc.methods[methodKey].comment, svc.methods[methodKey].requestType, svc.methods[methodKey].responseType, localname, // function source file
+                    genCustomHooks ? localnameReact : undefined, // hook source file (React)
+                    bundler.getLocalFilename(c.ref) // type source file (main types file)
+                    );
+                    // gen helper funcs
+                    asts.push(createMsgHelperCreator(ctx.generic, svc.methods[methodKey], helperCreatorName));
+                    if (genCustomHooks) {
+                        // gen custom react hooks
+                        reactAsts.push(createMsgHooks(ctx.generic, svc.methods[methodKey], helperCreatorName, hookName));
+                    }
+                    if (genCustomHooksVue) {
+                        // gen custom vue hooks
+                        vueAsts.push(createVueMsgHooks(ctx.generic, svc.methods[methodKey], helperCreatorName, hookName));
+                    }
+                });
+            }
+        });
+        if (!asts.length) {
+            return;
+        }
+        const serviceImports = getDepsFromQueries(ctx.mutations, localname);
+        const serviceImportsReact = getDepsFromQueries(ctx.mutations, localnameReact);
+        const serviceImportsVue = getDepsFromQueries(ctx.mutations, localnameVue);
+        // add imports from func file like query.rpc.func.ts without the .ts extension
+        const funcFileName = "./".concat(localname.substring(localname.lastIndexOf("/") + 1).replace(/\.ts$/, ""));
+        serviceImportsReact[funcFileName] = helperCreatorNameList;
+        serviceImportsVue[funcFileName] = helperCreatorNameList;
+        const imports = buildAllImports(ctx, serviceImports, localname);
+        const importsReact = buildAllImports(ctx, serviceImportsReact, localnameReact);
+        const importsVue = buildAllImports(ctx, serviceImportsVue, localnameReact);
+        const prog = [].concat(imports).concat(ctx.body).concat(asts);
+        const progReact = [].concat(importsReact).concat(reactAsts);
+        const progVue = [].concat(importsVue).concat(vueAsts);
+        const exportedTypeNames = getExportedTypeNames(prog);
+        const exportedTypeNamesReact = getExportedTypeNames(progReact);
+        const exportedTypeNamesVue = getExportedTypeNames(progVue);
+        exportedTypeNames.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localname);
+        });
+        exportedTypeNamesReact.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localnameReact);
+        });
+        exportedTypeNamesVue.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localnameVue);
+        });
+        bundler.writeAst(prog, filename);
+        bundler.addExportObjToBundle(c.ref.proto.package, localname, exportedTypeNames, true);
+        if (reactAsts.length) {
+            bundler.writeAst(progReact, filenameReact);
+            bundler.addExportObjToBundle(c.ref.proto.package, localnameReact, exportedTypeNamesReact, true);
+        }
+        if (vueAsts.length) {
+            bundler.writeAst(progVue, filenameVue);
+            bundler.addExportObjToBundle(c.ref.proto.package, localnameVue, exportedTypeNamesVue, true);
+        }
+        bundler.addToBundle(c, localname);
+        return {
+            package: c.ref.proto.package,
+            localname,
+            filename,
+        };
+    })
+        .filter(Boolean);
+};

package/module/generators/create-pinia-store-bundle.js

@@ -0,0 +1,23 @@
+import { commonBundlePlugin } from '../utils';
+import * as dotty from 'dotty';
+import { createPiniaStoreFactory } from '@cosmology/ast';
+export const plugin = (builder) => {
+    // if not enabled, exit
+    if (!builder.options?.pinia?.enabled) {
+        return;
+    }
+    // get mapping of packages and rpc query filenames.
+    const obj = {};
+    const bundlerFiles = builder.stateManagers['pinia'];
+    if (!bundlerFiles || !bundlerFiles.length) {
+        return;
+    }
+    bundlerFiles.map((queryClient) => {
+        const path = `./${queryClient.localname.replace(/\.ts$/, '')}`;
+        dotty.put(obj, queryClient.package, path);
+    });
+    commonBundlePlugin(builder, 'pinia.store.ts', obj, (context, obj) => {
+        // generate code for createRpcQueryHooks and imports of related packages.
+        return createPiniaStoreFactory(context, obj);
+    });
+};

package/module/generators/create-pinia-store.js

@@ -0,0 +1,86 @@
+import { buildAllImports, getDepsFromQueries, getImportStatements } from '../imports';
+import { parse } from '../parse';
+import { getNestedProto, isRefIncluded } from '@cosmology/proto-parser';
+import { createPiniaStore } from '@cosmology/ast';
+export const plugin = (builder, bundler) => {
+    if (!builder.options.pinia?.enabled) {
+        return;
+    }
+    // get mapping of packages and rpc query filenames.
+    if (!builder.options.lcdClients?.enabled) {
+        return;
+    }
+    const queryContexts = bundler.contexts.filter((context) => context.queries.length > 0 || context.services.length > 0);
+    if (queryContexts.length > 0) {
+        const piniaBundlerFiles = [];
+        // [x] write out one registry helper for all contexts w/mutations
+        queryContexts.forEach((c) => {
+            const enabled = c.proto.pluginValue('lcdClients.enabled');
+            if (!enabled)
+                return;
+            const includePinia = c.proto.pluginValue('pinia.enabled') &&
+                isRefIncluded(c.ref, c.proto.pluginValue('pinia.include'));
+            if (!includePinia)
+                return;
+            if (c.proto.isExcluded())
+                return;
+            const ctx = bundler.getFreshContext(c);
+            // get mutations, services
+            parse(ctx);
+            const proto = getNestedProto(c.ref.traversed);
+            //// Anything except Msg Service OK...
+            const allowedRpcServices = builder.options.rpcClients.enabledServices.filter((a) => a !== 'Msg');
+            let name, getImportsFrom;
+            // get imports
+            allowedRpcServices.forEach((svcKey) => {
+                if (proto[svcKey]) {
+                    if (svcKey === 'Query') {
+                        getImportsFrom = ctx.queries;
+                    }
+                    else {
+                        getImportsFrom = ctx.services;
+                    }
+                    name = svcKey;
+                }
+            });
+            const localname = bundler.getLocalFilename(c.ref, 'pinia.store');
+            const filename = bundler.getFilename(localname);
+            const bundlerFile = {
+                package: c.ref.proto.package,
+                localname,
+                filename
+            };
+            let ast = null;
+            allowedRpcServices.forEach((svcKey) => {
+                if (proto[svcKey]) {
+                    ast = createPiniaStore(ctx.generic, proto[svcKey]);
+                }
+            });
+            if (!ast) {
+                return;
+            }
+            piniaBundlerFiles.push(bundlerFile);
+            const serviceImports = getDepsFromQueries(getImportsFrom, localname);
+            const imports = buildAllImports(ctx, serviceImports, localname);
+            const piniaImport = getImportStatements('pinia', [
+                {
+                    type: 'import',
+                    name: 'defineStore',
+                    path: 'pinia'
+                },
+                {
+                    type: 'import',
+                    name: 'LCDQueryClient',
+                    path: './query.lcd'
+                }
+            ], builder.options);
+            const prog = []
+                .concat([...imports, ...piniaImport])
+                .concat(ctx.body)
+                .concat(ast);
+            bundler.writeAst(prog, filename);
+            bundler.addToBundle(c, localname);
+        });
+        bundler.addStateManagers('pinia', piniaBundlerFiles);
+    }
+};

package/module/generators/create-query-funcs.js

@@ -0,0 +1,129 @@
+import { buildAllImports, getDepsFromQueries } from "../imports";
+import { createQueryHelperCreator, createQueryHooks, createVueQueryHooks } from "@cosmology/ast";
+import { getNestedProto } from "@cosmology/proto-parser";
+import { parse } from "../parse";
+import { QUERY_SVC_TYPES } from "@cosmology/types";
+import { getHelperFuncName, getQueryMethodNames, } from "@cosmology/utils";
+import { getExportedTypeNames } from "../utils/files";
+export const plugin = (builder, bundler) => {
+    const clients = bundler.contexts
+        .map((c) => {
+        const enabled = c.proto.pluginValue("helperFunctions.enabled");
+        if (!enabled)
+            return;
+        const serviceTypes = c.proto.pluginValue("helperFunctions.include.serviceTypes");
+        if (serviceTypes &&
+            !serviceTypes.includes("Query") &&
+            !serviceTypes.includes("All")) {
+            return;
+        }
+        if (c.proto.isExcluded())
+            return;
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        parse(ctx);
+        const proto = getNestedProto(c.ref.traversed);
+        //// Anything except Msg Service OK...
+        if (proto?.Msg) {
+            return;
+        }
+        let getImportsFrom;
+        if (proto.Query) {
+            getImportsFrom = ctx.queries;
+        }
+        else {
+            getImportsFrom = ctx.services;
+        }
+        const localname = bundler.getLocalFilename(c.ref, `rpc.func`);
+        const localnameReact = bundler.getLocalFilename(c.ref, `rpc.react`);
+        const localnameVue = bundler.getLocalFilename(c.ref, `rpc.vue`);
+        const filename = bundler.getFilename(localname);
+        const filenameReact = bundler.getFilename(localnameReact);
+        const filenameVue = bundler.getFilename(localnameVue);
+        const bundlerFile = {
+            proto: c.ref.filename,
+            package: c.ref.proto.package,
+            localname,
+            filename,
+        };
+        const asts = [];
+        const reactAsts = [];
+        const vueAsts = [];
+        const helperCreatorNameList = [];
+        QUERY_SVC_TYPES.forEach((svcKey) => {
+            if (proto[svcKey]) {
+                const svc = proto[svcKey];
+                const patterns = c.proto.pluginValue("helperFunctions.include.patterns");
+                const nameMappers = c.proto.pluginValue("helperFunctions.nameMappers");
+                const methodKeys = getQueryMethodNames(bundlerFile.package, Object.keys(proto[svcKey].methods ?? {}), patterns || ["**"], String);
+                // see if the function is excluded.
+                if (!methodKeys || !methodKeys.length) {
+                    return;
+                }
+                // for each method key, create creators, hooks.
+                methodKeys.forEach((methodKey) => {
+                    // get helperCreatorName
+                    // get hookName
+                    const { creator: helperCreatorName, hook: hookName } = getHelperFuncName(bundlerFile.package, methodKey, [nameMappers?.Query, nameMappers?.All], "get");
+                    helperCreatorNameList.push(helperCreatorName);
+                    const genCustomHooksReact = c.proto.pluginValue("helperFunctions.hooks.react");
+                    const genCustomHooksVue = c.proto.pluginValue("helperFunctions.hooks.vue");
+                    // Store the mapping in builder
+                    builder.addFunctionMapping(bundlerFile.package, svcKey, methodKey, helperCreatorName, hookName, svc.methods[methodKey].comment, svc.methods[methodKey].requestType, svc.methods[methodKey].responseType, localname, genCustomHooksReact ? localnameReact : undefined, bundler.getLocalFilename(c.ref));
+                    // gen helper funcs
+                    asts.push(createQueryHelperCreator(ctx.generic, svc.methods[methodKey], svc.name, methodKey, helperCreatorName));
+                    if (genCustomHooksReact) {
+                        // gen custom react hooks
+                        reactAsts.push(createQueryHooks(ctx.generic, svc.methods[methodKey], methodKey, helperCreatorName, hookName));
+                    }
+                    if (genCustomHooksVue) {
+                        // gen custom vue hooks
+                        vueAsts.push(createVueQueryHooks(ctx.generic, svc.methods[methodKey], methodKey, helperCreatorName, hookName));
+                    }
+                });
+            }
+        });
+        if (!asts.length) {
+            return;
+        }
+        const serviceImports = getDepsFromQueries(getImportsFrom, localname);
+        const serviceImportsReact = getDepsFromQueries(getImportsFrom, localnameReact);
+        const serviceImportsVue = getDepsFromQueries(getImportsFrom, localnameVue);
+        // add imports from func file like query.rpc.func.ts without the .ts extension
+        const funcFileName = "./".concat(localname.substring(localname.lastIndexOf("/") + 1).replace(/\.ts$/, ""));
+        serviceImportsReact[funcFileName] = helperCreatorNameList;
+        serviceImportsVue[funcFileName] = helperCreatorNameList;
+        // TODO we do NOT need all imports...
+        const imports = buildAllImports(ctx, serviceImports, localname);
+        const importsReact = buildAllImports(ctx, serviceImportsReact, localnameReact);
+        const importsVue = buildAllImports(ctx, serviceImportsVue, localnameReact);
+        const prog = [].concat(imports).concat(ctx.body).concat(asts);
+        const progReact = [].concat(importsReact).concat(reactAsts);
+        const progVue = [].concat(importsVue).concat(vueAsts);
+        const exportedTypeNames = getExportedTypeNames(prog);
+        const exportedTypeNamesReact = getExportedTypeNames(progReact);
+        const exportedTypeNamesVue = getExportedTypeNames(progVue);
+        exportedTypeNames.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localname);
+        });
+        exportedTypeNamesReact.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localnameReact);
+        });
+        exportedTypeNamesVue.forEach((name) => {
+            builder.store.setHelperFuncFilesMapping(name, localnameVue);
+        });
+        bundler.writeAst(prog, filename);
+        bundler.addExportObjToBundle(c.ref.proto.package, localname, exportedTypeNames, true);
+        if (reactAsts.length) {
+            bundler.writeAst(progReact, filenameReact);
+            bundler.addExportObjToBundle(c.ref.proto.package, localnameReact, exportedTypeNamesReact, true);
+        }
+        if (vueAsts.length) {
+            bundler.writeAst(progVue, filenameVue);
+            bundler.addExportObjToBundle(c.ref.proto.package, localnameVue, exportedTypeNamesVue, true);
+        }
+        bundler.addToBundle(c, localname);
+        return bundlerFile;
+    })
+        .filter(Boolean);
+};

package/module/generators/create-react-query-bundle.js

@@ -0,0 +1,76 @@
+import { aggregateImports, getImportStatements } from '../imports';
+import { join } from 'path';
+import { createScopedRpcHookFactory } from '@cosmology/ast';
+import { TelescopeParseContext } from '../build';
+import { writeAstToFile } from '../utils/files';
+import { fixlocalpaths } from '../utils';
+import * as dotty from 'dotty';
+import { createEmptyProtoRef } from '@cosmology/proto-parser';
+import { camel, makeUseHookName, makeUsePkgHookName } from '@cosmology/utils';
+import { variableSlug } from '@cosmology/utils';
+import { swapKeyValue } from '@cosmology/utils';
+export const plugin = (builder) => {
+    // if react query is enabled
+    // generate hooks.ts based on query hooks generated in each package.
+    // eg: __fixtures__/output1/hooks.ts
+    if (!builder.options.reactQuery.enabled) {
+        return;
+    }
+    const localname = 'hooks.ts';
+    // get mapping of packages and rpc query filenames.
+    const obj = {};
+    const instantHooksMapping = {};
+    const methodSet = new Set();
+    const bundlerFiles = builder.stateManagers["reactQuery"];
+    if (!bundlerFiles || !bundlerFiles.length) {
+        return;
+    }
+    let nameMapping = builder.options.reactQuery?.instantExport?.nameMapping;
+    nameMapping = swapKeyValue(nameMapping ?? {});
+    bundlerFiles.map(bundlerFile => {
+        const path = `./${bundlerFile.localname.replace(/\.ts$/, '')}`;
+        dotty.put(obj, bundlerFile.package, path);
+        // build instantHooksMapping
+        bundlerFile.instantExportedMethods?.forEach((method) => {
+            const methodName = method.name;
+            const useHookName = makeUseHookName(camel(methodName));
+            const hookNameWithPkg = `${bundlerFile.package}.${useHookName}`;
+            let instantHookName = null;
+            if (nameMapping[hookNameWithPkg]) {
+                instantHookName = nameMapping[hookNameWithPkg];
+            }
+            else {
+                if (methodSet.has(useHookName)) {
+                    instantHookName = makeUsePkgHookName(bundlerFile.package, methodName);
+                }
+                else {
+                    instantHookName = useHookName;
+                }
+            }
+            dotty.put(instantHooksMapping, instantHookName, {
+                useHookName,
+                importedVarName: variableSlug(path),
+                comment: `${bundlerFile.package}.${useHookName}\n${method.comment ?? methodName}`
+            });
+            methodSet.add(instantHookName);
+        });
+    });
+    // create proto ref for context
+    const pkg = '@root';
+    const ref = 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 = createScopedRpcHookFactory(pCtx.proto, obj, 'createRpcQueryHooks', instantHooksMapping);
+    // 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/module/generators/create-registries.js

@@ -0,0 +1,45 @@
+import { buildAllImports, getDepsFromMutations } from '../imports';
+import { parse } from '../parse';
+import { getExportedTypeNames } from '../utils/files';
+export const plugin = (builder, bundler) => {
+    if (!builder.options.aminoEncoding?.enabled) {
+        return;
+    }
+    const mutationContexts = bundler
+        .contexts
+        .filter(context => context.mutations.length > 0);
+    // [x] write out one registry helper for all contexts w/mutations
+    const registries = mutationContexts.map(c => {
+        const enabled = c.amino.pluginValue('aminoEncoding.enabled');
+        if (!enabled)
+            return;
+        if (c.proto.isExcluded())
+            return;
+        const localname = bundler.getLocalFilename(c.ref, 'registry');
+        const filename = bundler.getFilename(localname);
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        parse(ctx);
+        ctx.buildRegistry();
+        ctx.buildRegistryLoader();
+        ctx.buildHelperObject();
+        const serviceImports = getDepsFromMutations(ctx.mutations, localname);
+        const imports = buildAllImports(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body);
+        const exportedTypeNames = getExportedTypeNames(prog);
+        exportedTypeNames.forEach((name) => {
+            builder.store.setTypeFilesMapping(name, localname);
+        });
+        bundler.addExportObjToBundle(c.ref.proto.package, localname, exportedTypeNames);
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+        return {
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+    }).filter(Boolean);
+    bundler.addRegistries(registries);
+};