@cosmwasm/ts-codegen 0.25.2 → 0.26.0

package/src/plugins/msg-builder.ts

@@ -0,0 +1,85 @@
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findAndParseTypes, findQueryMsg, findExecuteMsg } from '../utils';
+import {
+  getMessageProperties,
+  RenderContext,
+  RenderContextBase,
+  ContractInfo,
+  RenderOptions
+} from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+
+export class MsgBuilderPlugin 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.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/src/plugins/plugin-base.ts

@@ -0,0 +1,112 @@
+import { sync as mkdirp } from 'mkdirp';
+import { join } from 'path';
+import { writeFileSync } from 'fs';
+import { header } from '../utils/header';
+import {
+  ContractInfo,
+  UtilMapping,
+  IContext
+} from 'wasm-ast-types';
+import generate from '@babel/generator';
+import * as t from '@babel/types';
+import { BuilderFile, BuilderFileType, TSBuilderOptions } from '../builder';
+
+/**
+ * IBuilderPlugin is a common plugin that render generated code.
+ */
+export interface IBuilderPlugin {
+  /**
+   * a mapping of utils will be used in generated code.
+   */
+  utils: UtilMapping;
+
+  /**
+   * render generated cdoe.
+   * @param name the name of contract
+   * @param contractInfo contract
+   * @param outPath the path of generated code.
+   * @returns info of generated files.
+   */
+  render(
+    name: string,
+    contractInfo: ContractInfo,
+    outPath: string,
+  ): Promise<BuilderFile[]>;
+}
+
+/**
+ * BuilderPluginBase enable ts-codegen users implement their own plugins by only implement a few functions.
+ */
+export abstract class BuilderPluginBase<TOpt extends { enabled?: boolean }> implements IBuilderPlugin {
+  option: TOpt;
+  utils: UtilMapping;
+
+  constructor(opt: TOpt) {
+    this.option = opt;
+  }
+
+  async render(
+    name: string,
+    contractInfo: ContractInfo,
+    outPath: string
+  ): Promise<BuilderFile[]> {
+    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
+   */
+  abstract initContext(
+    contract: ContractInfo,
+    options?: TOpt
+  ): IContext;
+
+  /**
+   * render generated code here.
+   * @param name
+   * @param context
+   */
+  abstract doRender(
+    name: string,
+    context: IContext
+  ): Promise<
+    {
+      type: BuilderFileType;
+      pluginType?: string;
+      localname: string;
+      body: any[];
+    }[]
+  >;
+}

package/src/plugins/react-query.ts

@@ -0,0 +1,115 @@
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from '../utils';
+import {
+  getMessageProperties,
+  ContractInfo,
+  RenderOptions,
+  RenderContextBase,
+  RenderContext
+} from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+
+export class ReactQueryPlugin 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 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
+      }
+    ];
+  }
+}

package/src/plugins/recoil.ts

