@cosmwasm/ts-codegen 0.35.7 → 1.0.0

package/module/plugins/client.js

@@ -1,63 +0,0 @@
-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 const TYPE = "client";
-export class ClientPlugin extends BuilderPluginBase {
-  initContext(contract, options) {
-    return new RenderContext(contract, options, this.builder.builderContext);
-  }
-  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));
-      context.addProviderInfo(name, w.PROVIDER_TYPES.QUERY_CLIENT_TYPE, QueryClient, localname);
-    }
-
-    // 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));
-        context.addProviderInfo(name, w.PROVIDER_TYPES.SIGNING_CLIENT_TYPE, Client, localname);
-      }
-    }
-    if (typeHash.hasOwnProperty("Coin")) {
-      // @ts-ignore
-      delete context.utils.Coin;
-    }
-    return [{
-      type: TYPE,
-      localname,
-      body
-    }];
-  }
-}

package/module/plugins/index.js

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

package/module/plugins/message-builder.js

@@ -1,55 +0,0 @@
-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 MessageBuilderPlugin extends BuilderPluginBase {
-  initContext(contract, options) {
-    return new RenderContext(contract, options, this.builder.builderContext);
-  }
-  async doRender(name, context) {
-    const {
-      enabled
-    } = this.option.messageBuilder;
-    if (!enabled) {
-      return;
-    }
-    const {
-      schemas
-    } = context.contract;
-    const localname = pascal(name) + '.message-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.createMessageBuilderClass(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.createMessageBuilderClass(context, className, QueryMsg));
-      }
-    }
-    if (typeHash.hasOwnProperty('Coin')) {
-      // @ts-ignore
-      delete context.utils.Coin;
-    }
-    return [{
-      type: 'message-builder',
-      localname,
-      body
-    }];
-  }
-}

package/module/plugins/message-composer.js

