@cosmwasm/ts-codegen 0.17.0 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmwasm/ts-codegen",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "@cosmwasm/ts-codegen converts your CosmWasm smart contracts into dev-friendly TypeScript classes so you can focus on shipping code.",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "homepage": "https://github.com/cosmwasm/ts-codegen",
@@ -18,13 +18,15 @@
   "files": [
     "types",
     "main",
+    "src",
     "module"
   ],
   "scripts": {
     "build:main": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start --extensions \".tsx,.ts,.js\"",
     "build:module": "cross-env MODULE=true babel src --out-dir module --delete-dir-on-start  --extensions \".tsx,.ts,.js\"",
-    "build": "npm run build:module && npm run build:main",
     "build:ts": "tsc --project ./tsconfig.json",
+    "build": "npm run build:module && npm run build:main",
+    "buidl": "npm run build && npm run build:ts",
     "prepare": "npm run build",
     "dev": "cross-env NODE_ENV=development babel-node src/ts-codegen --extensions \".tsx,.ts,.js\"",
     "watch": "cross-env NODE_ENV=development babel-watch src/ts-codegen --extensions \".tsx,.ts,.js\"",
@@ -94,7 +96,7 @@
     "parse-package-name": "1.0.0",
     "rimraf": "3.0.2",
     "shelljs": "0.8.5",
-    "wasm-ast-types": "^0.11.3"
+    "wasm-ast-types": "^0.12.0"
   },
-  "gitHead": "98faaab5547b61074b697d7e5728a1788ef52826"
+  "gitHead": "59dcc054d241c6bf43d5a617b31c3cd5c4ecff6e"
 }

package/src/builder/builder.ts

