@cosmwasm/ts-codegen 0.30.1 → 0.31.1

package/src/plugins/provider.ts

@@ -0,0 +1,114 @@
+import { pascal } from "case";
+import * as w from "wasm-ast-types";
+import { ContractInfo, RenderContextBase, RenderContext } from "wasm-ast-types";
+import { BuilderFileType, TSBuilderOptions } from "../builder";
+import { BuilderPluginBase } from "./plugin-base";
+
+export const GetLocalNameByContractName = (name) =>
+  `${pascal(name)}.provider.ts`;
+
+export const GetLocalBaseNameByContractName = (name) =>
+  `${pascal(name)}.provider`;
+
+export class ContractsContextProviderPlugin extends BuilderPluginBase<TSBuilderOptions> {
+  constructor(opt: TSBuilderOptions) {
+    super(opt);
+
+    this.utils = {
+      ContractBase: "__contractContextBase__",
+      IContractConstructor: "__contractContextBase__",
+      IEmptyClient: "__contractContextBase__",
+    };
+  }
+
+  initContext(
+    contract: ContractInfo,
+    options?: TSBuilderOptions
+  ): RenderContextBase<TSBuilderOptions> {
+    return new RenderContext(contract, options, this.builder.builderContext);
+  }
+
+  async doRender(
+    name: string,
+    context: RenderContext
+  ): Promise<
+    {
+      type: BuilderFileType;
+      pluginType?: string;
+      localname: string;
+      body: any[];
+    }[]
+  > {
+    if (!this.option?.useContracts?.enabled) {
+      return;
+    }
+
+    const providerInfo = context.getProviderInfos()[name];
+
+    if (!Object.keys(providerInfo)?.length) {
+      return;
+    }
+
+    context.addUtil("ContractBase");
+    context.addUtil("IContractConstructor");
+
+    const localname = GetLocalNameByContractName(name);
+    let needEmptyClientType = false;
+    let clientFile = null;
+    let clientClasses = [];
+
+    const body = [];
+
+    const signClientProviderInfo =
+      providerInfo[w.PROVIDER_TYPES.SIGNING_CLIENT_TYPE];
+
+    if (signClientProviderInfo) {
+      clientFile = `./${signClientProviderInfo.basename}`;
+      clientClasses.push(signClientProviderInfo.classname);
+    } else {
+      needEmptyClientType = true;
+    }
+
+    const queryClientProviderInfo =
+      providerInfo[w.PROVIDER_TYPES.QUERY_CLIENT_TYPE];
+
+    if (queryClientProviderInfo) {
+      clientFile = `./${queryClientProviderInfo.basename}`;
+      clientClasses.push(queryClientProviderInfo.classname);
+    } else {
+      needEmptyClientType = true;
+    }
+
+    if (clientFile) {
+      body.push(w.importStmt(clientClasses, clientFile));
+    }
+
+    const messageComposerProviderInfo =
+      providerInfo[w.PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE];
+
+    if (messageComposerProviderInfo) {
+      body.push(
+        w.importStmt(
+          [messageComposerProviderInfo.classname],
+          `./${messageComposerProviderInfo.basename}`
+        )
+      );
+    } else {
+      needEmptyClientType = true;
+    }
+
+    if (needEmptyClientType) {
+      context.addUtil("IEmptyClient");
+    }
+
+    body.push(w.createProvider(name, providerInfo));
+
+    return [
+      {
+        type: "plugin",
+        localname,
+        body,
+      },
+    ];
+  }
+}

package/src/plugins/react-query.ts

