@cosmwasm/ts-codegen 0.35.7 → 1.1.0

package/builder/builder.js

@@ -0,0 +1,172 @@
+"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 });
+exports.TSBuilder = void 0;
+const wasm_ast_types_1 = require("wasm-ast-types");
+const header_1 = require("../utils/header");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const mkdirp_1 = require("mkdirp");
+const path_2 = require("path");
+const utils_1 = require("../utils");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const case_1 = require("case");
+const bundler_1 = require("../bundler");
+const generator_1 = __importDefault(require("@babel/generator"));
+const t = __importStar(require("@babel/types"));
+const react_query_1 = require("../plugins/react-query");
+const recoil_1 = require("../plugins/recoil");
+const message_builder_1 = require("../plugins/message-builder");
+const message_composer_1 = require("../plugins/message-composer");
+const client_1 = require("../plugins/client");
+const types_1 = require("../plugins/types");
+const provider_1 = require("../plugins/provider");
+const create_helpers_1 = require("../generators/create-helpers");
+const provider_bundle_1 = require("../plugins/provider-bundle");
+const defaultOpts = {
+    bundle: {
+        enabled: true,
+        scope: 'contracts',
+        bundleFile: 'bundle.ts'
+    },
+    useShorthandCtor: true
+};
+;
+;
+;
+;
+function getContract(contractOpt) {
+    if (typeof contractOpt === 'string') {
+        const name = (0, path_2.basename)(contractOpt);
+        const contractName = (0, case_1.pascal)(name);
+        return {
+            name: contractName,
+            dir: contractOpt
+        };
+    }
+    return {
+        name: (0, case_1.pascal)(contractOpt.name),
+        dir: contractOpt.dir
+    };
+}
+class TSBuilder {
+    contracts;
+    outPath;
+    options;
+    plugins = [];
+    builderContext = new wasm_ast_types_1.BuilderContext();
+    files = [];
+    loadDefaultPlugins() {
+        this.plugins.push(new types_1.TypesPlugin(this.options), new client_1.ClientPlugin(this.options), new message_composer_1.MessageComposerPlugin(this.options), new react_query_1.ReactQueryPlugin(this.options), new recoil_1.RecoilPlugin(this.options), new message_builder_1.MessageBuilderPlugin(this.options), new provider_1.ContractsContextProviderPlugin(this.options));
+    }
+    constructor({ contracts, outPath, options, plugins }) {
+        this.contracts = contracts;
+        this.outPath = outPath;
+        this.options = (0, deepmerge_1.default)((0, deepmerge_1.default)(wasm_ast_types_1.defaultOptions, defaultOpts), options ?? {});
+        this.loadDefaultPlugins();
+        if (plugins && plugins.length) {
+            this.plugins.push(...plugins);
+        }
+        this.plugins.forEach(plugin => plugin.setBuilder(this));
+    }
+    async build() {
+        await this.process();
+        await this.after();
+    }
+    // lifecycle functions
+    async process() {
+        for (const contractOpt of this.contracts) {
+            const contract = getContract(contractOpt);
+            //resolve contract schema.
+            const contractInfo = await (0, utils_1.readSchemas)({
+                schemaDir: contract.dir
+            });
+            //lifecycle and plugins.
+            await this.render(contract.name, contractInfo);
+        }
+    }
+    async render(name, contractInfo) {
+        for (const plugin of this.plugins) {
+            let files = await plugin.render(name, contractInfo, this.outPath);
+            if (files && files.length) {
+                this.files.push(...files);
+            }
+        }
+    }
+    async after() {
+        //create useContracts bundle file
+        const contractsProviderBundlePlugin = new provider_bundle_1.ContractsProviderBundlePlugin(this.options);
+        contractsProviderBundlePlugin.setBuilder(this);
+        //contractContextProviders.ts
+        const files = await contractsProviderBundlePlugin.render("contractContextProviders", {
+            schemas: [],
+        }, this.outPath);
+        if (files && files.length) {
+            this.files.push(...files);
+        }
+        const helpers = (0, create_helpers_1.createHelpers)({
+            outPath: this.outPath,
+            contracts: this.contracts,
+            options: this.options,
+            plugins: this.plugins,
+        }, this.builderContext);
+        if (helpers && helpers.length) {
+            this.files.push(...helpers);
+        }
+        if (this.options.bundle.enabled) {
+            this.bundle();
+        }
+    }
+    async bundle() {
+        const allFiles = this.files;
+        const bundleFile = this.options.bundle.bundleFile;
+        const bundlePath = (0, path_1.join)(this.options?.bundle?.bundlePath ?? this.outPath, bundleFile);
+        const bundleVariables = {};
+        const importPaths = [];
+        allFiles.forEach(file => {
+            (0, bundler_1.createFileBundle)(`${this.options.bundle.scope}.${file.contract}`, file.filename, bundlePath, importPaths, bundleVariables);
+        });
+        const ast = (0, bundler_1.recursiveModuleBundle)(bundleVariables);
+        const nodes = [
+            ...importPaths,
+            ...ast
+        ];
+        // @ts-ignore
+        let code = (0, generator_1.default)(t.program(
+        // @ts-ignore
+        nodes)).code;
+        if (this.options?.bundle?.bundlePath) {
+            (0, mkdirp_1.sync)(this.options?.bundle?.bundlePath);
+        }
+        (0, mkdirp_1.sync)(this.outPath);
+        if (code.trim() === '')
+            code = 'export {};';
+        (0, fs_1.writeFileSync)(bundlePath, header_1.header + code);
+    }
+}
+exports.TSBuilder = TSBuilder;

