@cosmwasm/ts-codegen 0.7.3 → 0.8.1

package/main/generators/recoil.js

@@ -11,6 +11,8 @@ exports["default"] = void 0;
 
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 
 var _case = require("case");
@@ -36,42 +38,56 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 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, context, code;
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(name, schemas, outPath, recoilOptions) {
+    var context, options, localname, ContractFile, TypesFile, QueryMsg, typeHash, QueryClient, ReadOnlyInstance, body, imports, 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';
+            context = new w.RenderContext((0, _utils.getDefinitionSchema)(schemas), {
+              recoil: recoilOptions !== null && recoilOptions !== void 0 ? recoilOptions : {}
+            });
+            options = context.options.recoil;
+            localname = (0, _case.pascal)(name) + '.recoil.ts';
+            ContractFile = (0, _case.pascal)(name) + '.client';
+            TypesFile = (0, _case.pascal)(name) + '.types';
             QueryMsg = (0, _utils.findQueryMsg)(schemas);
-            _context.next = 5;
+            _context.next = 8;
             return (0, _utils.findAndParseTypes)(schemas);
 
-          case 5:
+          case 8:
             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$/, '')));
-            context = new w.RenderContext((0, _utils.getDefinitionSchema)(schemas)); // query messages
+            body.push(w.importStmt(Object.keys(typeHash), "./".concat(TypesFile))); // 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.importStmt([QueryClient], "./".concat(ContractFile)));
               body.push(w.createRecoilQueryClientType());
               body.push(w.createRecoilQueryClient(context, name, QueryClient));
               [].push.apply(body, w.createRecoilSelectors(context, 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);
+            if (typeHash.hasOwnProperty('Coin')) {
+              delete context.utils.Coin;
+            }
 
-          case 17:
+            imports = context.getImports();
+            code = _header.header + (0, _generator["default"])(t.program([].concat((0, _toConsumableArray2["default"])(imports), body))).code;
+            (0, _mkdirp.sync)(outPath);
+            (0, _fs.writeFileSync)((0, _path.join)(outPath, localname), code);
+            return _context.abrupt("return", [{
+              type: 'recoil',
+              contract: name,
+              localname: localname,
+              filename: (0, _path.join)(outPath, localname)
+            }]);
+
+          case 21:
           case "end":
             return _context.stop();
         }
@@ -79,7 +95,7 @@ var _default = /*#__PURE__*/function () {
     }, _callee);
   }));
 
-  return function (_x, _x2, _x3) {
+  return function (_x, _x2, _x3, _x4) {
     return _ref.apply(this, arguments);
   };
 }();

package/main/generators/types.js

@@ -0,0 +1,95 @@
+"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 _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _case = require("case");
+
+var _header = require("../utils/header");
+
+var _path = require("path");
+
+var _mkdirp = require("mkdirp");
+
+var t = _interopRequireWildcard(require("@babel/types"));
+
+var _fs = require("fs");
+
+var _generator = _interopRequireDefault(require("@babel/generator"));
+
+var _clean = require("../utils/clean");
+
+var _utils = require("../utils");
+
+var _wasmAstTypes = require("wasm-ast-types");
+
+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, tsTypesOptions) {
+    var context, options, localname, ExecuteMsg, typeHash, body, imports, code, filename;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            context = new _wasmAstTypes.RenderContext((0, _utils.getDefinitionSchema)(schemas), {
+              tsClient: tsTypesOptions !== null && tsTypesOptions !== void 0 ? tsTypesOptions : {}
+            });
+            options = context.options.types;
+            localname = (0, _case.pascal)(name) + '.types.ts';
+            ExecuteMsg = (0, _utils.findExecuteMsg)(schemas);
+            _context.next = 6;
+            return (0, _utils.findAndParseTypes)(schemas);
+
+          case 6:
+            typeHash = _context.sent;
+            body = []; // TYPES
+
+            Object.values(typeHash).forEach(function (type) {
+              body.push((0, _clean.clean)(type));
+            }); // alias the ExecuteMsg
+
+            if (options.aliasExecuteMsg && ExecuteMsg) {
+              body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier("".concat(name, "ExecuteMsg")), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+            }
+
+            imports = context.getImports();
+            code = _header.header + (0, _generator["default"])(t.program([].concat((0, _toConsumableArray2["default"])(imports), body))).code;
+            (0, _mkdirp.sync)(outPath);
+            filename = (0, _path.join)(outPath, localname);
+            (0, _fs.writeFileSync)(filename, code);
+            return _context.abrupt("return", [{
+              type: 'type',
+              contract: name,
+              localname: localname,
+              filename: filename
+            }]);
+
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function (_x, _x2, _x3, _x4) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports["default"] = _default;

package/main/index.js

@@ -6,39 +6,67 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
-  tsClient: true,
-  fromPartial: true,
-  reactQuery: true,
-  recoil: true
+  generateTypes: true,
+  generateClient: true,
+  generateMessageComposer: true,
+  generateReactQuery: true,
+  generateRecoil: true
 };
