@cosmwasm/ts-codegen 0.35.7 → 1.1.0

package/ts-codegen.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+var argv = require('minimist')(process.argv.slice(2));
+(async () => {
+    await (0, cli_1.cli)(argv);
+})();

package/utils/clean.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clean = void 0;
+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] = (0, exports.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:
+                        // @ts-ignore
+                        copy[attr] = (0, exports.clean)(obj[attr]);
+                }
+            }
+            else {
+                // @ts-ignore
+                copy[attr] = (0, exports.clean)(obj[attr]);
+            }
+        }
+        return copy;
+    }
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+};
+exports.clean = clean;

package/utils/cleanse.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanse = void 0;
+const case_1 = require("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], (0, case_1.pascal)(m[1]));
+    }
+    return str;
+};
+const cleanNullable = (str) => {
+    if (/^Nullable_/.test(str)) {
+        str = str.replace(/^Nullable_/, 'Nullable');
+    }
+    return str;
+};
+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] = (0, exports.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)) {
+                    // @ts-ignore
+                    copy[cleanFor(attr)] = (0, exports.cleanse)(obj[attr]);
+                }
+                else if (/^Nullable_/.test(attr)) {
+                    // @ts-ignore
+                    copy[cleanNullable(attr)] = (0, exports.cleanse)(obj[attr]);
+                }
+                else {
+                    switch (attr) {
+                        case 'title':
+                        case '$ref':
+                            if (typeof obj[attr] === 'string') {
+                                // @ts-ignore
+                                copy[attr] = (0, exports.cleanse)(cleanNullable(cleanFor(obj[attr])));
+                            }
+                            else {
+                                // @ts-ignore
+                                copy[attr] = (0, exports.cleanse)(obj[attr]);
+                            }
+                            break;
+                        default:
+                            // @ts-ignore
+                            copy[attr] = (0, exports.cleanse)(obj[attr]);
+                    }
+                }
+            }
+            else {
+                // @ts-ignore
+                copy[attr] = (0, exports.cleanse)(obj[attr]);
+            }
+        }
+        return copy;
+    }
+    throw new Error("Unable to copy obj! Its type isn't supported.");
+};
+exports.cleanse = cleanse;

package/utils/files.js

@@ -0,0 +1,73 @@
+"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 });
+exports.writeContentToFile = exports.writeAstToFile = void 0;
+const t = __importStar(require("@babel/types"));
+const parser_1 = require("@babel/parser");
+const mkdirp_1 = require("mkdirp");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const generator_1 = __importDefault(require("@babel/generator"));
+const unused_1 = require("./unused");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const writeAstToFile = (outPath, program, filename, removeUnusedImports = false, isTsDisable = false, isEslintDisable = false) => {
+    const ast = t.program(program);
+    const content = (0, generator_1.default)(ast).code;
+    if (removeUnusedImports) {
+        const plugins = ["typescript"];
+        const newAst = (0, parser_1.parse)(content, {
+            sourceType: "module",
+            plugins,
+        });
+        (0, traverse_1.default)(newAst, unused_1.unused);
+        const content2 = (0, generator_1.default)(newAst).code;
+        (0, exports.writeContentToFile)(outPath, content2, filename, isTsDisable, isEslintDisable);
+    }
+    else {
+        (0, exports.writeContentToFile)(outPath, content, filename, isTsDisable, isEslintDisable);
+    }
+};
+exports.writeAstToFile = writeAstToFile;
+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;
+    (0, mkdirp_1.sync)((0, path_1.dirname)(filename));
+    (0, fs_1.writeFileSync)(filename, text);
+};
+exports.writeContentToFile = writeContentToFile;

package/utils/header.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.header = void 0;
+const package_json_1 = __importDefault(require("../../package.json"));
+const version = process.env.NODE_ENV === 'test' ? 'latest' : package_json_1.default.version;
+exports.header = `/**
+* This file was automatically generated by ${package_json_1.default.name}@${version}.
+* DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+* and run the ${package_json_1.default.name} generate command to regenerate this file.
+*/
+\n`;

package/utils/index.d.ts

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

package/utils/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schemas"), exports);

package/utils/parse.d.ts

@@ -0,0 +1 @@
+export declare const parser: (codes: string[]) => Record<string, any>;

package/utils/parse.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.parser = void 0;
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const parser_1 = require("@babel/parser");
+const parser = (codes) => {
+    const hash = {};
+    codes.forEach(code => {
+        const plugins = [
+            'typescript',
+        ];
+        const ast = (0, parser_1.parse)(code, {
+            sourceType: 'module',
+            plugins
+        });
+        const visitor = visitorFn({
+            addType(key, node) {
+                hash[key] = node;
+            }
+        });
+        (0, traverse_1.default)(ast, visitor);
+    });
+    return hash;
+};
+exports.parser = parser;
+const visitorFn = (parser) => ({
+    TSTypeAliasDeclaration(path) {
+        parser.addType(path.node.id.name, path.parentPath.node);
+        // if (path.node.id.name.endsWith('For_Empty')) {
+        //     const newName = path.node.id.name.replace(/For_Empty$/, '_for_Empty');
+        //     path.parentPath.node.declaration.id.name = newName;
+        //     parser.addType(newName, path.parentPath.node);
+        // } else {
+        //     parser.addType(path.node.id.name, path.parentPath.node);
+        // }
+    },
+    TSInterfaceDeclaration(path) {
+        parser.addType(path.node.id.name, path.parentPath.node);
+    }
+});

package/utils/prompt.d.ts

