@hyperweb/telescope 1.15.0

package/main/commands/transpile.js

@@ -0,0 +1,197 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompt_1 = require("../prompt");
+const index_1 = __importDefault(require("../index"));
+const fs_1 = require("fs");
+const types_1 = require("@cosmology/types");
+const path = __importStar(require("path"));
+const dotty = __importStar(require("dotty"));
+const deepmerge_1 = __importDefault(require("deepmerge"));
+exports.default = async (argv) => {
+    let options = {};
+    let protoDirs;
+    let outPath;
+    let data;
+    let overrideConfig = true;
+    if (argv.useDefaults) {
+        const defaultOptions = { ...types_1.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 = (0, fs_1.readFileSync)(inputConfigPath, {
+                    encoding: 'utf8'
+                });
+                if (configJson) {
+                    configJson = (0, deepmerge_1.default)(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((0, fs_1.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 (0, prompt_1.prompt)(questions, argv));
+    }
+    if (!Array.isArray(protoDirs)) {
+        protoDirs = [protoDirs];
+    }
+    // remove any duplicate protodirs
+    protoDirs = [...new Set(protoDirs)];
+    if (overrideConfig) {
+        (0, fs_1.writeFileSync)(process.cwd() + '/.telescope.json', JSON.stringify({
+            protoDirs,
+            outPath,
+            options
+        }, null, 2));
+    }
+    await (0, index_1.default)({
+        protoDirs,
+        outPath,
+        options
+    });
+    console.log(`✨ transpilation successful!`);
+};

package/main/contracts/generate.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompt_1 = require("../prompt");
+const ts_codegen_1 = require("@cosmwasm/ts-codegen");
+const contracts_1 = require("../utils/contracts");
+exports.default = async (argv) => {
+    const contracts = (0, contracts_1.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 (0, prompt_1.prompt)(questions, argv);
+    if (!Array.isArray(schema))
+        schema = [schema];
+    const s = await (0, contracts_1.getContractSchemata)(schema, out, argv);
+    s.forEach(async ({ contractName, schemas, outPath }) => {
+        await (0, ts_codegen_1.generateClient)(contractName, schemas, outPath);
+    });
+};

package/main/contracts/install.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const utils_1 = require("@cosmology/utils");
+const mkdirp_1 = require("mkdirp");
+const rimraf_1 = require("rimraf");
+const shelljs_1 = require("shelljs");
+const prompt_1 = require("../prompt");
+const parse_package_name_1 = require("parse-package-name");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const TMPDIR = (0, os_1.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 } = (0, parse_package_name_1.parse)(pkg);
+        return `${name}@${version}`;
+    }).join(' ');
+};
+exports.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((0, fs_1.readFileSync)((0, path_1.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 (0, prompt_1.prompt)([
+        {
+            type: 'checkbox',
+            name: 'pkg',
+            message: 'which chain contracts do you want to support?',
+            choices: [
+                'stargaze-base-factory',
+                'stargaze-base-minter',
+                'stargaze-sg721-base',
+                'stargaze-sg721-metdata-onchain',
+                'stargaze-sg721-nt',
+                'stargaze-splits',
+                'stargaze-vending-factory',
+                'stargaze-vending-minter',
+                'stargaze-whitelist',
+                'wasmswap',
+            ].map(name => {
+                return {
+                    name,
+                    value: `@cosmjson/${name}`
+                };
+            })
+        }
+    ], argv);
+    // install
+    if (!Array.isArray(pkg))
+        pkg = [pkg];
+    const tmp = (0, path_1.join)(TMPDIR, rnd());
+    mkdirp_1.mkdirp.sync(tmp);
+    process.chdir(tmp);
+    (0, shelljs_1.exec)(`npm install ${getPackages(pkg)} --production --prefix ./smart-contracts`);
+    // protos
+    const pkgs = (0, utils_1.crossGlob)('./smart-contracts/**/package.json');
+    const cmds = pkgs
+        .filter((f) => { return f !== './smart-contracts/package.json'; })
+        .map((f) => (0, path_1.resolve)((0, path_1.join)(tmp, f)))
+        .map((conf) => {
+        const extDir = (0, path_1.dirname)(conf);
+        const dir = extDir.split('node_modules/')[1];
+        const dst = (0, path_1.basename)(dir);
+        const files = (0, utils_1.crossGlob)(`${extDir}/**/*`, { nodir: true });
+        files.forEach(f => {
+            if ((0, path_1.extname)(f) === '.json'
+                || f === 'package.json'
+                || /license/i.test(f)
+                || /readme/i.test(f))
+                return;
+            (0, rimraf_1.rimrafSync)(f);
+        });
+        return [extDir, (0, path_1.resolve)((0, path_1.join)(cur, 'contracts', dst)), dir];
+    });
+    // move protos
+    for (const [src, dst, pkg] of cmds) {
+        (0, rimraf_1.rimrafSync)(dst);
+        console.log(`installing ${pkg}...`);
+        mkdirp_1.mkdirp.sync((0, path_1.dirname)(dst));
+        (0, shelljs_1.exec)(`mv ${src} ${dst}`);
+    }
+    // package
+    const packageInfo = JSON.parse((0, fs_1.readFileSync)('./smart-contracts/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());
+    (0, fs_1.writeFileSync)((0, path_1.join)(cur, 'package.json'), JSON.stringify(thisPackage, null, 2));
+    // cleanup
+    (0, rimraf_1.rimrafSync)(tmp);
+    process.chdir(cur);
+};

package/main/contracts/message-composer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompt_1 = require("../prompt");
+const ts_codegen_1 = require("@cosmwasm/ts-codegen");
+const contracts_1 = require("../utils/contracts");
+exports.default = async (argv) => {
+    const contracts = (0, contracts_1.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 (0, prompt_1.prompt)(questions, argv);
+    if (!Array.isArray(schema))
+        schema = [schema];
+    const s = await (0, contracts_1.getContractSchemata)(schema, out, argv);
+    s.forEach(async ({ contractName, schemas, outPath }) => {
+        await (0, ts_codegen_1.generateMessageComposer)(contractName, schemas, outPath);
+    });
+};

package/main/contracts/react-query.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompt_1 = require("../prompt");
+const ts_codegen_1 = require("@cosmwasm/ts-codegen");
+const contracts_1 = require("../utils/contracts");
+exports.default = async (argv) => {
+    const contracts = (0, contracts_1.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 (0, prompt_1.prompt)(questions, argv);
+    if (!Array.isArray(schema))
+        schema = [schema];
+    const s = await (0, contracts_1.getContractSchemata)(schema, out, argv);
+    s.forEach(async ({ contractName, schemas, outPath }) => {
+        await (0, ts_codegen_1.generateReactQuery)(contractName, schemas, outPath);
+    });
+};

package/main/contracts/recoil.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompt_1 = require("../prompt");
+const ts_codegen_1 = require("@cosmwasm/ts-codegen");
+const contracts_1 = require("../utils/contracts");
+exports.default = async (argv) => {
+    const contracts = (0, contracts_1.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 (0, prompt_1.prompt)(questions, argv);
+    if (!Array.isArray(schema))
+        schema = [schema];
+    const s = await (0, contracts_1.getContractSchemata)(schema, out, argv);
+    s.forEach(async ({ contractName, schemas, outPath }) => {
+        await (0, ts_codegen_1.generateRecoil)(contractName, schemas, outPath);
+    });
+};

package/main/file.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompt_1 = require("./prompt");
+const cli_1 = require("./cli");
+const fs_1 = require("fs");
+const argv = require('minimist')(process.argv.slice(2));
+const question = [
+    {
+        _: true,
+        type: 'string',
+        name: 'file',
+        message: 'file'
+    }
+];
+(async () => {
+    const { file } = await (0, prompt_1.prompt)(question, argv);
+    const argvv = JSON.parse((0, fs_1.readFileSync)(file, 'utf-8'));
+    await (0, cli_1.cli)(argvv);
+})();

package/main/generators/create-aggregated-lcd-client.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const proto_parser_1 = require("@cosmology/proto-parser");
+const parse_1 = require("../parse");
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const build_1 = require("../build");
+const files_1 = require("../utils/files");
+const utils_1 = require("../utils");
+const plugin = (builder) => {
+    if (!builder.options.aggregatedLCD) {
+        return;
+    }
+    const opts = builder.options.aggregatedLCD;
+    const { dir, filename: fname, packages, protos } = opts;
+    const localname = (0, path_1.join)(dir, fname);
+    const refs = builder.store.filterProtoWhere((ref) => {
+        return (0, proto_parser_1.isRefIncluded)(ref, {
+            packages,
+            protos
+        }) && !(0, proto_parser_1.isRefExcluded)(ref, builder.options.prototypes?.excluded);
+    });
+    const services = refs.map(ref => {
+        const proto = (0, proto_parser_1.getNestedProto)(ref.traversed);
+        if (!proto?.Query || proto.Query?.type !== 'Service') {
+            return;
+        }
+        return proto.Query;
+    }).filter(Boolean);
+    const tc = new build_1.TelescopeParseContext(refs[0], builder.store, builder.options);
+    const context = tc.proto;
+    const lcdast = (0, ast_1.createAggregatedLCDClient)(context, services, 'QueryClient');
+    const importsForAggregator = (0, imports_1.aggregateImports)(tc, {}, localname);
+    /////////
+    /////////
+    /////////
+    /////////
+    const queryContexts = builder
+        .contexts
+        .filter(context => context.queries.length > 0 ||
+        context.services.length > 0);
+    const progImports = queryContexts.reduce((m, c) => {
+        if (!(0, proto_parser_1.isRefIncluded)(c.ref, {
+            packages,
+            protos
+        })) {
+            return m;
+        }
+        const ctx = new build_1.TelescopeParseContext(c.ref, c.store, builder.options);
+        // get mutations, services
+        (0, parse_1.parse)(ctx);
+        const proto = (0, proto_parser_1.getNestedProto)(c.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;
+        }
+        ///
+        let getImportsFrom;
+        allowedRpcServices.forEach(svcKey => {
+            if (proto[svcKey]) {
+                if (svcKey === 'Query') {
+                    getImportsFrom = ctx.queries;
+                }
+                else {
+                    getImportsFrom = ctx.services;
+                }
+            }
+        });
+        const serviceImports = (0, imports_1.getDepsFromQueries)(getImportsFrom, localname);
+        const imports = (0, imports_1.aggregateImports)(ctx, serviceImports, localname);
+        return [...m, ...(0, utils_1.fixlocalpaths)(imports)];
+    }, []);
+    const importStmts = (0, imports_1.getImportStatements)(localname, [...importsForAggregator, ...progImports], builder.options);
+    const prog = []
+        .concat(importStmts)
+        .concat(lcdast);
+    const filename = (0, path_1.join)(builder.outPath, localname);
+    (0, files_1.writeAstToFile)(builder.outPath, builder.options, prog, filename);
+};
+exports.plugin = plugin;

package/main/generators/create-all-stargate-clients.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const path_1 = require("path");
+const ast_1 = require("@cosmology/ast");
+const case_1 = require("case");
+const utils_1 = require("@cosmology/utils");
+const imports_1 = require("../imports");
+const files_1 = require("../utils/files");
+const plugin = (builder, allRegistries, allConverters) => {
+    if (!allRegistries || !allRegistries.length) {
+        return;
+    }
+    const registryImports = [];
+    const converterImports = [];
+    const clientFile = 'all-module-client.ts';
+    builder.files.push(clientFile);
+    const ctxRef = {
+        absolute: '/',
+        filename: '/',
+        proto: {
+            imports: [],
+            package: null,
+            root: {},
+        }
+    };
+    const ctx = new ast_1.GenericParseContext(ctxRef, null, builder.options);
+    const registryVariables = [];
+    const converterVariables = [];
+    allRegistries.forEach(registry => {
+        let rel = (0, path_1.relative)((0, path_1.dirname)(clientFile), registry.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = (0, utils_1.toPosixPath)(rel);
+        const variable = (0, utils_1.variableSlug)(registry.localname);
+        registryVariables.push(variable);
+        registryImports.push((0, ast_1.importNamespace)(variable, rel));
+    });
+    allConverters.forEach(converter => {
+        let rel = (0, path_1.relative)((0, path_1.dirname)(clientFile), converter.localname);
+        if (!rel.startsWith('.'))
+            rel = `./${rel}`;
+        rel = (0, utils_1.toPosixPath)(rel);
+        const variable = (0, utils_1.variableSlug)(converter.localname);
+        converterVariables.push(variable);
+        converterImports.push((0, ast_1.importNamespace)(variable, rel));
+    });
+    const name = 'get' + (0, case_1.pascal)('AllSigningClient');
+    const txRpcName = 'get' + (0, case_1.pascal)('AllSigningTxRpc');
+    const prefix = (0, case_1.camel)('all');
+    const aminos = (0, ast_1.createStargateClientAminoRegistry)({
+        context: ctx,
+        aminos: converterVariables,
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const protos = (0, ast_1.createStargateClientProtoRegistry)({
+        context: ctx,
+        registries: registryVariables,
+        protoTypeRegistry: prefix + 'ProtoRegistry'
+    });
+    const clientOptions = (0, ast_1.createStargateClientOptions)({
+        context: ctx,
+        name: name + 'Options',
+        protoTypeRegistry: prefix + 'ProtoRegistry',
+        aminoConverters: prefix + 'AminoConverters'
+    });
+    const clientBody = (0, ast_1.createStargateClient)({
+        context: ctx,
+        name,
+        options: name + 'Options',
+    });
+    let getTxRpc;
+    if (ctx.pluginValue("stargateClients.addGetTxRpc")) {
+        getTxRpc = (0, ast_1.createGetTxRpc)(ctx, txRpcName, name);
+    }
+    const imports = (0, imports_1.buildAllImportsFromGenericContext)(ctx, clientFile);
+    let importDecls = [...imports, ...registryImports, ...converterImports];
+    importDecls = (0, utils_1.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 = (0, utils_1.toPosixPath)(cProg[i].source?.value);
+        }
+    }
+    if (getTxRpc) {
+        cProg = cProg.concat(getTxRpc);
+    }
+    const clientOutFile = (0, path_1.join)(builder.outPath, clientFile);
+    (0, files_1.writeAstToFile)(builder.outPath, builder.options, cProg, clientOutFile);
+};
+exports.plugin = plugin;

package/main/generators/create-amino-converters.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const imports_1 = require("../imports");
+const parse_1 = require("../parse");
+const plugin = (builder, bundler) => {
+    const aminoEncoding = builder.options.aminoEncoding;
+    if (!aminoEncoding?.enabled || !builder.options.rpcClients?.enabled) {
+        return;
+    }
+    const mutationContexts = bundler
+        .contexts
+        .filter(context => context.mutations.length > 0);
+    const converters = mutationContexts.map(c => {
+        const aminoEncodingEnabled = c.amino.pluginValue('aminoEncoding.enabled');
+        if (!aminoEncodingEnabled) {
+            return;
+        }
+        const localname = bundler.getLocalFilename(c.ref, 'amino');
+        const filename = bundler.getFilename(localname);
+        const ctx = bundler.getFreshContext(c);
+        // get mutations, services
+        (0, parse_1.parse)(ctx);
+        // now let's amino...
+        ctx.buildAminoInterfaces();
+        ctx.buildAminoConverter();
+        const serviceImports = (0, imports_1.getDepsFromMutations)(ctx.mutations, localname);
+        // build file
+        const imports = (0, imports_1.buildAllImports)(ctx, serviceImports, localname);
+        const prog = []
+            .concat(imports)
+            .concat(ctx.body);
+        bundler.writeAst(prog, filename);
+        bundler.addToBundle(c, localname);
+        return {
+            package: c.ref.proto.package,
+            localname,
+            filename
+        };
+    }).filter(Boolean);
+    bundler.addConverters(converters);
+};
+exports.plugin = plugin;