@@ -1,49 +0,0 @@
-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 const TYPE = "message-composer";
-export class MessageComposerPlugin extends BuilderPluginBase {
-  initContext(contract, options) {
-    return new RenderContext(contract, options, this.builder.builderContext);
-  }
-  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}MsgComposer`);
-        const Interface = pascal(`${name}Msg`);
-        body.push(w.createMessageComposerInterface(context, Interface, ExecuteMsg));
-        body.push(w.createMessageComposerClass(context, TheClass, Interface, ExecuteMsg));
-        context.addProviderInfo(name, w.PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE, TheClass, localname);
-      }
-    }
-    if (typeHash.hasOwnProperty("Coin")) {
-      // @ts-ignore
-      delete context.utils.Coin;
-    }
-    return [{
-      type: TYPE,
-      localname,
-      body
-    }];
-  }
-}

package/module/plugins/plugin-base.js

@@ -1,66 +0,0 @@
-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";
-
-/**
- * IBuilderPlugin is a common plugin that render generated code.
- */
-
-/**
- * BuilderPluginBase enable ts-codegen users implement their own plugins by only implement a few functions.
- */
-export class BuilderPluginBase {
-  constructor(opt, builder) {
-    _defineProperty(this, "builder", void 0);
-    _defineProperty(this, "option", void 0);
-    _defineProperty(this, "utils", void 0);
-    this.option = opt;
-    this.builder = builder;
-  }
-  setBuilder(builder) {
-    this.builder = builder;
-  }
-  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, 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
-   */
-
-  /**
-   * render generated code here.
-   * @param name
-   * @param context
-   */
-}

package/module/plugins/provider-bundle.js

@@ -1,56 +0,0 @@
-import { pascal } from "case";
-import * as w from "wasm-ast-types";
-import { RenderContext } from "wasm-ast-types";
-import { BuilderPluginBase } from "./plugin-base";
-import { GetLocalBaseNameByContractName } from "./provider";
-export class ContractsProviderBundlePlugin extends BuilderPluginBase {
-  constructor(opt) {
-    super(opt);
-    this.utils = {
-      CosmWasmClient: "@cosmjs/cosmwasm-stargate",
-      SigningCosmWasmClient: "@cosmjs/cosmwasm-stargate",
-      IQueryClientProvider: "__contractContextBase__",
-      ISigningClientProvider: "__contractContextBase__",
-      IMessageComposerProvider: "__contractContextBase__"
-    };
-  }
-  initContext(contract, options) {
-    return new RenderContext(contract, options, this.builder.builderContext);
-  }
-  async doRender(name, context) {
-    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/module/plugins/provider.js

@@ -1,68 +0,0 @@
-import { pascal } from "case";
-import * as w from "wasm-ast-types";
-import { RenderContext } from "wasm-ast-types";
-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 {
-  constructor(opt) {
-    super(opt);
-    this.utils = {
-      ContractBase: "__contractContextBase__",
-      IContractConstructor: "__contractContextBase__",
-      IEmptyClient: "__contractContextBase__"
-    };
-  }
-  initContext(contract, options) {
-    return new RenderContext(contract, options, this.builder.builderContext);
-  }
-  async doRender(name, context) {
-    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/module/plugins/react-query.js

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

package/module/plugins/recoil.js

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

@@ -1,42 +0,0 @@
-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, this.builder.builderContext);
-  }
-  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/module/ts-codegen.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-import { cli } from './cli';
-var argv = require('minimist')(process.argv.slice(2));
-(async () => {
-  await cli(argv);
-})();

package/module/utils/clean.js

@@ -1,44 +0,0 @@
-export const clean = obj => {
-  var copy;
-  // Handle the 3 simple types, and null or undefined
-  if (null == obj || 'object' != typeof obj) return obj;
-
-  // Handle Date
-  if (obj instanceof Date) {
-    copy = new Date();
-    copy.setTime(obj.getTime());
-    return copy;
-  }
-
-  // Handle Array
-  if (obj instanceof Array) {
-    copy = [];
-    for (var i = 0, len = obj.length; i < len; i++) {
-      copy[i] = clean(obj[i]);
-    }
-    return copy;
-  }
-
-  // Handle Object
-  if (obj instanceof Object || typeof obj === 'object') {
-    copy = {};
-    for (var attr in obj) {
-      if (obj.hasOwnProperty(attr)) {
-        switch (attr) {
-          case 'leadingComments':
-          case 'trailingComments':
-          case 'loc':
-          case 'start':
-          case 'end':
-            break;
-          default:
-            copy[attr] = clean(obj[attr]);
-        }
-      } else {
-        copy[attr] = clean(obj[attr]);
-      }
-    }
-    return copy;
-  }
-  throw new Error("Unable to copy obj! Its type isn't supported.");
-};

package/module/utils/cleanse.js

@@ -1,78 +0,0 @@
-import { pascal } from "case";
-const cleanFor = str => {
-  /*
-      1. look at first char after _for_
-      2. ONLY if you find capitals after, modify it
-  */
-  while (/_[a-z]+_[A-Z]/.test(str)) {
-    const m = str.match(/(_[a-z]+_)[A-Z]/);
-    str = str.replace(m[1], pascal(m[1]));
-  }
-  return str;
-};
-const cleanNullable = str => {
-  if (/^Nullable_/.test(str)) {
-    str = str.replace(/^Nullable_/, 'Nullable');
-  }
-  return str;
-};
-export const cleanse = obj => {
-  var copy;
-  // Handle the 3 simple types, and null or undefined
-  if (null == obj || 'object' != typeof obj) return obj;
-
-  // Handle Date
-  if (obj instanceof Date) {
-    copy = new Date();
-    copy.setTime(obj.getTime());
-    return copy;
-  }
-
-  // Handle Array
-  if (obj instanceof Array) {
-    copy = [];
-    for (var i = 0, len = obj.length; i < len; i++) {
-      copy[i] = cleanse(obj[i]);
-    }
-    return copy;
-  }
-
-  // Handle Object
-  if (obj instanceof Object || typeof obj === 'object') {
-    copy = {};
-
-    // https://github.com/CosmWasm/cosmwasm-typescript-gen/issues/27
-    if (Array.isArray(obj.enum) && obj.enum.length === 0) {
-      delete obj.enum;
-      if (!obj.type) {
-        obj.type = 'string';
-      }
-    }
-    for (var attr in obj) {
-      if (obj.hasOwnProperty(attr)) {
-        if (/_for_/.test(attr)) {
-          copy[cleanFor(attr)] = cleanse(obj[attr]);
-        } else if (/^Nullable_/.test(attr)) {
-          copy[cleanNullable(attr)] = cleanse(obj[attr]);
-        } else {
-          switch (attr) {
-            case 'title':
-            case '$ref':
-              if (typeof obj[attr] === 'string') {
-                copy[attr] = cleanse(cleanNullable(cleanFor(obj[attr])));
-              } else {
-                copy[attr] = cleanse(obj[attr]);
-              }
-              break;
-            default:
-              copy[attr] = cleanse(obj[attr]);
-          }
-        }
-      } else {
-        copy[attr] = cleanse(obj[attr]);
-      }
-    }
-    return copy;
-  }
-  throw new Error("Unable to copy obj! Its type isn't supported.");
-};