@cosmwasm/ts-codegen 0.25.2 → 0.26.0

package/module/plugins/recoil.js

@@ -0,0 +1,64 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findAndParseTypes, findQueryMsg } from '../utils';
+import { RenderContext } from 'wasm-ast-types';
+import { BuilderPluginBase } from './plugin-base';
+export class RecoilPlugin extends BuilderPluginBase {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "utils", {
+      selectorFamily: 'recoil'
+    });
+  }
+
+  initContext(contract, options) {
+    return new RenderContext(contract, options);
+  }
+
+  async doRender(name, context) {
+    const {
+      enabled
+    } = this.option.recoil;
+
+    if (!enabled) {
+      return;
+    }
+
+    const {
+      schemas
+    } = context.contract;
+    const localname = pascal(name) + '.recoil.ts';
+    const ContractFile = pascal(name) + '.client';
+    const TypesFile = pascal(name) + '.types';
+    const QueryMsg = findQueryMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+    let QueryClient = null;
+    let ReadOnlyInstance = null;
+    const body = [];
+    body.push(w.importStmt(['cosmWasmClient'], './chain'));
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`)); // query messages
+
+    if (QueryMsg) {
+      QueryClient = pascal(`${name}QueryClient`);
+      ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
+      body.push(w.importStmt([QueryClient], `./${ContractFile}`));
+      body.push(w.createRecoilQueryClientType());
+      body.push(w.createRecoilQueryClient(context, name, QueryClient));
+      [].push.apply(body, w.createRecoilSelectors(context, name, QueryClient, QueryMsg));
+    }
+
+    if (typeHash.hasOwnProperty('Coin')) {
+      // @ts-ignore
+      delete context.utils.Coin;
+    }
+
+    return [{
+      type: 'recoil',
+      localname,
+      body
+    }];
+  }
+
+}

package/module/plugins/types.js

@@ -0,0 +1,45 @@
+import * as t from '@babel/types';
+import { clean } from '../utils/clean';
+import { pascal } from 'case';
+import { findExecuteMsg, findAndParseTypes } from '../utils';
+import { RenderContext } from 'wasm-ast-types';
+import { BuilderPluginBase } from './plugin-base';
+export class TypesPlugin extends BuilderPluginBase {
+  initContext(contract, options) {
+    return new RenderContext(contract, options);
+  }
+
+  async doRender(name, context) {
+    const {
+      enabled
+    } = this.option.types;
+
+    if (!enabled) {
+      return;
+    }
+
+    const {
+      schemas
+    } = context.contract;
+    const options = this.option.types;
+    const localname = pascal(name) + '.types.ts';
+    const ExecuteMsg = findExecuteMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+    const body = []; // TYPES
+
+    Object.values(typeHash).forEach(type => {
+      body.push(clean(type));
+    }); // alias the ExecuteMsg
+
+    if (options.aliasExecuteMsg && ExecuteMsg) {
+      body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+    }
+
+    return [{
+      type: 'type',
+      localname,
+      body
+    }];
+  }
+
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmwasm/ts-codegen",
-  "version": "0.25.2",
+  "version": "0.26.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",
@@ -96,7 +96,7 @@
     "parse-package-name": "1.0.0",
     "rimraf": "3.0.2",
     "shelljs": "0.8.5",
-    "wasm-ast-types": "^0.18.2"
+    "wasm-ast-types": "^0.19.0"
   },
-  "gitHead": "a980b8040099876a056027f4bb45e83de86fb278"
+  "gitHead": "dccd0edd182dc4d5e58b30e7f46732e0be483bc1"
 }

package/src/builder/builder.ts

@@ -1,18 +1,13 @@
-import { RenderOptions, defaultOptions } from "wasm-ast-types";
+import { RenderOptions, defaultOptions, RenderContext, ContractInfo, MessageComposerOptions} 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 { IBuilderPlugin } from '../plugins';
 
 import deepmerge from 'deepmerge';
 import { pascal } from "case";
@@ -20,6 +15,12 @@ import { createFileBundle, recursiveModuleBundle } from "../bundler";
 
 import generate from '@babel/generator';
 import * as t from '@babel/types';
+import { ReactQueryPlugin } from "../plugins/react-query";
+import { RecoilPlugin } from "../plugins/recoil";
+import { MsgBuilderPlugin } from "../plugins/msg-builder";
+import { MessageComposerPlugin } from "../plugins/message-composer";
+import { ClientPlugin } from "../plugins/client";
+import { TypesPlugin } from "../plugins/types";
 
 const defaultOpts: TSBuilderOptions = {
     bundle: {
@@ -33,20 +34,25 @@ export interface TSBuilderInput {
     contracts: Array<ContractFile | string>;
     outPath: string;
     options?: TSBuilderOptions;
+    plugins?: IBuilderPlugin[];
 };
 
 export interface BundleOptions {
     enabled?: boolean;
     scope?: string;
     bundleFile?: string;
+    bundlePath?: string;
 };
 
 export type TSBuilderOptions = {
     bundle?: BundleOptions;
 } & RenderOptions;
 
+export type BuilderFileType = 'type' | 'client' | 'recoil' | 'react-query' | 'message-composer' | 'msg-builder' | 'plugin';
+
 export interface BuilderFile {
-    type: 'type' | 'client' | 'recoil' | 'react-query' | 'message-composer';
+    type: BuilderFileType;
+    pluginType?: string;
     contract: string;
     localname: string;
     filename: string;
@@ -56,14 +62,42 @@ export interface ContractFile {
     name: string;
     dir: string;
 }
+
+function getContract(contractOpt): ContractFile {
+    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
+    };
+}
+
 export class TSBuilder {
     contracts: Array<ContractFile | string>;
     outPath: string;
     options?: TSBuilderOptions;
+    plugins: IBuilderPlugin[] = [];
 
     protected files: BuilderFile[] = [];
 
-    constructor({ contracts, outPath, options }: TSBuilderInput) {
+    loadDefaultPlugins() {
+        [].push.apply(this.plugins, [
+            new TypesPlugin(this.options),
+            new ClientPlugin(this.options),
+            new MessageComposerPlugin(this.options),
+            new ReactQueryPlugin(this.options),
+            new RecoilPlugin(this.options),
+            new MsgBuilderPlugin(this.options),
+        ]);
+    }
+
+    constructor({ contracts, outPath, options, plugins }: TSBuilderInput) {
         this.contracts = contracts;
         this.outPath = outPath;
         this.options = deepmerge(
@@ -73,85 +107,43 @@ export class TSBuilder {
             ),
             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);
-    }
+        this.loadDefaultPlugins();
 
-    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);
+        if (plugins && plugins.length) {
+            [].push.apply(this.plugins, plugins);
+        }
     }
 
-    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 build() {
+        await this.process();
+        await this.after();
     }
 
-    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);
+    // lifecycle functions
+    private async process(){
+        for (const contractOpt of this.contracts) {
+            const contract = getContract(contractOpt);
+            //resolve contract schema.
+            const contractInfo = await readSchemas({
+                schemaDir: contract.dir
+            });
+
+            //lifecycle and plugins.
+            await this.render(contract.name, contractInfo);
+        }
     }
 
-    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);
+    private async render(name: string, contractInfo: ContractInfo){
+      for (const plugin of this.plugins) {
+          let files = await plugin.render(name, contractInfo, this.outPath);
+          if(files && files.length){
+              [].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);
-        }
+    private async after(){
         if (this.options.bundle.enabled) {
             this.bundle();
         }
@@ -162,14 +154,18 @@ export class TSBuilder {
         const allFiles = this.files;
 
         const bundleFile = this.options.bundle.bundleFile;
+        const bundlePath = join(
+          this.options?.bundle?.bundlePath ?? this.outPath,
+          bundleFile
+        );
         const bundleVariables = {};
         const importPaths = [];
 
         allFiles.forEach(file => {
             createFileBundle(
                 `${this.options.bundle.scope}.${file.contract}`,
-                file.localname,
-                bundleFile,
+                file.filename,
+                bundlePath,
                 importPaths,
                 bundleVariables
             );
@@ -184,11 +180,15 @@ export class TSBuilder {
             ]
         )).code;
 
+        if(this.options?.bundle?.bundlePath){
+            mkdirp(this.options?.bundle?.bundlePath);
+        }
+
         mkdirp(this.outPath);
 
         if (code.trim() === '') code = 'export {};'
 
-        writeFileSync(join(this.outPath, bundleFile), header + code);
+        writeFileSync(bundlePath, header + code);
 
     }
-}
+}

package/src/commands/generate.ts

@@ -151,6 +151,9 @@ export default async (argv) => {
         messageComposer: {
             enabled: plugin.includes('message-composer')
         },
+        msgBuilder: {
+          enabled: plugin.includes('msg-builder')
+        },
         bundle: {
             enabled: bundle,
             scope: bundleScope,

package/src/generators/msg-builder.ts

@@ -0,0 +1,80 @@
+import { pascal } from "case";
+import { header } from "../utils/header";
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from "wasm-ast-types";
+import * as t from "@babel/types";
+import { writeFileSync } from "fs";
+import generate from "@babel/generator";
+import { ContractInfo, getMessageProperties } from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
+import { RenderContext, MsgBuilderOptions } from 'wasm-ast-types';
+import { BuilderFile } from "../builder";
+import babelTraverse from '@babel/traverse';
+import { parse as babelParse } from '@babel/parser'
+
+export default async (
+  name: string,
+  contractInfo: ContractInfo,
+  outPath: string,
+  msgBuilderOptions?: MsgBuilderOptions
+): Promise<BuilderFile[]> => {
+  const { schemas } = contractInfo;
+  const context = new RenderContext(contractInfo, {
+    msgBuilder: msgBuilderOptions ?? {},
+  });
+
+  const localname = pascal(name) + ".msg-builder.ts";
+  const TypesFile = pascal(name) + ".types";
+  const ExecuteMsg = findExecuteMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+
+  const body = [];
+
+  body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+  body.push(w.importStmt(["CamelCasedProperties"], "type-fest"));
+
+  // execute messages
+  if (ExecuteMsg) {
+    const children = getMessageProperties(ExecuteMsg);
+    if (children.length > 0) {
+      const className = pascal(`${name}ExecuteMsgBuilder`);
+
+      body.push(
+        w.createMsgBuilderClass(context, className, ExecuteMsg)
+      );
+    }
+  }
+
+  const QueryMsg = findQueryMsg(schemas);
+  // query messages
+  if (QueryMsg) {
+    const children = getMessageProperties(QueryMsg);
+    if (children.length > 0) {
+      const className = pascal(`${name}QueryMsgBuilder`);
+
+      body.push(
+        w.createMsgBuilderClass(context, className, QueryMsg)
+      );
+    }
+  }
+
+  if (typeHash.hasOwnProperty("Coin")) {
+    // @ts-ignore
+    delete context.utils.Coin;
+  }
+  const imports = context.getImports();
+  const code = header + generate(t.program([...imports, ...body])).code;
+
+  mkdirp(outPath);
+  writeFileSync(join(outPath, localname), code);
+
+  return [
+    {
+      type: "msg-builder",
+      contract: name,
+      localname,
+      filename: join(outPath, localname),
+    },
+  ];
+};

package/src/index.ts

@@ -9,6 +9,7 @@ export { default as generateRecoil } from './generators/recoil';
 export * from './utils';
 export * from './builder';
 export * from './bundler';
+export * from './plugins';
 
 export default async (input: TSBuilderInput) => {
     const builder = new TSBuilder(input);

package/src/plugins/client.ts

@@ -0,0 +1,108 @@
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findExecuteMsg, findAndParseTypes, findQueryMsg } from '../utils';
+import {
+  RenderContext,
+  ContractInfo,
+  RenderContextBase,
+  getMessageProperties,
+  RenderOptions
+} from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+
+export class ClientPlugin extends BuilderPluginBase<RenderOptions> {
+  initContext(
+    contract: ContractInfo,
+    options?: RenderOptions
+  ): RenderContextBase<RenderOptions> {
+    return new RenderContext(contract, options);
+  }
+
+  async doRender(
+    name: string,
+    context: RenderContext
+  ): Promise<
+    {
+      type: BuilderFileType;
+      pluginType?: string;
+      localname: string;
+      body: any[];
+    }[]
+  > {
+    const { enabled } = this.option.client;
+
+    if (!enabled) {
+      return;
+    }
+
+    const { schemas } = context.contract;
+
+    const localname = pascal(name) + '.client.ts';
+    const TypesFile = pascal(name) + '.types';
+    const QueryMsg = findQueryMsg(schemas);
+    const ExecuteMsg = findExecuteMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+
+    let Client = null;
+    let Instance = null;
+    let QueryClient = null;
+    let ReadOnlyInstance = null;
+
+    const body = [];
+
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+
+    // query messages
+    if (QueryMsg) {
+      QueryClient = pascal(`${name}QueryClient`);
+      ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
+
+      body.push(w.createQueryInterface(context, ReadOnlyInstance, QueryMsg));
+      body.push(
+        w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg)
+      );
+    }
+
+    // execute messages
+    if (ExecuteMsg) {
+      const children = getMessageProperties(ExecuteMsg);
+      if (children.length > 0) {
+        Client = pascal(`${name}Client`);
+        Instance = pascal(`${name}Interface`);
+
+        body.push(
+          w.createExecuteInterface(
+            context,
+            Instance,
+            this.option.client.execExtendsQuery ? ReadOnlyInstance : null,
+            ExecuteMsg
+          )
+        );
+
+        body.push(
+          w.createExecuteClass(
+            context,
+            Client,
+            Instance,
+            this.option.client.execExtendsQuery ? QueryClient : null,
+            ExecuteMsg
+          )
+        );
+      }
+    }
+
+    if (typeHash.hasOwnProperty('Coin')) {
+      // @ts-ignore
+      delete context.utils.Coin;
+    }
+
+    return [
+      {
+        type: 'client',
+        localname,
+        body
+      }
+    ];
+  }
+}

package/src/plugins/index.ts

@@ -0,0 +1 @@
+export * from "./plugin-base"

package/src/plugins/message-composer.ts

@@ -0,0 +1,80 @@
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findAndParseTypes, findExecuteMsg } from '../utils';
+import {
+  MessageComposerOptions,
+  getMessageProperties,
+  ContractInfo,
+  RenderContextBase,
+  RenderContext,
+  RenderOptions
+} from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+
+export class MessageComposerPlugin extends BuilderPluginBase<RenderOptions> {
+  initContext(
+    contract: ContractInfo,
+    options?: RenderOptions
+  ): RenderContextBase<RenderOptions> {
+    return new RenderContext(contract, options);
+  }
+
+  async doRender(
+    name: string,
+    context: RenderContext
+  ): Promise<
+    {
+      type: BuilderFileType;
+      pluginType?: string;
+      localname: string;
+      body: any[];
+    }[]
+  > {
+    const { enabled } = this.option.messageComposer;
+
+    if (!enabled) {
+      return;
+    }
+
+    const { schemas } = context.contract;
+
+    const localname = pascal(name) + '.message-composer.ts';
+    const TypesFile = pascal(name) + '.types';
+    const ExecuteMsg = findExecuteMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+
+    const body = [];
+
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+
+    // execute messages
+    if (ExecuteMsg) {
+      const children = getMessageProperties(ExecuteMsg);
+      if (children.length > 0) {
+        const TheClass = pascal(`${name}MessageComposer`);
+        const Interface = pascal(`${name}Message`);
+
+        body.push(
+          w.createMessageComposerInterface(context, Interface, ExecuteMsg)
+        );
+        body.push(
+          w.createMessageComposerClass(context, TheClass, Interface, ExecuteMsg)
+        );
+      }
+    }
+
+    if (typeHash.hasOwnProperty('Coin')) {
+      // @ts-ignore
+      delete context.utils.Coin;
+    }
+
+    return [
+      {
+        type: 'message-composer',
+        localname,
+        body
+      }
+    ];
+  }
+}