@cosmwasm/ts-codegen 0.35.7 → 1.1.0

package/src/plugins/plugin-base.ts

@@ -1,122 +0,0 @@
-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,
-  TSBuilder,
-  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;
-
-  builder?: TSBuilder;
-
-  setBuilder(builder: TSBuilder);
-
-  /**
-   * 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
-{
-  builder?: TSBuilder;
-  option: TOpt;
-  utils: UtilMapping;
-
-  constructor(opt: TOpt, builder?: TSBuilder) {
-    this.option = opt;
-    this.builder = builder;
-  }
-
-  setBuilder(builder: TSBuilder) {
-    this.builder = builder;
-  }
-
-  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, result.localname);
-      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/provider-bundle.ts

@@ -1,98 +0,0 @@
-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";
-import { GetLocalBaseNameByContractName } from "./provider";
-
-export class ContractsProviderBundlePlugin extends BuilderPluginBase<TSBuilderOptions> {
-  constructor(opt: TSBuilderOptions) {
-    super(opt);
-
-    this.utils = {
-      CosmWasmClient: "@cosmjs/cosmwasm-stargate",
-      SigningCosmWasmClient: "@cosmjs/cosmwasm-stargate",
-      IQueryClientProvider: "__contractContextBase__",
-      ISigningClientProvider: "__contractContextBase__",
-      IMessageComposerProvider: "__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?.useContractsHooks?.enabled) {
-      return;
-    }
-
-    const providerInfos = context.getProviderInfos();
-
-    if (!Object.keys(providerInfos || {})?.length) {
-      return;
-    }
-
-    const localname = "contractContextProviders.ts";
-
-    const body = [];
-
-    context.addUtil("CosmWasmClient");
-    context.addUtil("SigningCosmWasmClient");
-
-    context.addUtil("IQueryClientProvider");
-    context.addUtil("ISigningClientProvider");
-    context.addUtil("IMessageComposerProvider");
-
-    for (const name in providerInfos) {
-      if (Object.prototype.hasOwnProperty.call(providerInfos, name)) {
-        const providerInfo = providerInfos[name];
-
-        for (const key in providerInfo) {
-          if (Object.prototype.hasOwnProperty.call(providerInfo, key)) {
-            const info = providerInfo[key];
-
-            body.push(
-              w.importStmt(
-                [info.classname],
-                `./${info.basename}`
-              )
-            );
-          }
-        }
-
-        body.push(
-          w.importStmt(
-            [pascal(name)],
-            `./${GetLocalBaseNameByContractName(name)}`
-          )
-        );
-      }
-    }
-
-    body.push(w.createIContractsContext(providerInfos));
-    body.push(w.createGettingProviders(providerInfos));
-
-    return [
-      {
-        type: "plugin",
-        pluginType: "contractContextProviders",
-        localname,
-        body,
-      },
-    ];
-  }
-}

package/src/plugins/provider.ts

@@ -1,115 +0,0 @@
-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?.useContractsHooks?.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",
-        pluginType: "provider",
-        localname,
-        body,
-      },
-    ];
-  }
-}

package/src/plugins/react-query.ts

@@ -1,115 +0,0 @@
-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, this.builder.builderContext);
-  }
-
-  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

@@ -1,89 +0,0 @@
-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, this.builder.builderContext);
-  }
-
-  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

@@ -1,74 +0,0 @@
-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, this.builder.builderContext);
-  }
-
-  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/src/utils/files.ts

@@ -1,73 +0,0 @@
-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/index.ts

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