@@ -0,0 +1,89 @@
+import { pascal } from 'case';
+import * as w from 'wasm-ast-types';
+import { findAndParseTypes, findQueryMsg } from '../utils';
+import {
+  ContractInfo,
+  RenderContext,
+  RenderContextBase,
+  UtilMapping,
+  RenderOptions
+} from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+
+export class RecoilPlugin extends BuilderPluginBase<RenderOptions> {
+  utils: UtilMapping = {
+    selectorFamily: 'recoil',
+  };
+  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.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/src/plugins/types.ts

@@ -0,0 +1,74 @@
+import * as t from '@babel/types';
+import { clean } from '../utils/clean';
+import { pascal } from 'case';
+import { findExecuteMsg, findAndParseTypes, findQueryMsg } from '../utils';
+import {
+  ContractInfo,
+  RenderContext,
+  RenderContextBase,
+  RenderOptions
+} from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+
+export class TypesPlugin 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.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: t.Node) => {
+      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/types/src/builder/builder.d.ts

@@ -1,19 +1,24 @@
 import { RenderOptions } from "wasm-ast-types";
+import { IBuilderPlugin } from '../plugins';
 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 declare type TSBuilderOptions = {
+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;
@@ -26,14 +31,13 @@ export declare class TSBuilder {
     contracts: Array<ContractFile | string>;
     outPath: string;
     options?: TSBuilderOptions;
+    plugins: IBuilderPlugin[];
     protected files: BuilderFile[];
-    constructor({ contracts, outPath, options }: TSBuilderInput);
-    getContracts(): ContractFile[];
-    renderTypes(contract: ContractFile): Promise<void>;
-    renderClient(contract: ContractFile): Promise<void>;
-    renderRecoil(contract: ContractFile): Promise<void>;
-    renderReactQuery(contract: ContractFile): Promise<void>;
-    renderMessageComposer(contract: ContractFile): Promise<void>;
+    loadDefaultPlugins(): void;
+    constructor({ contracts, outPath, options, plugins }: TSBuilderInput);
     build(): Promise<void>;
+    private process;
+    private render;
+    private after;
     bundle(): Promise<void>;
 }

package/types/src/generators/msg-builder.d.ts

@@ -0,0 +1,5 @@
+import { ContractInfo } from "wasm-ast-types";
+import { MsgBuilderOptions } from 'wasm-ast-types';
+import { BuilderFile } from "../builder";
+declare const _default: (name: string, contractInfo: ContractInfo, outPath: string, msgBuilderOptions?: MsgBuilderOptions) => Promise<BuilderFile[]>;
+export default _default;

package/types/src/generators/msg-builder.ts

@@ -0,0 +1,5 @@
+import { ContractInfo } from "wasm-ast-types";
+import { MsgBuilderOptions } from "wasm-ast-types";
+import { BuilderFile } from "../builder";
+declare const _default: (name: string, contractInfo: ContractInfo, outPath: string, msgBuilderOptions?: MsgBuilderOptions) => Promise<BuilderFile[]>;
+export default _default;

package/types/src/index.d.ts

@@ -7,5 +7,6 @@ export { default as generateRecoil } from './generators/recoil';
 export * from './utils';
 export * from './builder';
 export * from './bundler';
+export * from './plugins';
 declare const _default: (input: TSBuilderInput) => Promise<void>;
 export default _default;

package/types/src/plugins/client.d.ts

@@ -0,0 +1,12 @@
+import { RenderContext, ContractInfo, RenderContextBase, RenderOptions } from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+export declare class ClientPlugin extends BuilderPluginBase<RenderOptions> {
+    initContext(contract: ContractInfo, options?: RenderOptions): RenderContextBase<RenderOptions>;
+    doRender(name: string, context: RenderContext): Promise<{
+        type: BuilderFileType;
+        pluginType?: string;
+        localname: string;
+        body: any[];
+    }[]>;
+}

package/types/src/plugins/index.d.ts

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

package/types/src/plugins/message-composer.d.ts

@@ -0,0 +1,12 @@
+import { ContractInfo, RenderContextBase, RenderContext, RenderOptions } from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+export declare class MessageComposerPlugin extends BuilderPluginBase<RenderOptions> {
+    initContext(contract: ContractInfo, options?: RenderOptions): RenderContextBase<RenderOptions>;
+    doRender(name: string, context: RenderContext): Promise<{
+        type: BuilderFileType;
+        pluginType?: string;
+        localname: string;
+        body: any[];
+    }[]>;
+}

package/types/src/plugins/msg-builder.d.ts

@@ -0,0 +1,12 @@
+import { RenderContext, RenderContextBase, ContractInfo, RenderOptions } from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+export declare class MsgBuilderPlugin extends BuilderPluginBase<RenderOptions> {
+    initContext(contract: ContractInfo, options?: RenderOptions): RenderContextBase<RenderOptions>;
+    doRender(name: string, context: RenderContext): Promise<{
+        type: BuilderFileType;
+        pluginType?: string;
+        localname: string;
+        body: any[];
+    }[]>;
+}

package/types/src/plugins/plugin-base.d.ts

@@ -0,0 +1,47 @@
+import { ContractInfo, UtilMapping, IContext } from 'wasm-ast-types';
+import { BuilderFile, BuilderFileType } from '../builder';
+/**
+ * IBuilderPlugin is a common plugin that render generated code.
+ */
+export interface IBuilderPlugin {
+    /**
+     * a mapping of utils will be used in generated code.
+     */
+    utils: UtilMapping;
+    /**
+     * render generated cdoe.
+     * @param name the name of contract
+     * @param contractInfo contract
+     * @param outPath the path of generated code.
+     * @returns info of generated files.
+     */
+    render(name: string, contractInfo: ContractInfo, outPath: string): Promise<BuilderFile[]>;
+}
+/**
+ * BuilderPluginBase enable ts-codegen users implement their own plugins by only implement a few functions.
+ */
+export declare abstract class BuilderPluginBase<TOpt extends {
+    enabled?: boolean;
+}> implements IBuilderPlugin {
+    option: TOpt;
+    utils: UtilMapping;
+    constructor(opt: TOpt);
+    render(name: string, contractInfo: ContractInfo, outPath: string): Promise<BuilderFile[]>;
+    /**
+     * init context here
+     * @param contract
+     * @param options
+     */
+    abstract initContext(contract: ContractInfo, options?: TOpt): IContext;
+    /**
+     * render generated code here.
+     * @param name
+     * @param context
+     */
+    abstract doRender(name: string, context: IContext): Promise<{
+        type: BuilderFileType;
+        pluginType?: string;
+        localname: string;
+        body: any[];
+    }[]>;
+}

package/types/src/plugins/react-query.d.ts

@@ -0,0 +1,12 @@
+import { ContractInfo, RenderOptions, RenderContextBase, RenderContext } from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+export declare class ReactQueryPlugin extends BuilderPluginBase<RenderOptions> {
+    initContext(contract: ContractInfo, options?: RenderOptions): RenderContextBase<RenderOptions>;
+    doRender(name: string, context: RenderContext): Promise<{
+        type: BuilderFileType;
+        pluginType?: string;
+        localname: string;
+        body: any[];
+    }[]>;
+}

package/types/src/plugins/recoil.d.ts

@@ -0,0 +1,13 @@
+import { ContractInfo, RenderContext, RenderContextBase, UtilMapping, RenderOptions } from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+export declare class RecoilPlugin extends BuilderPluginBase<RenderOptions> {
+    utils: UtilMapping;
+    initContext(contract: ContractInfo, options?: RenderOptions): RenderContextBase<RenderOptions>;
+    doRender(name: string, context: RenderContext): Promise<{
+        type: BuilderFileType;
+        pluginType?: string;
+        localname: string;
+        body: any[];
+    }[]>;
+}

package/types/src/plugins/types.d.ts

@@ -0,0 +1,12 @@
+import { ContractInfo, RenderContext, RenderContextBase, RenderOptions } from 'wasm-ast-types';
+import { BuilderFileType } from '../builder';
+import { BuilderPluginBase } from './plugin-base';
+export declare class TypesPlugin extends BuilderPluginBase<RenderOptions> {
+    initContext(contract: ContractInfo, options?: RenderOptions): RenderContextBase<RenderOptions>;
+    doRender(name: string, context: RenderContext): Promise<{
+        type: BuilderFileType;
+        pluginType?: string;
+        localname: string;
+        body: any[];
+    }[]>;
+}