@cosmwasm/ts-codegen 0.3.9

package/main/react-query.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _case = require("case");
+
+var _header = require("./header");
+
+var _path = require("path");
+
+var _mkdirp = require("mkdirp");
+
+var w = _interopRequireWildcard(require("wasm-ast-types"));
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+var _fs = require("fs");
+
+var _generator = _interopRequireDefault(require("@babel/generator"));
+
+var _utils = require("./utils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var _default = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(name, schemas, outPath) {
+    var RecoilFile, Contract, QueryMsg, typeHash, QueryClient, ReadOnlyInstance, body, code;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            RecoilFile = (0, _case.pascal)("".concat(name, "Contract")) + '.react-query.ts';
+            Contract = (0, _case.pascal)("".concat(name, "Contract")) + '.ts';
+            QueryMsg = (0, _utils.findQueryMsg)(schemas);
+            _context.next = 5;
+            return (0, _utils.findAndParseTypes)(schemas);
+
+          case 5:
+            typeHash = _context.sent;
+            QueryClient = null;
+            ReadOnlyInstance = null;
+            body = [];
+            body.push(w.importStmt(['useQuery', 'UseQueryOptions'], 'react-query'));
+            body.push(w.importStmt(Object.keys(typeHash), "./".concat(Contract).replace(/\.ts$/, ''))); // query messages
+
+            if (QueryMsg) {
+              QueryClient = (0, _case.pascal)("".concat(name, "QueryClient"));
+              ReadOnlyInstance = (0, _case.pascal)("".concat(name, "ReadOnlyInterface"));
+              body.push(w.importStmt([QueryClient], "./".concat(Contract)));
+              [].push.apply(body, w.createReactQueryHooks(QueryMsg, name, QueryClient));
+            }
+
+            code = _header.header + (0, _generator["default"])(t.program(body)).code;
+            (0, _mkdirp.sync)(outPath);
+            (0, _fs.writeFileSync)((0, _path.join)(outPath, RecoilFile), code);
+
+          case 15:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function (_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports["default"] = _default;

package/main/recoil.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _case = require("case");
+
+var _header = require("./header");
+
+var _path = require("path");
+
+var _mkdirp = require("mkdirp");
+
+var w = _interopRequireWildcard(require("wasm-ast-types"));
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+var _fs = require("fs");
+
+var _generator = _interopRequireDefault(require("@babel/generator"));
+
+var _utils = require("./utils");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var _default = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(name, schemas, outPath) {
+    var RecoilFile, Contract, QueryMsg, typeHash, QueryClient, ReadOnlyInstance, body, code;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            RecoilFile = (0, _case.pascal)("".concat(name, "Contract")) + '.recoil.ts';
+            Contract = (0, _case.pascal)("".concat(name, "Contract")) + '.ts';
+            QueryMsg = (0, _utils.findQueryMsg)(schemas);
+            _context.next = 5;
+            return (0, _utils.findAndParseTypes)(schemas);
+
+          case 5:
+            typeHash = _context.sent;
+            QueryClient = null;
+            ReadOnlyInstance = null;
+            body = [];
+            body.push(w.importStmt(['selectorFamily'], 'recoil'));
+            body.push(w.importStmt(['cosmWasmClient'], './chain'));
+            body.push(w.importStmt(Object.keys(typeHash), "./".concat(Contract).replace(/\.ts$/, ''))); // query messages
+
+            if (QueryMsg) {
+              QueryClient = (0, _case.pascal)("".concat(name, "QueryClient"));
+              ReadOnlyInstance = (0, _case.pascal)("".concat(name, "ReadOnlyInterface"));
+              body.push(w.importStmt([QueryClient], "./".concat(Contract)));
+              body.push(w.createRecoilQueryClientType());
+              body.push(w.createRecoilQueryClient(name, QueryClient));
+              [].push.apply(body, w.createRecoilSelectors(name, QueryClient, QueryMsg));
+            }
+
+            code = _header.header + (0, _generator["default"])(t.program(body)).code;
+            (0, _mkdirp.sync)(outPath);
+            (0, _fs.writeFileSync)((0, _path.join)(outPath, RecoilFile), code);
+
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function (_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports["default"] = _default;

package/main/utils.js

@@ -0,0 +1,123 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readSchemas = exports.findQueryMsg = exports.findExecuteMsg = exports.findAndParseTypes = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _glob = require("glob");
+
+var _fs = require("fs");
+
+var _cleanse = require("./cleanse");
+
+var _jsonSchemaToTypescript = require("json-schema-to-typescript");
+
+var _parse = require("./parse");
+
+var readSchemas = function readSchemas(_ref) {
+  var schemaDir = _ref.schemaDir,
+      argv = _ref.argv,
+      _ref$clean = _ref.clean,
+      clean = _ref$clean === void 0 ? true : _ref$clean;
+  var fn = clean ? _cleanse.cleanse : function (str) {
+    return str;
+  };
+  var files = (0, _glob.sync)(schemaDir + '/**/*.json');
+  var schemas = files.map(function (file) {
+    return JSON.parse((0, _fs.readFileSync)(file, 'utf-8'));
+  });
+
+  if (argv.packed) {
+    if (schemas.length !== 1) {
+      throw new Error('packed option only supports one file');
+    }
+
+    return Object.values(fn(schemas[0]));
+  }
+
+  return fn(schemas);
+};
+
+exports.readSchemas = readSchemas;
+
+var findQueryMsg = function findQueryMsg(schemas) {
+  var QueryMsg = schemas.find(function (schema) {
+    return schema.title === 'QueryMsg';
+  });
+  return QueryMsg;
+};
+
+exports.findQueryMsg = findQueryMsg;
+
+var findExecuteMsg = function findExecuteMsg(schemas) {
+  var ExecuteMsg = schemas.find(function (schema) {
+    return schema.title === 'ExecuteMsg' || schema.title === 'ExecuteMsg_for_Empty' || // if cleanse is used, this is never
+    schema.title === 'ExecuteMsgForEmpty';
+  });
+  return ExecuteMsg;
+};
+
+exports.findExecuteMsg = findExecuteMsg;
+
+var findAndParseTypes = /*#__PURE__*/function () {
+  var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(schemas) {
+    var Types, allTypes, typ, _i, _Object$keys, key, result, typeHash;
+
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            Types = schemas;
+            allTypes = [];
+            _context.t0 = _regenerator["default"].keys(Types);
+
+          case 3:
+            if ((_context.t1 = _context.t0()).done) {
+              _context.next = 12;
+              break;
+            }
+
+            typ = _context.t1.value;
+
+            if (Types[typ].definitions) {
+              for (_i = 0, _Object$keys = Object.keys(Types[typ].definitions); _i < _Object$keys.length; _i++) {
+                key = _Object$keys[_i];
+                // set title
+                Types[typ].definitions[key].title = key;
+              }
+            }
+
+            _context.next = 8;
+            return (0, _jsonSchemaToTypescript.compile)(Types[typ], Types[typ].title);
+
+          case 8:
+            result = _context.sent;
+            allTypes.push(result);
+            _context.next = 3;
+            break;
+
+          case 12:
+            typeHash = (0, _parse.parser)(allTypes);
+            return _context.abrupt("return", typeHash);
+
+          case 14:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function findAndParseTypes(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+exports.findAndParseTypes = findAndParseTypes;

package/module/clean.js

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

@@ -0,0 +1,76 @@
+const cleanFor = str => {
+  /*
+      1. look at first char after _for_
+      2. ONLY if you find capitals after, modify it
+  */
+  if (/_for_[A-Z]/.test(str)) {
+    return str.replace(/_for_/, 'For');
+  }
+
+  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/module/cli.js

@@ -0,0 +1,20 @@
+import { prompt } from './prompt';
+import { Commands as commands } from './cmds';
+const question = [{
+  _: true,
+  type: 'fuzzy',
+  name: 'cmd',
+  message: 'what do you want to do?',
+  choices: Object.keys(commands)
+}];
+export const cli = async argv => {
+  var {
+    cmd
+  } = await prompt(question, argv);
+
+  if (typeof commands[cmd] === 'function') {
+    await commands[cmd](argv);
+  } else {
+    console.log('command not found.');
+  }
+};

package/module/cmds.js

@@ -0,0 +1,12 @@
+import _boilerplate from './commands/boilerplate';
+import _from_partial from './commands/from-partial';
+import _generate from './commands/generate';
+import _react_query from './commands/react-query';
+import _recoil from './commands/recoil';
+const Commands = {};
+Commands['boilerplate'] = _boilerplate;
+Commands['from-partial'] = _from_partial;
+Commands['generate'] = _generate;
+Commands['react-query'] = _react_query;
+Commands['recoil'] = _recoil;
+export { Commands };

package/module/commands/boilerplate.js

@@ -0,0 +1,116 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import * as shell from 'shelljs';
+import { prompt } from '../prompt';
+import dargs from 'dargs';
+
+const glob = require('glob').sync;
+
+const fs = require('fs');
+
+const path = require('path');
+
+const repo = 'git@github.com:pyramation/tmpl-cosmwasm-module.git';
+export default (async argv => {
+  if (!shell.which('git')) {
+    shell.echo('Sorry, this script requires git');
+    return shell.exit(1);
+  }
+
+  const {
+    name
+  } = await prompt([{
+    type: 'string',
+    name: 'name',
+    message: 'Enter your new module name'
+  }], argv);
+  shell.exec(`git clone ${repo} ${name}`);
+  shell.cd(name);
+  const questions = JSON.parse(fs.readFileSync(`.questions.json`));
+  const fullname = shell.exec('git config --global user.name', {
+    silent: true
+  }).trim();
+  const email = shell.exec('git config --global user.email', {
+    silent: true
+  }).trim(); // @__USERNAME__/__MODULENAME__
+  // __PACKAGE_IDENTIFIER__
+
+  const args = dargs(_objectSpread(_objectSpread({
+    _: []
+  }, argv), {}, {
+    __MODULENAME__: name,
+    __USERFULLNAME__: fullname,
+    __USEREMAIL__: email
+  }), {
+    allowCamelCase: true
+  });
+  const results = await prompt(questions, args);
+  let scopedResults;
+  const license = await prompt([{
+    name: '__LICENSE__',
+    message: 'Which license?',
+    choices: ['MIT', 'closed'],
+    type: 'list',
+    required: true
+  }], []);
+
+  if (results.__ACCESS__ === 'public') {
+    scopedResults = await prompt([{
+      type: 'confirm',
+      name: 'scoped',
+      message: 'use npm scopes?',
+      required: true
+    }], []);
+  }
+
+  const files = [].concat(glob(process.cwd() + '/**/.*')).concat(glob(process.cwd() + '/**/*'));
+
+  for (let i = 0; i < files.length; i++) {
+    const templateFile = files[i];
+    if (fs.lstatSync(templateFile).isDirectory()) continue;
+    let content = fs.readFileSync(templateFile).toString();
+
+    if (path.basename(templateFile) === 'LICENSE' && license.__LICENSE__ === 'closed') {
+      content = `Copyright (c) 2022 __USERFULLNAME__ <__USEREMAIL__> - All Rights Reserved
+Unauthorized copying via any medium is strictly prohibited
+Proprietary and confidential`;
+    }
+
+    Object.keys(results).forEach(key => {
+      if (/^__/.test(key)) {
+        content = content.replace(new RegExp(key, 'g'), results[key]);
+      }
+    });
+
+    if (results.__ACCESS__ === 'public') {
+      if (scopedResults.scoped) {
+        content = content.replace(/__PACKAGE_IDENTIFIER__/g, `@${results.__USERNAME__}/${results.__MODULENAME__}`);
+      } else {
+        content = content.replace(/__PACKAGE_IDENTIFIER__/g, `${results.__MODULENAME__}`);
+      }
+    } else {
+      content = content.replace(/__PACKAGE_IDENTIFIER__/g, `@${results.__USERNAME__}/${results.__MODULENAME__}`);
+    }
+
+    if (path.basename(templateFile) === 'README.md') {
+      content = `# ${results.__MODULENAME__}`;
+    }
+
+    fs.writeFileSync(templateFile, content);
+  }
+
+  shell.rm('-rf', '.git');
+  shell.rm('-rf', '.questions.json');
+  console.log(`
+
+       |||
+      (o o)
+  ooO--(_)--Ooo-
+
+  ✨ Great work!
+  `);
+});

package/module/commands/from-partial.js

@@ -0,0 +1,33 @@
+import { prompt } from '../prompt';
+import fromPartial from '../from-partial';
+import { readSchemas } from '../utils';
+export default (async argv => {
+  const questions = [{
+    _: true,
+    type: 'path',
+    name: 'schema',
+    message: 'which directory contains the the Rust contracts?',
+    default: './schema'
+  }, {
+    _: true,
+    type: 'path',
+    name: 'out',
+    message: 'where is the output directory?',
+    default: './ts'
+  }, {
+    _: true,
+    type: 'string',
+    name: 'name',
+    message: 'contract name?'
+  }];
+  const {
+    schema,
+    out,
+    name
+  } = await prompt(questions, argv);
+  const schemas = readSchemas({
+    schemaDir: schema,
+    argv
+  });
+  await fromPartial(name, schemas, out);
+});

package/module/commands/generate.js

@@ -0,0 +1,33 @@
+import { prompt } from '../prompt';
+import cosmscript from '../generate';
+import { readSchemas } from '../utils';
+export default (async argv => {
+  const questions = [{
+    _: true,
+    type: 'path',
+    name: 'schema',
+    message: 'which directory contains the the Rust contracts?',
+    default: './schema'
+  }, {
+    _: true,
+    type: 'path',
+    name: 'out',
+    message: 'where is the output directory?',
+    default: './ts'
+  }, {
+    _: true,
+    type: 'string',
+    name: 'name',
+    message: 'contract name?'
+  }];
+  const {
+    schema,
+    out,
+    name
+  } = await prompt(questions, argv);
+  const schemas = readSchemas({
+    schemaDir: schema,
+    argv
+  });
+  await cosmscript(name, schemas, out);
+});

package/module/commands/react-query.js

@@ -0,0 +1,33 @@
+import { prompt } from '../prompt';
+import reactQuery from '../react-query';
+import { readSchemas } from '../utils';
+export default (async argv => {
+  const questions = [{
+    _: true,
+    type: 'path',
+    name: 'schema',
+    message: 'which directory contains the the Rust contracts?',
+    default: './schema'
+  }, {
+    _: true,
+    type: 'path',
+    name: 'out',
+    message: 'where is the output directory?',
+    default: './ts'
+  }, {
+    _: true,
+    type: 'string',
+    name: 'name',
+    message: 'contract name?'
+  }];
+  const {
+    schema,
+    out,
+    name
+  } = await prompt(questions, argv);
+  const schemas = readSchemas({
+    schemaDir: schema,
+    argv
+  });
+  await reactQuery(name, schemas, out);
+});