package/builder/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./builder"), exports);

package/bundler/bundler.d.ts

@@ -0,0 +1,8 @@
+import * as t from '@babel/types';
+export interface BundleData {
+    __export?: boolean;
+    [key: string]: boolean | BundleData;
+}
+export declare const recursiveModuleBundle: (obj: BundleData) => t.ExportNamedDeclaration[];
+export declare const importNamespace: (ident: string, path: string) => t.ImportDeclaration;
+export declare const createFileBundle: (pkg: string, filename: string, bundleFile: string, importPaths: (t.ImportDeclaration | t.ImportDefaultSpecifier | t.ImportNamespaceSpecifier)[], bundleVariables: BundleData) => void;

package/bundler/bundler.js

@@ -0,0 +1,79 @@
+"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 });
+exports.createFileBundle = exports.importNamespace = exports.recursiveModuleBundle = void 0;
+const t = __importStar(require("@babel/types"));
+const nested_obj_1 = __importDefault(require("nested-obj"));
+const path_1 = require("path");
+const recursiveModuleBundle = (obj) => {
+    return Object.keys(obj).map(key => {
+        const value = obj[key];
+        if (typeof value === 'object' && value && value.__export) {
+            // e.g. abci
+            // 1. create variable for abci
+            // 2. splat ALL _0, parms into abci
+            // 3. export that variable
+            const nmspc = t.variableDeclaration('const', [t.variableDeclarator(t.identifier(key), t.objectExpression(Object.keys(obj[key])
+                    .filter(a => a !== '__export')
+                    .filter(a => a.startsWith('_'))
+                    .map(a => t.spreadElement(t.identifier(a)))))]);
+            const others = Object.keys(obj[key])
+                .filter(a => a !== '__export')
+                .filter(a => !a.startsWith('_'));
+            if (others.length) {
+                throw new Error('namespace and package not supported, yet.');
+            }
+            // return nmspc;
+            return t.exportNamedDeclaration(nmspc, []);
+        }
+        else if (typeof value === 'object' && value) {
+            // you can make a namespace for obj[key]
+            // e.g. libs
+            return t.exportNamedDeclaration(t.tsModuleDeclaration(t.identifier(key), t.tsModuleBlock((0, exports.recursiveModuleBundle)(obj[key]))));
+        }
+        else {
+            throw new Error('Invalid structure for BundleData');
+        }
+    });
+};
+exports.recursiveModuleBundle = recursiveModuleBundle;
+const importNamespace = (ident, path) => t.importDeclaration([
+    t.importNamespaceSpecifier(t.identifier(ident))
+], t.stringLiteral(path.replace((0, path_1.extname)(path), '')));
+exports.importNamespace = importNamespace;
+let counter = 0;
+const createFileBundle = (pkg, filename, bundleFile, importPaths, bundleVariables) => {
+    let rel = (0, path_1.relative)((0, path_1.dirname)(bundleFile), filename);
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    const variable = `_${counter++}`;
+    importPaths.push((0, exports.importNamespace)(variable, rel));
+    nested_obj_1.default.set(bundleVariables, pkg + '.__export', true);
+    nested_obj_1.default.set(bundleVariables, pkg + '.' + variable, true);
+};
+exports.createFileBundle = createFileBundle;

