@cosmwasm/ts-codegen 0.25.2 → 0.27.0

package/module/builder/builder.js

@@ -1,20 +1,9 @@
-import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-const _excluded = ["enabled"],
-      _excluded2 = ["enabled"],
-      _excluded3 = ["enabled"],
-      _excluded4 = ["enabled"],
-      _excluded5 = ["enabled"];
 import { 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';
@@ -22,6 +11,12 @@ import { pascal } from "case";
 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 = {
   bundle: {
     enabled: true,
@@ -32,11 +27,33 @@ const defaultOpts = {
 ;
 ;
 ;
+
+function getContract(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
+  };
+}
+
 export class TSBuilder {
+  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
+    options,
+    plugins
   }) {
     _defineProperty(this, "contracts", void 0);
 
@@ -44,118 +61,49 @@ export class TSBuilder {
 
     _defineProperty(this, "options", void 0);
 
+    _defineProperty(this, "plugins", []);
+
     _defineProperty(this, "files", []);
 
     this.contracts = contracts;
     this.outPath = outPath;
     this.options = deepmerge(deepmerge(defaultOptions, defaultOpts), options ?? {});
-  }
+    this.loadDefaultPlugins();
 
-  getContracts() {
-    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) {
-    const _this$options$types = this.options.types,
-          {
-      enabled
-    } = _this$options$types,
-          options = _objectWithoutProperties(_this$options$types, _excluded);
-
-    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);
+    if (plugins && plugins.length) {
+      [].push.apply(this.plugins, plugins);
+    }
   }
 
-  async renderClient(contract) {
-    const _this$options$client = this.options.client,
-          {
-      enabled
-    } = _this$options$client,
-          options = _objectWithoutProperties(_this$options$client, _excluded2);
-
-    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 build() {
+    await this.process();
+    await this.after();
+  } // lifecycle functions
 
-  async renderRecoil(contract) {
-    const _this$options$recoil = this.options.recoil,
-          {
-      enabled
-    } = _this$options$recoil,
-          options = _objectWithoutProperties(_this$options$recoil, _excluded3);
 
-    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 process() {
+    for (const contractOpt of this.contracts) {
+      const contract = getContract(contractOpt); //resolve contract schema.
 
-  async renderReactQuery(contract) {
-    const _this$options$reactQu = this.options.reactQuery,
-          {
-      enabled
-    } = _this$options$reactQu,
-          options = _objectWithoutProperties(_this$options$reactQu, _excluded4);
+      const contractInfo = await readSchemas({
+        schemaDir: contract.dir
+      }); //lifecycle and plugins.
 
-    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);
+      await this.render(contract.name, contractInfo);
+    }
   }
 
-  async renderMessageComposer(contract) {
-    const _this$options$message = this.options.messageComposer,
-          {
-      enabled
-    } = _this$options$message,
-          options = _objectWithoutProperties(_this$options$message, _excluded5);
-
-    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 render(name, contractInfo) {
+    for (const plugin of this.plugins) {
+      let files = await plugin.render(name, contractInfo, this.outPath);
 
-  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 (files && files.length) {
+        [].push.apply(this.files, files);
+      }
     }
+  }
 
+  async after() {
     if (this.options.bundle.enabled) {
       this.bundle();
     }
@@ -164,16 +112,22 @@ export class TSBuilder {
   async bundle() {
     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, importPaths, bundleVariables);
+      createFileBundle(`${this.options.bundle.scope}.${file.contract}`, file.filename, bundlePath, importPaths, bundleVariables);
     });
     const ast = recursiveModuleBundle(bundleVariables);
     let code = generate(t.program([...importPaths, ...ast])).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/module/commands/generate.js

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

package/module/generators/msg-builder.js

@@ -0,0 +1,62 @@
+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 { getMessageProperties } from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
+import { RenderContext } from 'wasm-ast-types';
+export default (async (name, contractInfo, outPath, msgBuilderOptions) => {
+  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/module/index.js

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

package/module/plugins/client.js

@@ -0,0 +1,66 @@
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findExecuteMsg, findAndParseTypes, findQueryMsg } from '../utils';
+import { RenderContext, getMessageProperties } from 'wasm-ast-types';
+import { BuilderPluginBase } from './plugin-base';
+export class ClientPlugin extends BuilderPluginBase {
+  initContext(contract, options) {
+    return new RenderContext(contract, options);
+  }
+
+  async doRender(name, context) {
+    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/module/plugins/index.js

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

package/module/plugins/message-composer.js

@@ -0,0 +1,53 @@
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findAndParseTypes, findExecuteMsg } from '../utils';
+import { getMessageProperties, RenderContext } from 'wasm-ast-types';
+import { BuilderPluginBase } from './plugin-base';
+export class MessageComposerPlugin extends BuilderPluginBase {
+  initContext(contract, options) {
+    return new RenderContext(contract, options);
+  }
+
+  async doRender(name, context) {
+    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
+    }];
+  }
+
+}

package/module/plugins/msg-builder.js

@@ -0,0 +1,63 @@
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findAndParseTypes, findQueryMsg, findExecuteMsg } from '../utils';
+import { getMessageProperties, RenderContext } from 'wasm-ast-types';
+import { BuilderPluginBase } from './plugin-base';
+export class MsgBuilderPlugin extends BuilderPluginBase {
+  initContext(contract, options) {
+    return new RenderContext(contract, options);
+  }
+
+  async doRender(name, context) {
+    const {
+      enabled
+    } = this.option.msgBuilder;
+
+    if (!enabled) {
+      return;
+    }
+
+    const {
+      schemas
+    } = context.contract;
+    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;
+    }
+
+    return [{
+      type: 'msg-builder',
+      localname,
+      body
+    }];
+  }
+
+}

package/module/plugins/plugin-base.js

@@ -0,0 +1,59 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { sync as mkdirp } from 'mkdirp';
+import { join } from 'path';
+import { writeFileSync } from 'fs';
+import { header } from '../utils/header';
+import generate from '@babel/generator';
+import * as t from '@babel/types';
+
+/**
+ * BuilderPluginBase enable ts-codegen users implement their own plugins by only implement a few functions.
+ */
+export class BuilderPluginBase {
+  constructor(opt) {
+    _defineProperty(this, "option", void 0);
+
+    _defineProperty(this, "utils", void 0);
+
+    this.option = opt;
+  }
+
+  async render(name, contractInfo, outPath) {
+    const {
+      enabled
+    } = this.option;
+
+    if (!enabled) {
+      return;
+    }
+
+    const context = this.initContext(contractInfo, this.option);
+    const results = await this.doRender(name, context);
+
+    if (!results || !results.length) {
+      return [];
+    }
+
+    return results.map(result => {
+      const imports = context.getImports(this.utils);
+      const code = header + generate(t.program([...imports, ...result.body])).code;
+      mkdirp(outPath);
+      const filename = join(outPath, result.localname);
+      writeFileSync(filename, code);
+      return {
+        type: result.type,
+        pluginType: result.pluginType,
+        contract: name,
+        localname: result.localname,
+        filename
+      };
+    });
+  }
+  /**
+   * init context here
+   * @param contract
+   * @param options
+   */
+
+
+}

package/module/plugins/react-query.js

@@ -0,0 +1,77 @@
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
+import { getMessageProperties, RenderContext } from 'wasm-ast-types';
+import { BuilderPluginBase } from './plugin-base';
+export class ReactQueryPlugin extends BuilderPluginBase {
+  initContext(contract, options) {
+    return new RenderContext(contract, options);
+  }
+
+  async doRender(name, context) {
+    const options = this.option.reactQuery;
+    const {
+      enabled
+    } = options;
+
+    if (!enabled) {
+      return;
+    }
+
+    const {
+      schemas
+    } = context.contract;
+    const localname = pascal(`${name}`) + '.react-query.ts';
+    const ContractFile = pascal(`${name}`) + '.client';
+    const TypesFile = pascal(`${name}`) + '.types';
+    const QueryMsg = findQueryMsg(schemas);
+    const ExecuteMsg = findExecuteMsg(schemas);
+    const typeHash = await findAndParseTypes(schemas);
+    const ExecuteClient = pascal(`${name}Client`);
+    const QueryClient = pascal(`${name}QueryClient`);
+    const body = [];
+    const clientImports = [];
+    QueryMsg && clientImports.push(QueryClient); // check that there are commands within the exec msg
+
+    const shouldGenerateMutationHooks = ExecuteMsg && options?.version === 'v4' && options?.mutations && getMessageProperties(ExecuteMsg).length > 0;
+
+    if (shouldGenerateMutationHooks) {
+      clientImports.push(ExecuteClient);
+    } // general contract imports
+
+
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`)); // client imports
+
+    body.push(w.importStmt(clientImports, `./${ContractFile}`)); // query messages
+
+    if (QueryMsg) {
+      [].push.apply(body, w.createReactQueryHooks({
+        context,
+        queryMsg: QueryMsg,
+        contractName: name,
+        QueryClient
+      }));
+    }
+
+    if (shouldGenerateMutationHooks) {
+      [].push.apply(body, w.createReactQueryMutationHooks({
+        context,
+        execMsg: ExecuteMsg,
+        contractName: name,
+        ExecuteClient
+      }));
+    }
+
+    if (typeHash.hasOwnProperty('Coin')) {
+      // @ts-ignore
+      delete context.utils.Coin;
+    }
+
+    return [{
+      type: 'react-query',
+      localname,
+      body
+    }];
+  }
+
+}