@cosmwasm/ts-codegen 0.35.7 → 1.1.0

package/esm/utils/files.js

@@ -0,0 +1,42 @@
+import * as t from "@babel/types";
+import { parse } 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, program, filename, removeUnusedImports = false, isTsDisable = false, isEslintDisable = false) => {
+    const ast = t.program(program);
+    const content = generate(ast).code;
+    if (removeUnusedImports) {
+        const plugins = ["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, content, filename, 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/parse.ts → esm/utils/parse.js}

@@ -1,32 +1,24 @@
 import babelTraverse from '@babel/traverse';
-import { parse, ParserPlugin } from '@babel/parser';
-
+import { parse } from '@babel/parser';
 export const parser = (codes) => {
-
     const hash = {};
     codes.forEach(code => {
-
-        const plugins: ParserPlugin[] = [
+        const plugins = [
             'typescript',
         ];
-
         const ast = parse(code, {
             sourceType: 'module',
             plugins
         });
-
         const visitor = visitorFn({
             addType(key, node) {
                 hash[key] = node;
             }
-        })
+        });
         babelTraverse(ast, visitor);
     });
-
     return hash;
-
-}
-
+};
 const visitorFn = (parser) => ({
     TSTypeAliasDeclaration(path) {
         parser.addType(path.node.id.name, path.parentPath.node);
@@ -42,4 +34,3 @@ const visitorFn = (parser) => ({
         parser.addType(path.node.id.name, path.parentPath.node);
     }
 });
-

package/esm/utils/prompt.js

@@ -0,0 +1,59 @@
+// @ts-nocheck
+import { filter } from 'fuzzy';
+import { prompt as inquirerer } from 'inquirerer';
+export const getFuzzySearch = (list) => {
+    return (answers, input) => {
+        input = input || '';
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                const fuzzyResult = filter(input, list);
+                resolve(fuzzyResult.map(function (el) {
+                    return el.original;
+                }));
+            }, 25);
+        });
+    };
+};
+export const getFuzzySearchNames = (nameValueItemList) => {
+    const list = nameValueItemList.map(({ name, value }) => name);
+    return (answers, input) => {
+        input = input || '';
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                const fuzzyResult = filter(input, list);
+                resolve(fuzzyResult.map(function (el) {
+                    return nameValueItemList.find(({ name, value }) => el.original == name);
+                }));
+            }, 25);
+        });
+    };
+};
+const transform = (questions) => {
+    return questions.map((q) => {
+        if (q.type === 'fuzzy') {
+            const choices = q.choices;
+            delete q.choices;
+            return {
+                ...q,
+                type: 'autocomplete',
+                source: getFuzzySearch(choices)
+            };
+        }
+        else if (q.type === 'fuzzy:objects') {
+            const choices = q.choices;
+            delete q.choices;
+            return {
+                ...q,
+                type: 'autocomplete',
+                source: getFuzzySearchNames(choices)
+            };
+        }
+        else {
+            return q;
+        }
+    });
+};
+export const prompt = async (questions = [], argv = {}) => {
+    questions = transform(questions);
+    return await inquirerer(questions, argv);
+};

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

@@ -3,22 +3,13 @@ import { readFileSync } from 'fs';
 import { cleanse } from './cleanse';
 import { compile } from '@pyramation/json-schema-to-typescript';
 import { parser } from './parse';