package/bundler/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bundler"), exports);

package/cli.d.ts

@@ -0,0 +1,2 @@
+import { MinimistArgs } from '@cosmology/ts-codegen-types';
+export declare const cli: (argv: MinimistArgs) => Promise<void>;

package/cli.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cli = void 0;
+const prompt_1 = require("./utils/prompt");
+const cmds_1 = require("./cmds");
+const question = [
+    {
+        _: true,
+        type: 'fuzzy',
+        name: 'cmd',
+        message: 'what do you want to do?',
+        choices: Object.keys(cmds_1.Commands)
+    }
+];
+const cli = async (argv) => {
+    var { cmd } = await (0, prompt_1.prompt)(question, argv);
+    if (typeof cmds_1.Commands[cmd] === 'function') {
+        await cmds_1.Commands[cmd](argv);
+    }
+    else {
+        console.log('command not found.');
+    }
+};
+exports.cli = cli;

package/cmds.d.ts

@@ -0,0 +1,2 @@
+declare const Commands: any;
+export { Commands };

package/cmds.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Commands = void 0;
+const create_boilerplate_1 = __importDefault(require("./commands/create-boilerplate"));
+const generate_1 = __importDefault(require("./commands/generate"));
+const install_1 = __importDefault(require("./commands/install"));
+const Commands = {};
+exports.Commands = Commands;
+Commands['create-boilerplate'] = create_boilerplate_1.default;
+Commands['generate'] = generate_1.default;
+Commands['install'] = install_1.default;

package/commands/create-boilerplate.d.ts

@@ -0,0 +1,3 @@
+import { MinimistArgs } from '@cosmology/ts-codegen-types';
+declare const _default: (argv: MinimistArgs) => Promise<never>;
+export default _default;

package/commands/create-boilerplate.js

@@ -0,0 +1,132 @@
+"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 shell = __importStar(require("shelljs"));
+const prompt_1 = require("../utils/prompt");
+const dargs_1 = __importDefault(require("dargs"));
+const glob = require('glob').sync;
+const fs = require('fs');
+const path = require('path');
+const repo = 'https://github.com/cosmology-tech/ts-codegen-module-boilerplate';
+exports.default = async (argv) => {
+    if (!shell.which('git')) {
+        shell.echo('Sorry, this script requires git');
+        return shell.exit(1);
+    }
+    const { name } = await (0, prompt_1.prompt)([
+        {
+            type: 'string',
+            name: 'name',
+            message: 'Enter your new module name',
+        }
+    ], argv);
+    shell.exec(`git clone ${repo} ${name}`);
+    shell.cd(name);
+    const questions = JSON.parse(fs.readFileSync(`.questions.json`));
+    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 = (0, dargs_1.default)({
+        _: [],
+        ...argv,
+        __MODULENAME__: name,
+        __USERFULLNAME__: fullname,
+        __USEREMAIL__: email,
+    }, { allowCamelCase: true });
+    const results = await (0, prompt_1.prompt)(questions, args);
+    let scopedResults;
+    const license = await (0, prompt_1.prompt)([
+        {
+            name: '__LICENSE__',
+            message: 'Which license?',
+            choices: ['MIT', 'closed'],
+            type: 'list',
+            required: true,
+        },
+    ], []);
+    if (results.__ACCESS__ === 'public') {
+        scopedResults = await (0, prompt_1.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) 2023 __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__}`);
+        }
+        // if (path.basename(templateFile) === 'README.md') {
+        //     content = `# ${results.__MODULENAME__}`;
+        // }
+        fs.writeFileSync(templateFile, content);
+    }
+    shell.rm('-rf', '.git');
+    shell.rm('-rf', '.questions.json');
+    console.log(`
+
+       |||
+      (o o)
+  ooO--(_)--Ooo-
+
+  ✨ Great work!
+  `);
+};

package/commands/generate.d.ts

@@ -0,0 +1,3 @@
+import { MinimistArgs } from '@cosmology/ts-codegen-types';
+declare const _default: (argv: MinimistArgs) => Promise<void>;
+export default _default;