@@ -16,7 +16,7 @@ export class ReactQueryPlugin extends BuilderPluginBase<RenderOptions> {
     contract: ContractInfo,
     options?: RenderOptions
   ): RenderContextBase<RenderOptions> {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(

package/src/plugins/recoil.ts

@@ -19,7 +19,7 @@ export class RecoilPlugin extends BuilderPluginBase<RenderOptions> {
     contract: ContractInfo,
     options?: RenderOptions
   ): RenderContextBase<RenderOptions> {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(

package/src/plugins/types.ts

@@ -16,7 +16,7 @@ export class TypesPlugin extends BuilderPluginBase<RenderOptions> {
     contract: ContractInfo,
     options?: RenderOptions
   ): RenderContextBase<RenderOptions> {
-    return new RenderContext(contract, options);
+    return new RenderContext(contract, options, this.builder.builderContext);
   }
 
   async doRender(

package/src/utils/files.ts

@@ -0,0 +1,73 @@
+import * as t from "@babel/types";
+import { parse, ParserPlugin } from "@babel/parser";
+import { sync as mkdirp } from "mkdirp";
+import { writeFileSync } from "fs";
+import { dirname } from "path";
+import generate from "@babel/generator";
+import { unused } from "./unused";
+import traverse from "@babel/traverse";
+
+export const writeAstToFile = (
+  outPath: string,
+  program: t.Statement[],
+  filename: string,
+  removeUnusedImports = false,
+  isTsDisable = false,
+  isEslintDisable = false
+) => {
+  const ast = t.program(program);
+  const content = generate(ast).code;
+
+  if (removeUnusedImports) {
+    const plugins: ParserPlugin[] = ["typescript"];
+    const newAst = parse(content, {
+      sourceType: "module",
+      plugins,
+    });
+    traverse(newAst, unused);
+    const content2 = generate(newAst).code;
+    writeContentToFile(
+      outPath,
+      content2,
+      filename,
+      isTsDisable,
+      isEslintDisable
+    );
+  } else {
+    writeContentToFile(
+      outPath,
+      content,
+      filename,
+      isTsDisable,
+      isEslintDisable
+    );
+  }
+};
+
+export const writeContentToFile = (
+  outPath: string,
+  content: string,
+  filename: string,
+  isTsDisable = false,
+  isEslintDisable = false
+) => {
+  let esLintPrefix = "";
+  let tsLintPrefix = "";
+
+  let nameWithoutPath = filename.replace(outPath, "");
+  // strip off leading slash
+  if (nameWithoutPath.startsWith("/"))
+    nameWithoutPath = nameWithoutPath.replace(/^\//, "");
+
+  if (isTsDisable) {
+    tsLintPrefix = `//@ts-nocheck\n`;
+  }
+
+  if (isEslintDisable) {
+    esLintPrefix = `/* eslint-disable */\n`;
+  }
+
+  const text = tsLintPrefix + esLintPrefix + content;
+  mkdirp(dirname(filename));
+  writeFileSync(filename, text);
+};

package/src/utils/unused.ts

@@ -0,0 +1,52 @@
+//@ts-nocheck
+
+import * as t from '@babel/types';
+
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import
+// https://github.com/chuyik/babel-plugin-danger-remove-unused-import/blob/c5454c21e94698a2464a12baa5590761932a71a8/License#L1
+
+export const unused = {
+  Program: {
+    exit: (path) => {
+      const UnRefBindings = new Map()
+      for (const [name, binding] of Object.entries(path.scope.bindings)) {
+        if (!binding.path.parentPath || binding.kind !== 'module') continue
+
+        const source = binding.path.parentPath.get('source')
+        const importName = source.node.value
+        if (
+          !t.isStringLiteral(source)
+        )
+          continue
+
+        const key = `${importName}(${source.node.loc &&
+          source.node.loc.start.line})`
+
+        if (!UnRefBindings.has(key)) {
+          UnRefBindings.set(key, binding)
+        }
+
+        if (binding.referenced) {
+          UnRefBindings.set(key, null)
+        } else {
+          const nodeType = binding.path.node.type
+          if (nodeType === 'ImportSpecifier') {
+            binding.path.remove()
+          } else if (nodeType === 'ImportDefaultSpecifier') {
+            binding.path.remove()
+          } else if (nodeType === 'ImportNamespaceSpecifier') {
+            binding.path.remove()
+          } else if (binding.path.parentPath) {
+            binding.path.parentPath.remove()
+          }
+        }
+      }
+
+      UnRefBindings.forEach((binding, key) => {
+        if (binding && binding.path.parentPath) {
+          binding.path.parentPath.remove()
+        }
+      })
+    }
+  }
+};

package/types/src/builder/builder.d.ts

@@ -1,4 +1,4 @@
-import { RenderOptions } from "wasm-ast-types";
+import { RenderOptions, BuilderContext } from "wasm-ast-types";
 import { IBuilderPlugin } from '../plugins';
 export interface TSBuilderInput {
     contracts: Array<ContractFile | string>;
@@ -12,8 +12,13 @@ export interface BundleOptions {
     bundleFile?: string;
     bundlePath?: string;
 }
+export interface UseContractsOptions {
+    enabled?: boolean;
+    filename?: string;
+}
 export type TSBuilderOptions = {
     bundle?: BundleOptions;
+    useContracts?: UseContractsOptions;
 } & RenderOptions;
 export type BuilderFileType = 'type' | 'client' | 'recoil' | 'react-query' | 'message-composer' | 'msg-builder' | 'plugin';
 export interface BuilderFile {
@@ -32,6 +37,7 @@ export declare class TSBuilder {
     outPath: string;
     options?: TSBuilderOptions;
     plugins: IBuilderPlugin[];
+    builderContext: BuilderContext;
     protected files: BuilderFile[];
     loadDefaultPlugins(): void;
     constructor({ contracts, outPath, options, plugins }: TSBuilderInput);

package/types/src/generators/create-helpers.d.ts

@@ -0,0 +1,3 @@
+import { TSBuilderInput } from "../builder";
+import { BuilderContext } from "wasm-ast-types";
+export declare const createHelpers: (input: TSBuilderInput, builderContext: BuilderContext) => void;

package/types/src/helpers/contractContextBase.d.ts

@@ -0,0 +1 @@
+export declare const contractContextBase = "\nimport {\n  CosmWasmClient,\n  SigningCosmWasmClient,\n} from '@cosmjs/cosmwasm-stargate';\n\nexport interface IContractConstructor {\n  address: string | undefined;\n  cosmWasmClient: CosmWasmClient | undefined;\n  signingCosmWasmClient: SigningCosmWasmClient | undefined;\n}\n\nexport const NO_SINGING_ERROR_MESSAGE = 'signingCosmWasmClient not connected';\n\nexport const NO_COSMWASW_CLIENT_ERROR_MESSAGE = 'cosmWasmClient not connected';\n\nexport const NO_ADDRESS_ERROR_MESSAGE = \"address doesn't exist\";\n\nexport const NO_SIGNING_CLIENT_ERROR_MESSAGE =\n  'Signing client is not generated. Please check ts-codegen config';\n\nexport const NO_QUERY_CLIENT_ERROR_MESSAGE =\n  'Query client is not generated. Please check ts-codegen config';\n\nexport const NO_MESSAGE_COMPOSER_ERROR_MESSAGE =\n  'Message composer client is not generated. Please check ts-codegen config';\n\n/**\n * a placeholder for non-generated classes\n */\nexport interface IEmptyClient {}\n\nexport interface ISigningClientProvider<T> {\n  getSigningClient(contractAddr: string): T;\n}\n\nexport interface IQueryClientProvider<T> {\n  getQueryClient(contractAddr: string): T;\n}\n\nexport interface IMessageComposerProvider<T> {\n  getMessageComposer(contractAddr: string): T;\n}\n\nexport class ContractBase<\n  TSign = IEmptyClient,\n  TQuery = IEmptyClient,\n  TMsgComposer = IEmptyClient\n> {\n  constructor(\n    protected address: string | undefined,\n    protected cosmWasmClient: CosmWasmClient | undefined,\n    protected signingCosmWasmClient: SigningCosmWasmClient | undefined,\n    private TSign?: new (\n      client: SigningCosmWasmClient,\n      sender: string,\n      contractAddress: string\n    ) => TSign,\n    private TQuery?: new (\n      client: CosmWasmClient,\n      contractAddress: string\n    ) => TQuery,\n    private TMsgComposer?: new (\n      sender: string,\n      contractAddress: string\n    ) => TMsgComposer\n  ) {}\n\n  public getSigningClient(contractAddr: string): TSign {\n    if (!this.signingCosmWasmClient) throw new Error(NO_SINGING_ERROR_MESSAGE);\n    if (!this.address) throw new Error(NO_ADDRESS_ERROR_MESSAGE);\n    if (!this.TSign) throw new Error(NO_SIGNING_CLIENT_ERROR_MESSAGE);\n    return new this.TSign(\n      this.signingCosmWasmClient,\n      this.address,\n      contractAddr\n    );\n  }\n\n  public getQueryClient(contractAddr: string): TQuery {\n    if (!this.cosmWasmClient) throw new Error(NO_COSMWASW_CLIENT_ERROR_MESSAGE);\n    if (!this.TQuery) throw new Error(NO_QUERY_CLIENT_ERROR_MESSAGE);\n    return new this.TQuery(this.cosmWasmClient, contractAddr);\n  }\n\n  public getMessageComposer(contractAddr: string): TMsgComposer {\n    if (!this.address) throw new Error(NO_ADDRESS_ERROR_MESSAGE);\n    if (!this.TMsgComposer) throw new Error(NO_MESSAGE_COMPOSER_ERROR_MESSAGE);\n    return new this.TMsgComposer(this.address, contractAddr);\n  }\n}\n";

package/types/src/helpers/contractsContextTSX.d.ts

@@ -0,0 +1 @@
+export declare const contractsContextTSX = "\nimport React, { useEffect, useMemo, useRef, useState, useContext } from 'react';\nimport {\n  CosmWasmClient,\n  SigningCosmWasmClient,\n} from '@cosmjs/cosmwasm-stargate';\n\nimport { IContractsContext, getProviders } from './contractContextProviders';\n\ninterface ContractsConfig {\n  address: string | undefined;\n  getCosmWasmClient: () => Promise<CosmWasmClient>;\n  getSigningCosmWasmClient: () => Promise<SigningCosmWasmClient>;\n}\n\nconst ContractsContext = React.createContext<IContractsContext | null>(null);\n\nexport const ContractsProvider = ({\n  children,\n  contractsConfig,\n}: {\n  children: React.ReactNode;\n  contractsConfig: ContractsConfig;\n}) => {\n  const [cosmWasmClient, setCosmWasmClient] = useState<CosmWasmClient>();\n  const [signingCosmWasmClient, setSigningCosmWasmClient] =\n    useState<SigningCosmWasmClient>();\n\n  const { address, getCosmWasmClient, getSigningCosmWasmClient } =\n    contractsConfig;\n\n  const prevAddressRef = useRef<string | undefined>(address);\n\n  const contracts: IContractsContext = useMemo(() => {\n    return getProviders(address, cosmWasmClient, signingCosmWasmClient);\n  }, [address, cosmWasmClient, signingCosmWasmClient]);\n\n  useEffect(() => {\n    const connectSigningCwClient = async () => {\n      if (address && prevAddressRef.current !== address) {\n        const signingCosmWasmClient = await getSigningCosmWasmClient();\n        setSigningCosmWasmClient(signingCosmWasmClient);\n      } else if (!address) {\n        setSigningCosmWasmClient(undefined);\n      }\n      prevAddressRef.current = address;\n    };\n    connectSigningCwClient();\n  }, [address, getSigningCosmWasmClient]);\n\n  useEffect(() => {\n    const connectCosmWasmClient = async () => {\n      const cosmWasmClient = await getCosmWasmClient();\n      setCosmWasmClient(cosmWasmClient);\n    };\n    connectCosmWasmClient();\n  }, [getCosmWasmClient]);\n\n  return (\n    <ContractsContext.Provider value={contracts}>\n      {children}\n    </ContractsContext.Provider>\n  );\n};\n\nexport const useContracts = () => {\n  const contracts = useContext(ContractsContext);\n  if (contracts === null) {\n    throw new Error('useContracts must be used within a ContractsProvider');\n  }\n  return contracts;\n};\n";

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

@@ -0,0 +1,2 @@
+export * from './contractContextBase';
+export * from './contractsContextTSX';

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

@@ -1,6 +1,7 @@
-import { RenderContext, ContractInfo, RenderContextBase, RenderOptions } from 'wasm-ast-types';
-import { BuilderFileType } from '../builder';
-import { BuilderPluginBase } from './plugin-base';
+import { RenderContext, ContractInfo, RenderContextBase, RenderOptions } from "wasm-ast-types";
+import { BuilderFileType } from "../builder";
+import { BuilderPluginBase } from "./plugin-base";
+export declare const TYPE = "client";
 export declare class ClientPlugin extends BuilderPluginBase<RenderOptions> {
     initContext(contract: ContractInfo, options?: RenderOptions): RenderContextBase<RenderOptions>;
     doRender(name: string, context: RenderContext): Promise<{

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

@@ -1,6 +1,7 @@
-import { ContractInfo, RenderContextBase, RenderContext, RenderOptions } from 'wasm-ast-types';
-import { BuilderFileType } from '../builder';
-import { BuilderPluginBase } from './plugin-base';
+import { ContractInfo, RenderContextBase, RenderContext, RenderOptions } from "wasm-ast-types";
+import { BuilderFileType } from "../builder";
+import { BuilderPluginBase } from "./plugin-base";
+export declare const TYPE = "message-composer";
 export declare class MessageComposerPlugin extends BuilderPluginBase<RenderOptions> {
     initContext(contract: ContractInfo, options?: RenderOptions): RenderContextBase<RenderOptions>;
     doRender(name: string, context: RenderContext): Promise<{

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

@@ -1,5 +1,5 @@
-import { ContractInfo, UtilMapping, IContext } from 'wasm-ast-types';
-import { BuilderFile, BuilderFileType } from '../builder';
+import { ContractInfo, UtilMapping, IContext } from "wasm-ast-types";
+import { BuilderFile, BuilderFileType, TSBuilder } from "../builder";
 /**
  * IBuilderPlugin is a common plugin that render generated code.
  */
@@ -8,6 +8,8 @@ export interface IBuilderPlugin {
      * a mapping of utils will be used in generated code.
      */
     utils: UtilMapping;
+    builder?: TSBuilder;
+    setBuilder(builder: TSBuilder): any;
     /**
      * render generated cdoe.
      * @param name the name of contract
@@ -23,9 +25,11 @@ export interface IBuilderPlugin {
 export declare abstract class BuilderPluginBase<TOpt extends {
     enabled?: boolean;
 }> implements IBuilderPlugin {
+    builder?: TSBuilder;
     option: TOpt;
     utils: UtilMapping;
-    constructor(opt: TOpt);
+    constructor(opt: TOpt, builder?: TSBuilder);
+    setBuilder(builder: TSBuilder): void;
     render(name: string, contractInfo: ContractInfo, outPath: string): Promise<BuilderFile[]>;
     /**
      * init context here

package/types/src/plugins/provider-bundle.d.ts

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

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

@@ -0,0 +1,15 @@
+import { ContractInfo, RenderContextBase, RenderContext } from "wasm-ast-types";
+import { BuilderFileType, TSBuilderOptions } from "../builder";
+import { BuilderPluginBase } from "./plugin-base";
+export declare const GetLocalNameByContractName: (name: any) => string;
+export declare const GetLocalBaseNameByContractName: (name: any) => string;
+export declare class ContractsContextProviderPlugin extends BuilderPluginBase<TSBuilderOptions> {
+    constructor(opt: TSBuilderOptions);
+    initContext(contract: ContractInfo, options?: TSBuilderOptions): RenderContextBase<TSBuilderOptions>;
+    doRender(name: string, context: RenderContext): Promise<{
+        type: BuilderFileType;
+        pluginType?: string;
+        localname: string;
+        body: any[];
+    }[]>;
+}

package/types/src/plugins/use-contracts.d.ts

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

package/types/src/utils/files.d.ts

@@ -0,0 +1,3 @@
+import * as t from "@babel/types";
+export declare const writeAstToFile: (outPath: string, program: t.Statement[], filename: string, removeUnusedImports?: boolean, isTsDisable?: boolean, isEslintDisable?: boolean) => void;
+export declare const writeContentToFile: (outPath: string, content: string, filename: string, isTsDisable?: boolean, isEslintDisable?: boolean) => void;

package/types/src/utils/unused.d.ts

@@ -0,0 +1,5 @@
+export declare const unused: {
+    Program: {
+        exit: (path: any) => void;
+    };
+};