@@ -0,0 +1,3 @@
+export declare const getFuzzySearch: (list: any) => (answers: any, input: any) => Promise<unknown>;
+export declare const getFuzzySearchNames: (nameValueItemList: any) => (answers: any, input: any) => Promise<unknown>;
+export declare const prompt: (questions?: any[], argv?: {}) => Promise<any>;

package/utils/prompt.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = exports.getFuzzySearchNames = exports.getFuzzySearch = void 0;
+// @ts-nocheck
+const fuzzy_1 = require("fuzzy");
+const inquirerer_1 = require("inquirerer");
+const getFuzzySearch = (list) => {
+    return (answers, input) => {
+        input = input || '';
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                const fuzzyResult = (0, fuzzy_1.filter)(input, list);
+                resolve(fuzzyResult.map(function (el) {
+                    return el.original;
+                }));
+            }, 25);
+        });
+    };
+};
+exports.getFuzzySearch = getFuzzySearch;
+const getFuzzySearchNames = (nameValueItemList) => {
+    const list = nameValueItemList.map(({ name, value }) => name);
+    return (answers, input) => {
+        input = input || '';
+        return new Promise(function (resolve) {
+            setTimeout(function () {
+                const fuzzyResult = (0, fuzzy_1.filter)(input, list);
+                resolve(fuzzyResult.map(function (el) {
+                    return nameValueItemList.find(({ name, value }) => el.original == name);
+                }));
+            }, 25);
+        });
+    };
+};
+exports.getFuzzySearchNames = getFuzzySearchNames;
+const transform = (questions) => {
+    return questions.map((q) => {
+        if (q.type === 'fuzzy') {
+            const choices = q.choices;
+            delete q.choices;
+            return {
+                ...q,
+                type: 'autocomplete',
+                source: (0, exports.getFuzzySearch)(choices)
+            };
+        }
+        else if (q.type === 'fuzzy:objects') {
+            const choices = q.choices;
+            delete q.choices;
+            return {
+                ...q,
+                type: 'autocomplete',
+                source: (0, exports.getFuzzySearchNames)(choices)
+            };
+        }
+        else {
+            return q;
+        }
+    });
+};
+const prompt = async (questions = [], argv = {}) => {
+    questions = transform(questions);
+    return await (0, inquirerer_1.prompt)(questions, argv);
+};
+exports.prompt = prompt;

package/utils/schemas.d.ts

@@ -0,0 +1,11 @@
+import { ContractInfo } from 'wasm-ast-types';
+import { ExecuteMsg, JSONSchema, QueryMsg } from '@cosmology/ts-codegen-types';
+interface ReadSchemaOpts {
+    schemaDir: string;
+    clean?: boolean;
+}
+export declare const readSchemas: ({ schemaDir, clean }: ReadSchemaOpts) => Promise<ContractInfo>;
+export declare const findQueryMsg: (schemas: JSONSchema[]) => QueryMsg;
+export declare const findExecuteMsg: (schemas: JSONSchema[]) => ExecuteMsg;
+export declare const findAndParseTypes: (schemas: JSONSchema[]) => Promise<Record<string, any>>;
+export {};

package/utils/schemas.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAndParseTypes = exports.findExecuteMsg = exports.findQueryMsg = exports.readSchemas = void 0;
+const glob_1 = require("glob");
+const fs_1 = require("fs");
+const cleanse_1 = require("./cleanse");
+const json_schema_to_typescript_1 = require("@pyramation/json-schema-to-typescript");
+const parse_1 = require("./parse");
+;
+const readSchemas = async ({ schemaDir, clean = true }) => {
+    const fn = clean ? cleanse_1.cleanse : (schema) => schema;
+    const files = (0, glob_1.sync)(schemaDir + '/**/*.json')
+        .filter(file => !file.match(/\/raw\//));
+    const schemas = files
+        .map(file => JSON.parse((0, fs_1.readFileSync)(file, 'utf-8')));
+    if (schemas.length > 1) {
+        // legacy
+        // TODO add console.warn here
+        return {
+            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;
+    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(idl)).filter(Boolean),
+            ...Object.values(fn({ ...responses })).filter(Boolean)
+        ],
+        responses,
+        idlObject
+    };
+};
+exports.readSchemas = readSchemas;
+const findQueryMsg = (schemas) => {
+    const queryMsg = schemas.find(schema => schema.title === 'QueryMsg');
+    return queryMsg;
+};
+exports.findQueryMsg = findQueryMsg;
+const findExecuteMsg = (schemas) => {
+    const executeMsg = schemas.find(schema => schema.title.startsWith('ExecuteMsg'));
+    return executeMsg;
+};
+exports.findExecuteMsg = findExecuteMsg;
+const findAndParseTypes = async (schemas) => {
+    const Types = schemas;
+    const allTypes = [];
+    for (const typ in Types) {
+        if (Types[typ].definitions) {
+            for (const key of Object.keys(Types[typ].definitions)) {
+                // set title
+                Types[typ].definitions[key].title = key;
+            }
+        }
+        const result = await (0, json_schema_to_typescript_1.compile)(Types[typ], Types[typ].title);
+        allTypes.push(result);
+    }
+    const typeHash = (0, parse_1.parser)(allTypes);
+    return typeHash;
+};
+exports.findAndParseTypes = findAndParseTypes;

package/utils/unused.js

@@ -0,0 +1,73 @@
+"use strict";
+//@ts-nocheck
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unused = void 0;
+const t = __importStar(require("@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
+exports.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();
+                }
+            });
+        }
+    }
+};