package/commands/generate.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const prompt_1 = require("../utils/prompt");
+const index_1 = __importDefault(require("../index"));
+exports.default = async (argv) => {
+    const questions = [
+        {
+            _: true,
+            type: 'path',
+            name: 'schema',
+            message: 'which directory contains the the Rust contracts?',
+            default: './schema'
+        },
+        {
+            _: true,
+            type: 'path',
+            name: 'out',
+            message: 'where is the output directory?',
+            default: './ts'
+        },
+        {
+            _: true,
+            type: 'string',
+            name: 'name',
+            message: 'contract name?'
+        },
+        {
+            type: 'checkbox',
+            name: 'plugin',
+            message: 'which plugins?',
+            choices: [
+                'client',
+                'recoil',
+                'react-query',
+                'message-composer'
+            ]
+        },
+        {
+            type: 'confirm',
+            name: 'bundle',
+            message: 'enable bundle?',
+            default: true
+        }
+    ];
+    if (argv.typesOnly) {
+        argv.plugin = 'types';
+    }
+    let { schema, out, name, plugin, bundle } = await (0, prompt_1.prompt)(questions, argv);
+    if (!Array.isArray(plugin))
+        plugin = [plugin];
+    ///////// REACT QUERY
+    const questions2 = [];
+    if (plugin.includes('react-query')) {
+        // @ts-ignore
+        [].push.apply(questions2, [
+            {
+                type: 'confirm',
+                name: 'optionalClient',
+                message: 'optionalClient?',
+                default: false
+            },
+            {
+                type: 'list',
+                name: 'version',
+                message: 'which react-query version?',
+                default: 'v4',
+                choices: ['v3', 'v4']
+            },
+            {
+                type: 'confirm',
+                name: 'queryKeys',
+                message: 'queryKeys?',
+                default: false
+            },
+        ]);
+    }
+    ;
+    const { optionalClient, version, queryKeys } = await (0, prompt_1.prompt)(questions2, argv);
+    const questions3 = [];
+    if (version === 'v4') {
+        [].push.apply(questions3, [
+            // currently we only support v4 for useMutation
+            {
+                type: 'confirm',
+                name: 'mutations',
+                message: 'Generate useMutation hooks?',
+                default: false
+            }
+        ]);
+    }
+    ;
+    const { mutations } = await (0, prompt_1.prompt)(questions3, argv);
+    const queryFactoryQuestions = [];
+    if (queryKeys) {
+        [].push.apply(queryFactoryQuestions, [
+            // Only can use queryFactory if queryKeys is enabled
+            {
+                type: 'confirm',
+                name: 'queryFactory',
+                message: 'queryFactory? ',
+                default: false
+            }
+        ]);
+    }
+    ;
+    const { queryFactory } = await (0, prompt_1.prompt)(queryFactoryQuestions, argv);
+    ///////// END REACT QUERY
+    ///////// BUNDLE
+    const questions4 = [];
+    if (bundle) {
+        [].push.apply(questions4, [
+            {
+                type: 'string',
+                name: 'bundleFile',
+                message: 'bundleFile?',
+                default: 'index.ts'
+            },
+            {
+                type: 'string',
+                name: 'bundleScope',
+                message: 'bundleScope?',
+                default: 'contracts'
+            }
+        ]);
+    }
+    ;
+    const { bundleFile, bundleScope } = await (0, prompt_1.prompt)(questions4, argv);
+    ///////// END BUNDLE
+    const options = {
+        types: {
+            enabled: true
+        },
+        client: {
+            enabled: plugin.includes('client') ||
+                plugin.includes('recoil') ||
+                plugin.includes('react-query')
+        },
+        reactQuery: {
+            enabled: plugin.includes('react-query'),
+            optionalClient,
+            queryKeys,
+            version,
+            mutations,
+            queryFactory
+        },
+        recoil: {
+            enabled: plugin.includes('recoil'),
+        },
+        messageComposer: {
+            enabled: plugin.includes('message-composer')
+        },
+        messageBuilder: {
+            enabled: plugin.includes('message-builder')
+        },
+        bundle: {
+            enabled: bundle,
+            scope: bundleScope,
+            bundleFile
+        }
+    };
+    await (0, index_1.default)({
+        contracts: [
+            {
+                name,
+                dir: schema
+            }
+        ],
+        outPath: out,
+        options
+    });
+};

package/commands/install.d.ts

@@ -0,0 +1,3 @@
+import { MinimistArgs } from '@cosmology/ts-codegen-types';
+declare const _default: (argv: MinimistArgs) => Promise<void>;
+export default _default;