@@ -0,0 +1,194 @@
+import { RenderOptions, defaultOptions } from "wasm-ast-types";
+
+import { header } from '../utils/header';
+import { join } from "path";
+import { writeFileSync } from 'fs';
+import { sync as mkdirp } from "mkdirp";
+
+import generateMessageComposer from '../generators/message-composer';
+import generateTypes from '../generators/types';
+import generateReactQuery from '../generators/react-query';
+import generateRecoil from '../generators/recoil';
+import generateClient from '../generators/client';
+
+import { basename } from 'path';
+import { readSchemas } from '../utils';
+
+import deepmerge from 'deepmerge';
+import { pascal } from "case";
+import { createFileBundle, recursiveModuleBundle } from "../bundler";
+
+import generate from '@babel/generator';
+import * as t from '@babel/types';
+
+const defaultOpts: TSBuilderOptions = {
+    bundle: {
+        enabled: true,
+        scope: 'contracts',
+        bundleFile: 'bundle.ts'
+    }
+}
+
+export interface TSBuilderInput {
+    contracts: Array<ContractFile | string>;
+    outPath: string;
+    options?: TSBuilderOptions;
+};
+
+export interface BundleOptions {
+    enabled?: boolean;
+    scope?: string;
+    bundleFile?: string;
+};
+
+export type TSBuilderOptions = {
+    bundle?: BundleOptions;
+} & RenderOptions;
+
+export interface BuilderFile {
+    type: 'type' | 'client' | 'recoil' | 'react-query' | 'message-composer';
+    contract: string;
+    localname: string;
+    filename: string;
+};
+
+export interface ContractFile {
+    name: string;
+    dir: string;
+}
+export class TSBuilder {
+    contracts: Array<ContractFile | string>;
+    outPath: string;
+    options?: TSBuilderOptions;
+
+    protected files: BuilderFile[] = [];
+
+    constructor({ contracts, outPath, options }: TSBuilderInput) {
+        this.contracts = contracts;
+        this.outPath = outPath;
+        this.options = deepmerge(
+            deepmerge(
+                defaultOptions,
+                defaultOpts
+            ),
+            options ?? {}
+        );
+    }
+
+    getContracts(): ContractFile[] {
+        return this.contracts.map(contractOpt => {
+            if (typeof contractOpt === 'string') {
+                const name = basename(contractOpt);
+                const contractName = pascal(name);
+                return {
+                    name: contractName,
+                    dir: contractOpt
+                }
+            }
+            return {
+                name: pascal(contractOpt.name),
+                dir: contractOpt.dir
+            };
+        });
+    }
+
+    async renderTypes(contract: ContractFile) {
+        const { enabled, ...options } = this.options.types;
+        if (!enabled) return;
+        const contractInfo = await readSchemas({
+            schemaDir: contract.dir
+        });
+        const files = await generateTypes(contract.name, contractInfo, this.outPath, options);
+        [].push.apply(this.files, files);
+    }
+
+    async renderClient(contract: ContractFile) {
+        const { enabled, ...options } = this.options.client;
+        if (!enabled) return;
+        const contractInfo = await readSchemas({
+            schemaDir: contract.dir
+        });
+        const files = await generateClient(contract.name, contractInfo, this.outPath, options);
+        [].push.apply(this.files, files);
+    }
+
+    async renderRecoil(contract: ContractFile) {
+        const { enabled, ...options } = this.options.recoil;
+        if (!enabled) return;
+        const contractInfo = await readSchemas({
+            schemaDir: contract.dir
+        });
+        const files = await generateRecoil(contract.name, contractInfo, this.outPath, options);
+        [].push.apply(this.files, files);
+    }
+
+    async renderReactQuery(contract: ContractFile) {
+        const { enabled, ...options } = this.options.reactQuery;
+        if (!enabled) return;
+        const contractInfo = await readSchemas({
+            schemaDir: contract.dir
+        });
+        const files = await generateReactQuery(contract.name, contractInfo, this.outPath, options);
+        [].push.apply(this.files, files);
+    }
+
+    async renderMessageComposer(contract: ContractFile) {
+        const { enabled, ...options } = this.options.messageComposer;
+        if (!enabled) return;
+        const contractInfo = await readSchemas({
+            schemaDir: contract.dir
+        });
+        const files = await generateMessageComposer(contract.name, contractInfo, this.outPath, options);
+        [].push.apply(this.files, files);
+    }
+
+    async build() {
+        const contracts = this.getContracts();
+        for (let c = 0; c < contracts.length; c++) {
+            const contract = contracts[c];
+            await this.renderTypes(contract);
+            await this.renderClient(contract);
+            await this.renderMessageComposer(contract);
+            await this.renderReactQuery(contract);
+            await this.renderRecoil(contract);
+        }
+        if (this.options.bundle.enabled) {
+            this.bundle();
+        }
+    }
+
+    async bundle() {
+
+        const allFiles = this.files;
+
+        const bundleFile = this.options.bundle.bundleFile;
+        const bundleVariables = {};
+        const importPaths = [];
+
+        allFiles.forEach(file => {
+            createFileBundle(
+                `${this.options.bundle.scope}.${file.contract}`,
+                file.localname,
+                bundleFile,
+                importPaths,
+                bundleVariables
+            );
+
+        });
+
+        const ast = recursiveModuleBundle(bundleVariables);
+        let code = generate(t.program(
+            [
+                ...importPaths,
+                ...ast
+            ]
+        )).code;
+
+        mkdirp(this.outPath);
+
+        if (code.trim() === '') code = 'export {};'
+
+        writeFileSync(join(this.outPath, bundleFile), header + code);
+
+    }
+}

package/src/builder/index.ts

@@ -0,0 +1 @@
+export * from './builder';

package/src/bundler/bundler.ts