-Object.defineProperty(exports, "fromPartial", {
+exports["default"] = void 0;
+Object.defineProperty(exports, "generateClient", {
   enumerable: true,
   get: function get() {
-    return _fromPartial["default"];
+    return _client["default"];
   }
 });
-Object.defineProperty(exports, "reactQuery", {
+Object.defineProperty(exports, "generateMessageComposer", {
+  enumerable: true,
+  get: function get() {
+    return _messageComposer["default"];
+  }
+});
+Object.defineProperty(exports, "generateReactQuery", {
   enumerable: true,
   get: function get() {
     return _reactQuery["default"];
   }
 });
-Object.defineProperty(exports, "recoil", {
+Object.defineProperty(exports, "generateRecoil", {
   enumerable: true,
   get: function get() {
     return _recoil["default"];
   }
 });
-Object.defineProperty(exports, "tsClient", {
+Object.defineProperty(exports, "generateTypes", {
   enumerable: true,
   get: function get() {
-    return _tsClient["default"];
+    return _types["default"];
   }
 });
 
-var _tsClient = _interopRequireDefault(require("./generators/ts-client"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _builder = require("./builder");
+
+Object.keys(_builder).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _builder[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _builder[key];
+    }
+  });
+});
+
+var _types = _interopRequireDefault(require("./generators/types"));
+
+var _client = _interopRequireDefault(require("./generators/client"));
 
-var _fromPartial = _interopRequireDefault(require("./generators/from-partial"));
+var _messageComposer = _interopRequireDefault(require("./generators/message-composer"));
 
 var _reactQuery = _interopRequireDefault(require("./generators/react-query"));
 
@@ -58,16 +86,42 @@ Object.keys(_utils).forEach(function (key) {
   });
 });
 
-var _imports = require("./utils/imports");
+var _bundler = require("./bundler");
 
-Object.keys(_imports).forEach(function (key) {
+Object.keys(_bundler).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _imports[key]) return;
+  if (key in exports && exports[key] === _bundler[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function get() {
-      return _imports[key];
+      return _bundler[key];
     }
   });
-});
+});
+
+var _default = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(input) {
+    var builder;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            builder = new _builder.TSBuilder(input);
+            _context.next = 3;
+            return builder.build();
+
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function (_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports["default"] = _default;

package/main/types.js

@@ -0,0 +1 @@
+"use strict";

package/main/utils/schemas.js

@@ -27,15 +27,17 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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) { (0, _defineProperty2["default"])(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; }
 
+;
+
 var readSchemas = /*#__PURE__*/function () {
   var _ref2 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(_ref) {
-    var schemaDir, argv, _ref$clean, clean, fn, files, schemas;
+    var schemaDir, schemaOptions, _ref$clean, clean, fn, files, schemas;
 
     return _regenerator["default"].wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            schemaDir = _ref.schemaDir, argv = _ref.argv, _ref$clean = _ref.clean, clean = _ref$clean === void 0 ? true : _ref$clean;
+            schemaDir = _ref.schemaDir, schemaOptions = _ref.schemaOptions, _ref$clean = _ref.clean, clean = _ref$clean === void 0 ? true : _ref$clean;
             fn = clean ? _cleanse.cleanse : function (str) {
               return str;
             };
@@ -44,7 +46,7 @@ var readSchemas = /*#__PURE__*/function () {
               return JSON.parse((0, _fs.readFileSync)(file, 'utf-8'));
             });
 
-            if (!argv.packed) {
+            if (!(schemaOptions !== null && schemaOptions !== void 0 && schemaOptions.packed)) {
               _context.next = 8;
               break;
             }

package/module/builder/builder.js

@@ -0,0 +1,178 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+const _excluded = ["enabled"],
+      _excluded2 = ["enabled"],
+      _excluded3 = ["enabled"],
+      _excluded4 = ["enabled"],
+      _excluded5 = ["enabled"];
+import { defaultOptions } from "wasm-ast-types";
+import { header } from '../utils/header';
+import { join } from "path";
+import { writeFileSync } from 'fs';
+import { sync as mkdirp } from "mkdirp";
+import generateMessageComposer from '../generators/message-composer';
+import generateTypes from '../generators/types';
+import generateReactQuery from '../generators/react-query';
+import generateRecoil from '../generators/recoil';
+import generateClient from '../generators/client';
+import { basename } from 'path';
+import { readSchemas } from '../utils';
+import deepmerge from 'deepmerge';
+import { pascal } from "case";
+import { createFileBundle, recursiveModuleBundle } from "../bundler";
+import generate from '@babel/generator';
+import * as t from '@babel/types';
+const defaultOpts = {
+  bundle: {
+    enabled: true,
+    scope: 'contracts',
+    bundleFile: 'bundle.ts'
+  }
+};
+;
+;
+;
+export class TSBuilder {
+  constructor({
+    contracts,
+    outPath,
+    options
+  }) {
+    _defineProperty(this, "contracts", void 0);
+
+    _defineProperty(this, "outPath", void 0);
+
+    _defineProperty(this, "options", void 0);
+
+    _defineProperty(this, "files", []);
+
+    this.contracts = contracts;
+    this.outPath = outPath;
+    this.options = deepmerge(deepmerge(defaultOptions, defaultOpts), options ?? {});
+  }
+
+  getContracts() {
+    return this.contracts.map(contractOpt => {
+      if (typeof contractOpt === 'string') {
+        const name = basename(contractOpt);
+        const contractName = pascal(name);
+        return {
+          name: contractName,
+          dir: contractOpt
+        };
+      }
+
+      return {
+        name: pascal(contractOpt.name),
+        dir: contractOpt.dir
+      };
+    });
+  }
+
+  async renderTypes(contract) {
+    const _this$options$types = this.options.types,
+          {
+      enabled
+    } = _this$options$types,
+          options = _objectWithoutProperties(_this$options$types, _excluded);
+
+    if (!enabled) return;
+    const schemas = await readSchemas({
+      schemaDir: contract.dir
+    });
+    const files = await generateTypes(contract.name, schemas, this.outPath, options);
+    [].push.apply(this.files, files);
+  }
+
+  async renderClient(contract) {
+    const _this$options$client = this.options.client,
+          {
+      enabled
+    } = _this$options$client,
+          options = _objectWithoutProperties(_this$options$client, _excluded2);
+
+    if (!enabled) return;
+    const schemas = await readSchemas({
+      schemaDir: contract.dir
+    });
+    const files = await generateClient(contract.name, schemas, this.outPath, options);
+    [].push.apply(this.files, files);
+  }
+
+  async renderRecoil(contract) {
+    const _this$options$recoil = this.options.recoil,
+          {
+      enabled
+    } = _this$options$recoil,
+          options = _objectWithoutProperties(_this$options$recoil, _excluded3);
+
+    if (!enabled) return;
+    const schemas = await readSchemas({
+      schemaDir: contract.dir
+    });
+    const files = await generateRecoil(contract.name, schemas, this.outPath, options);
+    [].push.apply(this.files, files);
+  }
+
+  async renderReactQuery(contract) {
+    const _this$options$reactQu = this.options.reactQuery,
+          {
+      enabled
+    } = _this$options$reactQu,
+          options = _objectWithoutProperties(_this$options$reactQu, _excluded4);
+
+    if (!enabled) return;
+    const schemas = await readSchemas({
+      schemaDir: contract.dir
+    });
+    const files = await generateReactQuery(contract.name, schemas, this.outPath, options);
+    [].push.apply(this.files, files);
+  }
+
+  async renderMessageComposer(contract) {
+    const _this$options$message = this.options.messageComposer,
+          {
+      enabled
+    } = _this$options$message,
+          options = _objectWithoutProperties(_this$options$message, _excluded5);
+
+    if (!enabled) return;
+    const schemas = await readSchemas({
+      schemaDir: contract.dir
+    });
+    const files = await generateMessageComposer(contract.name, schemas, this.outPath, options);
+    [].push.apply(this.files, files);
+  }
+
+  async build() {
+    const contracts = this.getContracts();
+
+    for (let c = 0; c < contracts.length; c++) {
+      const contract = contracts[c];
+      await this.renderTypes(contract);
+      await this.renderClient(contract);
+      await this.renderMessageComposer(contract);
+      await this.renderReactQuery(contract);
+      await this.renderRecoil(contract);
+    }
+
+    if (this.options.bundle.enabled) {
+      this.bundle();
+    }
+  }
+
+  async bundle() {
+    const allFiles = this.files;
+    const bundleFile = this.options.bundle.bundleFile;
+    const bundleVariables = {};
+    const importPaths = [];
+    allFiles.forEach(file => {
+      createFileBundle(`${this.options.bundle.scope}.${file.contract}`, file.localname, bundleFile, importPaths, bundleVariables);
+    });
+    const ast = recursiveModuleBundle(bundleVariables);
+    const code = generate(t.program([...importPaths, ...ast])).code;
+    mkdirp(this.outPath);
+    writeFileSync(join(this.outPath, bundleFile), header + code);
+  }
+
+}

package/module/builder/index.js

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

package/module/bundler/bundler.js

@@ -0,0 +1,36 @@
+import * as t from '@babel/types';
+import * as dotty from 'dotty';
+import { relative, dirname, extname } from 'path';
+export const recursiveModuleBundle = obj => {
+  return Object.keys(obj).map(key => {
+    if (obj[key]?.__export) {
+      // e.g. abci
+      // 1. create variable for abci
+      // 2. splat ALL _0, parms into abci
+      // 3. export that variable
+      const nmspc = t.variableDeclaration('const', [t.variableDeclarator(t.identifier(key), t.objectExpression(Object.keys(obj[key]).filter(a => a !== '__export').filter(a => a.startsWith('_')).map(a => t.spreadElement(t.identifier(a)))))]);
+      const others = Object.keys(obj[key]).filter(a => a !== '__export').filter(a => !a.startsWith('_'));
+
+      if (others.length) {
+        throw new Error('namespace and package not supported, yet.');
+      } // return nmspc;
+
+
+      return t.exportNamedDeclaration(nmspc, []);
+    } else {
+      // you can make a namespace for obj[key]
+      // e.g. libs
+      return t.exportNamedDeclaration(t.tsModuleDeclaration(t.identifier(key), t.tsModuleBlock(recursiveModuleBundle(obj[key]))));
+    }
+  });
+};
+export const importNamespace = (ident, path) => t.importDeclaration([t.importNamespaceSpecifier(t.identifier(ident))], t.stringLiteral(path.replace(extname(path), '')));
+let counter = 0;
+export const createFileBundle = (pkg, filename, bundleFile, importPaths, bundleVariables) => {
+  let rel = relative(dirname(bundleFile), filename);
+  if (!rel.startsWith('.')) rel = `./${rel}`;
+  const variable = `_${counter++}`;
+  importPaths.push(importNamespace(variable, rel));
+  dotty.put(bundleVariables, pkg + '.__export', true);
+  dotty.put(bundleVariables, pkg + '.' + variable, true);
+};

package/module/bundler/index.js

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

package/module/cmds.js

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