@cosmwasm/ts-codegen 0.35.7 → 1.1.0

package/{src/index.ts → esm/index.js}

@@ -1,17 +1,15 @@
-import { TSBuilder, TSBuilderInput } from './builder';
-
+import { TSBuilder } from './builder';
 export { default as generateTypes } from './generators/types';
 export { default as generateClient } from './generators/client';
 export { default as generateMessageComposer } from './generators/message-composer';
+export { default as generateMessageBuilder } from './generators/message-builder';
 export { default as generateReactQuery } from './generators/react-query';
 export { default as generateRecoil } from './generators/recoil';
-
 export * from './utils';
 export * from './builder';
 export * from './bundler';
 export * from './plugins';
-
-export default async (input: TSBuilderInput) => {
+export default async (input) => {
     const builder = new TSBuilder(input);
     await builder.build();
-};
+};

package/esm/plugins/client.js

@@ -0,0 +1,59 @@
+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/esm/plugins/message-builder.js

@@ -0,0 +1,52 @@
+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/esm/plugins/message-composer.js

@@ -0,0 +1,46 @@
+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/esm/plugins/plugin-base.js

@@ -0,0 +1,47 @@
+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 {
+    builder;
+    option;
+    utils;
+    constructor(opt, builder) {
+        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);
+            // @ts-ignore
+            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,
+            };
+        });
+    }
+}

package/esm/plugins/provider-bundle.js

@@ -0,0 +1,58 @@
+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/esm/plugins/provider.js

@@ -0,0 +1,73 @@
+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/esm/plugins/react-query.js

@@ -0,0 +1,69 @@
+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/esm/plugins/recoil.js

@@ -0,0 +1,51 @@
+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 {
+    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));
+            const selectors = w.createRecoilSelectors(context, name, QueryClient, QueryMsg);
+            body.push(...selectors);
+        }
+        if (typeHash.hasOwnProperty('Coin')) {
+            // @ts-ignore
+            delete context.utils.Coin;
+        }
+        return [
+            {
+                type: 'recoil',
+                localname,
+                body
+            }
+        ];
+    }
+}

package/esm/plugins/types.js

@@ -0,0 +1,38 @@
+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/{src → esm}/ts-codegen.js

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

package/{src/utils/clean.ts → esm/utils/clean.js}

@@ -1,15 +1,14 @@
 export const clean = (obj) => {
     var copy;
     // Handle the 3 simple types, and null or undefined
-    if (null == obj || 'object' != typeof obj) return obj;
-
+    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 = [];
@@ -18,7 +17,6 @@ export const clean = (obj) => {
         }
         return copy;
     }
-
     // Handle Object
     if (obj instanceof Object || typeof obj === 'object') {
         copy = {};
@@ -32,14 +30,16 @@ export const clean = (obj) => {
                     case 'end':
                         break;
                     default:
+                        // @ts-ignore
                         copy[attr] = clean(obj[attr]);
                 }
-            } else {
+            }
+            else {
+                // @ts-ignore
                 copy[attr] = clean(obj[attr]);
             }
         }
         return copy;
     }
-
     throw new Error("Unable to copy obj! Its type isn't supported.");
-};
+};

package/{src/utils/cleanse.ts → esm/utils/cleanse.js}

@@ -1,5 +1,4 @@
 import { pascal } from "case";
-
 const cleanFor = (str) => {
     /*
         1. look at first char after _for_
@@ -9,30 +8,25 @@ const cleanFor = (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;
-
+    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 = [];
@@ -41,11 +35,9 @@ export const cleanse = (obj) => {
         }
         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;
@@ -53,37 +45,41 @@ export const cleanse = (obj) => {
                 obj.type = 'string';
             }
         }
-
         for (var attr in obj) {
             if (obj.hasOwnProperty(attr)) {
-
                 if (/_for_/.test(attr)) {
+                    // @ts-ignore
                     copy[cleanFor(attr)] = cleanse(obj[attr]);
-                } else if (/^Nullable_/.test(attr)) {
+                }
+                else if (/^Nullable_/.test(attr)) {
+                    // @ts-ignore
                     copy[cleanNullable(attr)] = cleanse(obj[attr]);
-                } else {
+                }
+                else {
                     switch (attr) {
                         case 'title':
                         case '$ref':
                             if (typeof obj[attr] === 'string') {
-                                copy[attr] = cleanse(
-                                    cleanNullable(cleanFor(obj[attr]))
-                                );
-                            } else {
+                                // @ts-ignore
+                                copy[attr] = cleanse(cleanNullable(cleanFor(obj[attr])));
+                            }
+                            else {
+                                // @ts-ignore
                                 copy[attr] = cleanse(obj[attr]);
                             }
                             break;
                         default:
+                            // @ts-ignore
                             copy[attr] = cleanse(obj[attr]);
                     }
                 }
-
-            } else {
+            }
+            else {
+                // @ts-ignore
                 copy[attr] = cleanse(obj[attr]);
             }
         }
         return copy;
     }
-
     throw new Error("Unable to copy obj! Its type isn't supported.");
-};
+};