@@ -0,0 +1,67 @@
+import * as t from '@babel/types';
+import * as dotty from 'dotty';
+import {
+    relative, dirname, extname
+} from 'path';
+
+export const recursiveModuleBundle = (obj) => {
+    return Object.keys(obj).map(key => {
+        if (obj[key]?.__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 {
+            // you can make a namespace for obj[key]
+            // e.g. libs
+            return t.exportNamedDeclaration(
+                t.tsModuleDeclaration(
+                    t.identifier(key),
+                    t.tsModuleBlock(recursiveModuleBundle(obj[key]))
+                )
+            )
+        }
+    });
+};
+
+export const importNamespace = (ident: string, path: string) => t.importDeclaration(
+    [
+        t.importNamespaceSpecifier(t.identifier(ident))
+    ],
+    t.stringLiteral(path.replace(extname(path), ''))
+);
+
+let counter = 0;
+export const createFileBundle = (pkg, filename, bundleFile, importPaths, bundleVariables) => {
+    let rel = relative(dirname(bundleFile), filename);
+    if (!rel.startsWith('.')) rel = `./${rel}`;
+    const variable = `_${counter++}`;
+    importPaths.push(importNamespace(variable, rel));
+    dotty.put(bundleVariables, pkg + '.__export', true);
+    dotty.put(bundleVariables, pkg + '.' + variable, true);
+}

package/src/bundler/index.ts

@@ -0,0 +1 @@
+export * from './bundler';

package/src/cli.js

@@ -0,0 +1,21 @@
+import { prompt } from './utils/prompt';
+import { Commands as commands } from './cmds';
+
+const question = [
+  {
+    _: true,
+    type: 'fuzzy',
+    name: 'cmd',
+    message: 'what do you want to do?',
+    choices: Object.keys(commands)
+  }
+];
+
+export const cli = async (argv) => {
+  var { cmd } = await prompt(question, argv);
+  if (typeof commands[cmd] === 'function') {
+    await commands[cmd](argv);
+  } else {
+    console.log('command not found.');
+  }
+};

package/src/cmds.js

@@ -0,0 +1,12 @@
+
+import _create_boilerplate from './commands/create-boilerplate';
+import _generate from './commands/generate';
+import _install from './commands/install';
+const Commands = {};
+Commands['create-boilerplate'] = _create_boilerplate;
+Commands['generate'] = _generate;
+Commands['install'] = _install;
+
+  export { Commands }; 
+
+  

package/src/commands/create-boilerplate.ts

@@ -0,0 +1,139 @@
+import * as shell from 'shelljs';
+import { prompt } from '../utils/prompt';
+import dargs from 'dargs';
+const glob = require('glob').sync;
+const fs = require('fs');
+const path = require('path');
+
+const repo = 'https://github.com/pyramation/tmpl-cosmwasm-module.git';
+export default async argv => {
+    if (!shell.which('git')) {
+        shell.echo('Sorry, this script requires git');
+        return shell.exit(1);
+    }
+
+    const { name } = await 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 = dargs(
+        {
+            _: [],
+            ...argv,
+            __MODULENAME__: name,
+            __USERFULLNAME__: fullname,
+            __USEREMAIL__: email,
+        },
+        { allowCamelCase: true }
+    );
+
+    const results = await prompt(questions, args);
+    let scopedResults;
+
+    const license = await prompt(
+        [
+            {
+                name: '__LICENSE__',
+                message: 'Which license?',
+                choices: ['MIT', 'closed'],
+                type: 'list',
+                required: true,
+            },
+        ],
+        []
+    );
+
+    if (results.__ACCESS__ === 'public') {
+        scopedResults = await prompt(
+            [
+                {
+                    type: 'confirm',
+                    name: 'scoped',
+                    message: 'use npm scopes?',
+                    required: true,
+                },
+            ],
+            []
+        );
+    }
+
+    const files = []
+        .concat(glob(process.cwd() + '/**/.*'))
+        .concat(glob(process.cwd() + '/**/*'));
+
+    for (let i = 0; i < files.length; i++) {
+        const templateFile = files[i];
+        if (fs.lstatSync(templateFile).isDirectory()) continue;
+
+        let content = fs.readFileSync(templateFile).toString();
+        if (
+            path.basename(templateFile) === 'LICENSE' &&
+            license.__LICENSE__ === 'closed'
+        ) {
+            content = `Copyright (c) 2022 __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/src/commands/generate.ts

@@ -0,0 +1,156 @@
+import { prompt } from '../utils/prompt';
+import codegen from '../index';
+import { TSBuilderOptions } from '../builder';
+
+export 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 prompt(questions, argv);
+    if (!Array.isArray(plugin)) plugin = [plugin];
+
+    ///////// REACT QUERY
+    const questions2 = [];
+    if (plugin.includes('react-query')) {
+        [].push.apply(questions2, [
+            {
+                type: 'confirm',
+                name: 'optionalClient',
+                message: 'optionalClient?',
+                default: false
+            },
+            {
+                type: 'list',
+                name: 'version',
+                message: 'which react-query version?',
+                default: 'v3',
+                choices: ['v3', 'v4']
+            },
+            {
+                type: 'confirm',
+                name: 'queryKeys',
+                message: 'queryKeys?',
+                default: false
+            },
+        ])
+    };
+    const { optionalClient, version, queryKeys } = await 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 prompt(questions3, 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 prompt(questions4, argv);
+    ///////// END BUNDLE
+
+    const options: TSBuilderOptions = {
+        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
+        },
+        recoil: {
+            enabled: plugin.includes('recoil'),
+        },
+        messageComposer: {
+            enabled: plugin.includes('message-composer')
+        },
+        bundle: {
+            enabled: bundle,
+            scope: bundleScope,
+            bundleFile
+        }
+    };
+
+    await codegen({
+        contracts: [
+            {
+                name,
+                dir: schema
+            }
+        ],
+        outPath: out,
+        options
+    })
+};