-import { ContractInfo, JSONSchema } from 'wasm-ast-types';
-interface ReadSchemaOpts {
-    schemaDir: string;
-    clean?: boolean;
-};
-
-export const readSchemas = async ({
-    schemaDir, clean = true
-}: ReadSchemaOpts): Promise<ContractInfo> => {
-    const fn = clean ? cleanse : (str) => str;
+;
+export const readSchemas = async ({ schemaDir, clean = true }) => {
+    const fn = clean ? cleanse : (schema) => schema;
     const files = glob(schemaDir + '/**/*.json')
         .filter(file => !file.match(/\/raw\//));
-
     const schemas = files
         .map(file => JSON.parse(readFileSync(file, 'utf-8')));
-
     if (schemas.length > 1) {
         // legacy
         // TODO add console.warn here
@@ -26,64 +17,45 @@ export const readSchemas = async ({
             schemas: fn(schemas)
         };
     }
-
     if (schemas.length === 0) {
         throw new Error('Error [too few files]: requires one schema file per contract');
     }
-
     if (schemas.length !== 1) {
         throw new Error('Error [too many files]: CosmWasm v1.1 schemas supports one file');
     }
-
     const idlObject = schemas[0];
-    const {
-        contract_name,
-        contract_version,
-        idl_version,
-        responses,
-        instantiate,
-        execute,
-        query,
-        migrate,
-        sudo
-    } = idlObject;
-
+    const { contract_name, contract_version, idl_version, responses, instantiate, execute, query, migrate, sudo } = idlObject;
     if (typeof idl_version !== 'string') {
         // legacy
         return {
             schemas: fn(schemas)
         };
     }
-
     // TODO use contract_name, etc.
+    const idl = {
+        instantiate,
+        execute,
+        query,
+        migrate,
+        sudo
+    };
     return {
         schemas: [
-            ...Object.values(fn({
-                instantiate,
-                execute,
-                query,
-                migrate,
-                sudo
-            })).filter(Boolean),
+            ...Object.values(fn(idl)).filter(Boolean),
             ...Object.values(fn({ ...responses })).filter(Boolean)
         ],
         responses,
         idlObject
     };
 };
-
 export const findQueryMsg = (schemas) => {
-    const QueryMsg = schemas.find(schema => schema.title === 'QueryMsg');
-    return QueryMsg;
+    const queryMsg = schemas.find(schema => schema.title === 'QueryMsg');
+    return queryMsg;
 };
-
 export const findExecuteMsg = (schemas) => {
-    const ExecuteMsg = schemas.find(schema =>
-      schema.title.startsWith('ExecuteMsg')
-    );
-    return ExecuteMsg;
+    const executeMsg = schemas.find(schema => schema.title.startsWith('ExecuteMsg'));
+    return executeMsg;
 };
-
 export const findAndParseTypes = async (schemas) => {
     const Types = schemas;
     const allTypes = [];

package/esm/utils/unused.js

@@ -0,0 +1,47 @@
+//@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/file.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const prompt_1 = require("./utils/prompt");
+const cli_1 = require("./cli");
+const fs_1 = require("fs");
+const argv = require('minimist')(process.argv.slice(2));
+const question = [
+    {
+        _: true,
+        type: 'string',
+        name: 'file',
+        message: 'file'
+    }
+];
+(async () => {
+    const { file } = await (0, prompt_1.prompt)(question, argv);
+    const argvv = JSON.parse((0, fs_1.readFileSync)(file, 'utf-8'));
+    await (0, cli_1.cli)(argvv);
+})();

package/generators/client.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const case_1 = require("case");
+const header_1 = require("../utils/header");
+const path_1 = require("path");
+const mkdirp_1 = require("mkdirp");
+const w = __importStar(require("wasm-ast-types"));
+const t = __importStar(require("@babel/types"));
+const fs_1 = require("fs");
+const generator_1 = __importDefault(require("@babel/generator"));
+const wasm_ast_types_1 = require("wasm-ast-types");
+const utils_1 = require("../utils");
+const wasm_ast_types_2 = require("wasm-ast-types");
+exports.default = async (name, contractInfo, outPath, tsClientOptions) => {
+    const { schemas } = contractInfo;
+    const context = new wasm_ast_types_2.RenderContext(contractInfo, {
+        client: tsClientOptions ?? {}
+    });
+    // const options = context.options.client;
+    const localname = (0, case_1.pascal)(name) + '.client.ts';
+    const TypesFile = (0, case_1.pascal)(name) + '.types';
+    const QueryMsg = (0, utils_1.findQueryMsg)(schemas);
+    const ExecuteMsg = (0, utils_1.findExecuteMsg)(schemas);
+    const typeHash = await (0, utils_1.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 = (0, case_1.pascal)(`${name}QueryClient`);
+        ReadOnlyInstance = (0, case_1.pascal)(`${name}ReadOnlyInterface`);
+        body.push(w.createQueryInterface(context, ReadOnlyInstance, QueryMsg));
+        body.push(w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg));
+    }
+    // execute messages
+    if (ExecuteMsg) {
+        const children = (0, wasm_ast_types_1.getMessageProperties)(ExecuteMsg);
+        if (children.length > 0) {
+            Client = (0, case_1.pascal)(`${name}Client`);
+            Instance = (0, case_1.pascal)(`${name}Interface`);
+            body.push(w.createExecuteInterface(context, Instance, context.options.client.execExtendsQuery ? ReadOnlyInstance : null, ExecuteMsg));
+            body.push(w.createExecuteClass(context, Client, Instance, context.options.client.execExtendsQuery ? QueryClient : null, ExecuteMsg));
+        }
+    }
+    if (typeHash.hasOwnProperty('Coin')) {
+        // @ts-ignore
+        delete context.utils.Coin;
+    }
+    const imports = context.getImports();
+    const code = header_1.header + (0, generator_1.default)(
+    // @ts-ignore
+    t.program([
+        ...imports,
+        ...body
+    ])).code;
+    (0, mkdirp_1.sync)(outPath);
+    (0, fs_1.writeFileSync)((0, path_1.join)(outPath, localname), code);
+    return [
+        {
+            type: 'client',
+            contract: name,
+            localname,
+            filename: (0, path_1.join)(outPath, localname),
+        }
+    ];
+};

package/generators/create-helpers.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHelpers = void 0;
+const path_1 = require("path");
+const mkdirp_1 = require("mkdirp");
+const package_json_1 = __importDefault(require("../../package.json"));
+const files_1 = require("../utils/files");
+const helpers_1 = require("../helpers");
+const version = process.env.NODE_ENV === "test" ? "latest" : package_json_1.default.version;
+const header = `/**
+* This file and any referenced files were automatically generated by ${package_json_1.default.name}@${version}
+* DO NOT MODIFY BY HAND. Instead, download the latest proto files for your chain
+* and run the transpile command or yarn proto command to regenerate this bundle.
+*/
+\n`;
+const write = (outPath, file, content, varname) => {
+    const outFile = (0, path_1.join)(outPath, file);
+    (0, mkdirp_1.sync)((0, path_1.dirname)(outFile));
+    (0, files_1.writeContentToFile)(outPath, header + content, outFile);
+    return {
+        type: "plugin",
+        pluginType: "helper",
+        contract: varname ?? (0, path_1.basename)(file, (0, path_1.extname)(file)),
+        localname: file,
+        filename: outFile,
+    };
+};
+const createHelpers = (input, builderContext) => {
+    const files = [];
+    if (input.options?.useContractsHooks?.enabled &&
+        Object.keys(builderContext.providers)?.length) {
+        const useShorthandCtor = input.options?.useShorthandCtor;
+        files.push(write(input.outPath, "contractContextBase.ts", useShorthandCtor
+            ? helpers_1.contractContextBaseShortHandCtor
+            : helpers_1.contractContextBase));
+        files.push(write(input.outPath, "contracts-context.tsx", helpers_1.contractsContextTSX, "contractsContext"));
+    }
+    return files;
+};
+exports.createHelpers = createHelpers;

package/generators/message-builder.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const case_1 = require("case");
+const header_1 = require("../utils/header");
+const path_1 = require("path");
+const mkdirp_1 = require("mkdirp");
+const w = __importStar(require("wasm-ast-types"));
+const t = __importStar(require("@babel/types"));
+const fs_1 = require("fs");
+const generator_1 = __importDefault(require("@babel/generator"));
+const wasm_ast_types_1 = require("wasm-ast-types");
+const utils_1 = require("../utils");
+const wasm_ast_types_2 = require("wasm-ast-types");
+exports.default = async (name, contractInfo, outPath, messageBuilderOptions) => {
+    const { schemas } = contractInfo;
+    const context = new wasm_ast_types_2.RenderContext(contractInfo, {
+        messageBuilder: messageBuilderOptions ?? {},
+    });
+    const localname = (0, case_1.pascal)(name) + ".message-builder.ts";
+    const TypesFile = (0, case_1.pascal)(name) + ".types";
+    const ExecuteMsg = (0, utils_1.findExecuteMsg)(schemas);
+    const typeHash = await (0, utils_1.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 = (0, wasm_ast_types_1.getMessageProperties)(ExecuteMsg);
+        if (children.length > 0) {
+            const className = (0, case_1.pascal)(`${name}ExecuteMsgBuilder`);
+            body.push(w.createMessageBuilderClass(context, className, ExecuteMsg));
+        }
+    }
+    const QueryMsg = (0, utils_1.findQueryMsg)(schemas);
+    // query messages
+    if (QueryMsg) {
+        const children = (0, wasm_ast_types_1.getMessageProperties)(QueryMsg);
+        if (children.length > 0) {
+            const className = (0, case_1.pascal)(`${name}QueryMsgBuilder`);
+            body.push(w.createMessageBuilderClass(context, className, QueryMsg));
+        }
+    }
+    if (typeHash.hasOwnProperty("Coin")) {
+        // @ts-ignore
+        delete context.utils.Coin;
+    }
+    const imports = context.getImports();
+    // @ts-ignore
+    const code = header_1.header + (0, generator_1.default)(t.program([...imports, ...body])).code;
+    (0, mkdirp_1.sync)(outPath);
+    (0, fs_1.writeFileSync)((0, path_1.join)(outPath, localname), code);
+    return [
+        {
+            type: "message-builder",
+            contract: name,
+            localname,
+            filename: (0, path_1.join)(outPath, localname),
+        },
+    ];
+};

package/generators/message-composer.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const case_1 = require("case");
+const header_1 = require("../utils/header");
+const path_1 = require("path");
+const mkdirp_1 = require("mkdirp");
+const w = __importStar(require("wasm-ast-types"));
+const t = __importStar(require("@babel/types"));
+const fs_1 = require("fs");
+const generator_1 = __importDefault(require("@babel/generator"));
+const wasm_ast_types_1 = require("wasm-ast-types");
+const utils_1 = require("../utils");
+const wasm_ast_types_2 = require("wasm-ast-types");
+exports.default = async (name, contractInfo, outPath, messageComposerOptions) => {
+    const { schemas } = contractInfo;
+    const context = new wasm_ast_types_2.RenderContext(contractInfo, {
+        messageComposer: messageComposerOptions ?? {}
+    });
+    // const options = context.options.messageComposer;
+    const localname = (0, case_1.pascal)(name) + '.message-composer.ts';
+    const TypesFile = (0, case_1.pascal)(name) + '.types';
+    const ExecuteMsg = (0, utils_1.findExecuteMsg)(schemas);
+    const typeHash = await (0, utils_1.findAndParseTypes)(schemas);
+    const body = [];
+    body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`));
+    // execute messages
+    if (ExecuteMsg) {
+        const children = (0, wasm_ast_types_1.getMessageProperties)(ExecuteMsg);
+        if (children.length > 0) {
+            const TheClass = (0, case_1.pascal)(`${name}MessageComposer`);
+            const Interface = (0, case_1.pascal)(`${name}Message`);
+            body.push(w.createMessageComposerInterface(context, Interface, ExecuteMsg));
+            body.push(w.createMessageComposerClass(context, TheClass, Interface, ExecuteMsg));
+        }
+    }
+    if (typeHash.hasOwnProperty('Coin')) {
+        // @ts-ignore
+        delete context.utils.Coin;
+    }
+    const imports = context.getImports();
+    const code = header_1.header + (0, generator_1.default)(
+    // @ts-ignore
+    t.program([
+        ...imports,
+        ...body
+    ])).code;
+    (0, mkdirp_1.sync)(outPath);
+    (0, fs_1.writeFileSync)((0, path_1.join)(outPath, localname), code);
+    return [
+        {
+            type: 'message-composer',
+            contract: name,
+            localname,
+            filename: (0, path_1.join)(outPath, localname),
+        }
+    ];
+};