@cosmwasm/ts-codegen 0.16.5 → 0.18.0

package/src/utils/cleanse.ts

@@ -0,0 +1,77 @@
+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;
+};
+
+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 {
+                    switch (attr) {
+                        case 'title':
+                        case '$ref':
+                            if (typeof obj[attr] === 'string') {
+                                copy[attr] = cleanse(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.");
+};

package/src/utils/header.ts

@@ -0,0 +1,8 @@
+import pkg from '../../package.json';
+const version = process.env.NODE_ENV === 'test' ? 'latest' : pkg.version;
+export const header = `/**
+* This file was automatically generated by ${pkg.name}@${version}.
+* DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+* and run the ${pkg.name} generate command to regenerate this file.
+*/
+\n`;

package/src/utils/index.ts

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

package/src/utils/parse.ts

@@ -0,0 +1,45 @@
+import babelTraverse from '@babel/traverse';
+import { parse, ParserPlugin } from '@babel/parser';
+
+export const parser = (codes) => {
+
+    const hash = {};
+    codes.forEach(code => {
+
+        const plugins: ParserPlugin[] = [
+            '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);
+        // 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/src/utils/prompt.js

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,102 @@
+import { sync as glob } from 'glob';
+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;
+    const files = glob(schemaDir + '/**/*.json');
+    const schemas = files
+        .map(file => JSON.parse(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.
+    return {
+        schemas: [
+            ...Object.values(fn({
+                instantiate,
+                execute,
+                query,
+                migrate,
+                sudo
+            })).filter(Boolean),
+            ...Object.values(fn({ ...responses })).filter(Boolean)
+        ],
+        responses,
+        idlObject
+    };
+};
+
+export const findQueryMsg = (schemas) => {
+    const QueryMsg = schemas.find(schema => schema.title === 'QueryMsg');
+    return QueryMsg;
+};
+
+export const findExecuteMsg = (schemas) => {
+    const ExecuteMsg = schemas.find(schema =>
+        schema.title === 'ExecuteMsg' ||
+        schema.title === 'ExecuteMsg_for_Empty' || // if cleanse is used, this is never
+        schema.title === 'ExecuteMsgForEmpty'
+    );
+    return ExecuteMsg;
+};
+
+export 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 compile(Types[typ], Types[typ].title);
+        allTypes.push(result);
+    }
+    const typeHash = parser(allTypes);
+    return typeHash;
+};