@cosmwasm/ts-codegen 0.6.1 → 0.7.2

package/main/{generate.js → generators/ts-client.js}

@@ -15,7 +15,7 @@ var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/
 
 var _case = require("case");
 
-var _header = require("./header");
+var _header = require("../utils/header");
 
 var _path = require("path");
 
@@ -29,11 +29,11 @@ var _fs = require("fs");
 
 var _generator = _interopRequireDefault(require("@babel/generator"));
 
-var _clean = require("./clean");
+var _clean = require("../utils/clean");
 
-var _utils = require("./utils");
+var _utils = require("../utils");
 
-var _imports = require("./imports");
+var _imports = require("../utils/imports");
 
 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); }
 
@@ -41,7 +41,7 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 var _default = /*#__PURE__*/function () {
   var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(name, schemas, outPath) {
-    var Contract, QueryMsg, ExecuteMsg, typeHash, Client, Instance, QueryClient, ReadOnlyInstance, body, children, code;
+    var Contract, QueryMsg, ExecuteMsg, typeHash, Client, Instance, QueryClient, ReadOnlyInstance, body, context, children, code;
     return _regenerator["default"].wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
@@ -66,13 +66,14 @@ var _default = /*#__PURE__*/function () {
               body.push((0, _clean.clean)(type));
             }); // alias the ExecuteMsg
 
-            ExecuteMsg && body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier("".concat(name, "ExecuteMsg")), null, t.tsTypeReference(t.identifier('ExecuteMsg'))))); // query messages
+            ExecuteMsg && body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier("".concat(name, "ExecuteMsg")), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+            context = new w.RenderContext((0, _utils.getDefinitionSchema)(schemas)); // query messages
 
             if (QueryMsg) {
               QueryClient = (0, _case.pascal)("".concat(name, "QueryClient"));
               ReadOnlyInstance = (0, _case.pascal)("".concat(name, "ReadOnlyInterface"));
-              body.push(w.createQueryInterface(ReadOnlyInstance, QueryMsg));
-              body.push(w.createQueryClass(QueryClient, ReadOnlyInstance, QueryMsg));
+              body.push(w.createQueryInterface(context, ReadOnlyInstance, QueryMsg));
+              body.push(w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg));
             } // execute messages
 
 
@@ -82,8 +83,8 @@ var _default = /*#__PURE__*/function () {
               if (children.length > 0) {
                 Client = (0, _case.pascal)("".concat(name, "Client"));
                 Instance = (0, _case.pascal)("".concat(name, "Interface"));
-                body.push(w.createExecuteInterface(Instance, ReadOnlyInstance, ExecuteMsg));
-                body.push(w.createExecuteClass(Client, Instance, QueryClient, ExecuteMsg));
+                body.push(w.createExecuteInterface(context, Instance, ReadOnlyInstance, ExecuteMsg));
+                body.push(w.createExecuteClass(context, Client, Instance, QueryClient, ExecuteMsg));
               }
             }
 
@@ -91,7 +92,7 @@ var _default = /*#__PURE__*/function () {
             (0, _mkdirp.sync)(outPath);
             (0, _fs.writeFileSync)((0, _path.join)(outPath, Contract), code);
 
-          case 20:
+          case 21:
           case "end":
             return _context.stop();
         }

package/main/index.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
-  generate: true,
+  tsClient: true,
   fromPartial: true,
   reactQuery: true,
   recoil: true
@@ -17,12 +17,6 @@ Object.defineProperty(exports, "fromPartial", {
     return _fromPartial["default"];
   }
 });
-Object.defineProperty(exports, "generate", {
-  enumerable: true,
-  get: function get() {
-    return _generate["default"];
-  }
-});
 Object.defineProperty(exports, "reactQuery", {
   enumerable: true,
   get: function get() {
@@ -35,14 +29,20 @@ Object.defineProperty(exports, "recoil", {
     return _recoil["default"];
   }
 });
+Object.defineProperty(exports, "tsClient", {
+  enumerable: true,
+  get: function get() {
+    return _tsClient["default"];
+  }
+});
 
-var _generate = _interopRequireDefault(require("./generate"));
+var _tsClient = _interopRequireDefault(require("./generators/ts-client"));
 
-var _fromPartial = _interopRequireDefault(require("./from-partial"));
+var _fromPartial = _interopRequireDefault(require("./generators/from-partial"));
 
-var _reactQuery = _interopRequireDefault(require("./react-query"));
+var _reactQuery = _interopRequireDefault(require("./generators/react-query"));
 
-var _recoil = _interopRequireDefault(require("./recoil"));
+var _recoil = _interopRequireDefault(require("./generators/recoil"));
 
 var _utils = require("./utils");
 
@@ -58,7 +58,7 @@ Object.keys(_utils).forEach(function (key) {
   });
 });
 
-var _imports = require("./imports");
+var _imports = require("./utils/imports");
 
 Object.keys(_imports).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/main/{header.js → utils/header.js}

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.header = void 0;
 
-var _package = _interopRequireDefault(require("../package.json"));
+var _package = _interopRequireDefault(require("../../package.json"));
 
 var version = process.env.NODE_ENV === 'test' ? 'latest' : _package["default"].version;
 var header = "/**\n* This file was automatically generated by ".concat(_package["default"].name, "@").concat(version, ".\n* DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,\n* and run the ").concat(_package["default"].name, " generate command to regenerate this file.\n*/\n\n");

package/main/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _schemas = require("./schemas");
+
+Object.keys(_schemas).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _schemas[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _schemas[key];
+    }
+  });
+});

package/main/utils/schemas.js

@@ -0,0 +1,167 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readSchemas = exports.getDefinitionSchema = exports.findQueryMsg = exports.findExecuteMsg = exports.findAndParseTypes = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+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");
+
+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) { (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;
+
+    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;
+            fn = clean ? _cleanse.cleanse : function (str) {
+              return str;
+            };
+            files = (0, _glob.sync)(schemaDir + '/**/*.json');
+            schemas = files.map(function (file) {
+              return JSON.parse((0, _fs.readFileSync)(file, 'utf-8'));
+            });
+
+            if (!argv.packed) {
+              _context.next = 8;
+              break;
+            }
+
+            if (!(schemas.length !== 1)) {
+              _context.next = 7;
+              break;
+            }
+
+            throw new Error('packed option only supports one file');
+
+          case 7:
+            return _context.abrupt("return", Object.values(fn(schemas[0])));
+
+          case 8:
+            return _context.abrupt("return", fn(schemas));
+
+          case 9:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function readSchemas(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+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 _ref3 = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(schemas) {
+    var Types, allTypes, typ, _i, _Object$keys, key, result, typeHash;
+
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            Types = schemas;
+            allTypes = [];
+            _context2.t0 = _regenerator["default"].keys(Types);
+
+          case 3:
+            if ((_context2.t1 = _context2.t0()).done) {
+              _context2.next = 12;
+              break;
+            }
+
+            typ = _context2.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;
+              }
+            }
+
+            _context2.next = 8;
+            return (0, _jsonSchemaToTypescript.compile)(Types[typ], Types[typ].title);
+
+          case 8:
+            result = _context2.sent;
+            allTypes.push(result);
+            _context2.next = 3;
+            break;
+
+          case 12:
+            typeHash = (0, _parse.parser)(allTypes);
+            return _context2.abrupt("return", typeHash);
+
+          case 14:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function findAndParseTypes(_x2) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+exports.findAndParseTypes = findAndParseTypes;
+
+var getDefinitionSchema = function getDefinitionSchema(schemas) {
+  var aggregateSchema = {
+    definitions: {//
+    }
+  };
+  schemas.forEach(function (schema) {
+    schema.definitions = schema.definitions || {};
+    aggregateSchema.definitions = _objectSpread(_objectSpread({}, aggregateSchema.definitions), schema.definitions);
+  });
+  return aggregateSchema;
+};
+
+exports.getDefinitionSchema = getDefinitionSchema;

package/module/cli.js

@@ -1,4 +1,4 @@
-import { prompt } from './prompt';
+import { prompt } from './utils/prompt';
 import { Commands as commands } from './cmds';
 const question = [{
   _: true,

package/module/cmds.js

@@ -1,10 +1,8 @@
-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;

package/module/commands/from-partial.js

@@ -1,5 +1,5 @@
-import { prompt } from '../prompt';
-import fromPartial from '../from-partial';
+import { prompt } from '../utils/prompt';
+import fromPartial from '../generators/from-partial';
 import { readSchemas } from '../utils';
 export default (async argv => {
   const questions = [{
@@ -25,7 +25,7 @@ export default (async argv => {
     out,
     name
   } = await prompt(questions, argv);
-  const schemas = readSchemas({
+  const schemas = await readSchemas({
     schemaDir: schema,
     argv
   });

package/module/commands/generate.js

@@ -1,5 +1,5 @@
-import { prompt } from '../prompt';
-import cosmscript from '../generate';
+import { prompt } from '../utils/prompt';
+import tsClient from '../generators/ts-client';
 import { readSchemas } from '../utils';
 export default (async argv => {
   const questions = [{
@@ -25,9 +25,9 @@ export default (async argv => {
     out,
     name
   } = await prompt(questions, argv);
-  const schemas = readSchemas({
+  const schemas = await readSchemas({
     schemaDir: schema,
     argv
   });
-  await cosmscript(name, schemas, out);
+  await tsClient(name, schemas, out);
 });

package/module/commands/react-query.js

@@ -1,7 +1,7 @@
 import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 const _excluded = ["schema", "out", "name"];
-import { prompt } from '../prompt';
-import reactQuery from '../react-query';
+import { prompt } from '../utils/prompt';
+import reactQuery from '../generators/react-query';
 import { readSchemas } from '../utils';
 export default (async argv => {
   const questions = [{
@@ -46,7 +46,7 @@ export default (async argv => {
   } = _await$prompt,
         options = _objectWithoutProperties(_await$prompt, _excluded);
 
-  const schemas = readSchemas({
+  const schemas = await readSchemas({
     schemaDir: schema,
     argv
   });

package/module/commands/recoil.js

@@ -1,5 +1,5 @@
-import { prompt } from '../prompt';
-import recoil from '../recoil';
+import { prompt } from '../utils/prompt';
+import recoil from '../generators/recoil';
 import { readSchemas } from '../utils';
 export default (async argv => {
   const questions = [{
@@ -25,7 +25,7 @@ export default (async argv => {
     out,
     name
   } = await prompt(questions, argv);
-  const schemas = readSchemas({
+  const schemas = await readSchemas({
     schemaDir: schema,
     argv
   });

package/module/file.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { prompt } from './prompt';
+import { prompt } from './utils/prompt';
 import { cli } from './cli';
 import { readFileSync } from 'fs';
 

package/module/{from-partial.js → generators/from-partial.js}

@@ -1,5 +1,5 @@
 import { pascal } from "case";
-import { header } from './header';
+import { header } from '../utils/header';
 import { join } from "path";
 import { sync as mkdirp } from "mkdirp";
 import * as w from 'wasm-ast-types';
@@ -7,7 +7,8 @@ import * as t from '@babel/types';
 import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
 import { getMessageProperties } from "wasm-ast-types";
-import { findAndParseTypes, findExecuteMsg } from "./utils";
+import { findAndParseTypes, findExecuteMsg, getDefinitionSchema } from "../utils";
+import { RenderContext } from "wasm-ast-types";
 export default (async (name, schemas, outPath) => {
   const FromPartialFile = pascal(`${name}Contract`) + '.from-partial.ts';
   const Contract = pascal(`${name}Contract`) + '.ts';
@@ -22,7 +23,8 @@ export default (async (name, schemas, outPath) => {
     body.push(w.importStmt(['Coin'], '@cosmjs/amino'));
   }
 
-  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, ''))); // execute messages
+  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, '')));
+  const context = new RenderContext(getDefinitionSchema(schemas)); // execute messages
 
   if (ExecuteMsg) {
     const children = getMessageProperties(ExecuteMsg);
@@ -30,8 +32,8 @@ export default (async (name, schemas, outPath) => {
     if (children.length > 0) {
       const TheClass = pascal(`${name}MessageComposer`);
       const Interface = pascal(`${name}Message`);
-      body.push(w.createFromPartialInterface(Interface, ExecuteMsg));
-      body.push(w.createFromPartialClass(TheClass, Interface, ExecuteMsg));
+      body.push(w.createFromPartialInterface(context, Interface, ExecuteMsg));
+      body.push(w.createFromPartialClass(context, TheClass, Interface, ExecuteMsg));
     }
   }
 

package/module/{react-query.js → generators/react-query.js}

@@ -1,15 +1,20 @@
 import { pascal } from "case";
-import { header } from './header';
+import { header } from '../utils/header';
 import { join } from "path";
 import { sync as mkdirp } from "mkdirp";
 import * as w from 'wasm-ast-types';
+import { RenderContext } from 'wasm-ast-types';
 import * as t from '@babel/types';
 import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
-import { findAndParseTypes, findExecuteMsg, findQueryMsg } from './utils';
+import { findAndParseTypes, findExecuteMsg, findQueryMsg, getDefinitionSchema } from '../utils';
 import { getMessageProperties } from "wasm-ast-types";
-import { cosmjsAminoImportStatements } from './imports';
-export default (async (contractName, schemas, outPath, options) => {
+import { cosmjsAminoImportStatements } from '../utils/imports';
+export default (async (contractName, schemas, outPath, reactQueryOptions) => {
+  const context = new RenderContext(getDefinitionSchema(schemas), {
+    reactQuery: reactQueryOptions ?? {}
+  });
+  const options = context.options.reactQuery;
   const ReactQueryFile = pascal(`${contractName}Contract`) + '.react-query.ts';
   const Contract = pascal(`${contractName}Contract`);
   const QueryMsg = findQueryMsg(schemas);
@@ -40,19 +45,19 @@ export default (async (contractName, schemas, outPath, options) => {
 
   if (QueryMsg) {
     [].push.apply(body, w.createReactQueryHooks({
+      context,
       queryMsg: QueryMsg,
       contractName: contractName,
-      QueryClient,
-      options
+      QueryClient
     }));
   }
 
   if (shouldGenerateMutationHooks) {
     [].push.apply(body, w.createReactQueryMutationHooks({
+      context,
       execMsg: ExecuteMsg,
       contractName: contractName,
-      ExecuteClient,
-      options
+      ExecuteClient
     }));
   }
 

package/module/{recoil.js → generators/recoil.js}

@@ -1,12 +1,13 @@
 import { pascal } from "case";
-import { header } from './header';
+import { header } from '../utils/header';
 import { join } from "path";
 import { sync as mkdirp } from "mkdirp";
 import * as w from 'wasm-ast-types';
 import * as t from '@babel/types';
 import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
-import { findAndParseTypes, findQueryMsg } from "./utils";
+import { findAndParseTypes, findQueryMsg, getDefinitionSchema } from "../utils";
+import { RenderContext } from "wasm-ast-types";
 export default (async (name, schemas, outPath) => {
   const RecoilFile = pascal(`${name}Contract`) + '.recoil.ts';
   const Contract = pascal(`${name}Contract`) + '.ts';
@@ -17,15 +18,16 @@ export default (async (name, schemas, outPath) => {
   const body = [];
   body.push(w.importStmt(['selectorFamily'], 'recoil'));
   body.push(w.importStmt(['cosmWasmClient'], './chain'));
-  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, ''))); // query messages
+  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, '')));
+  const context = new RenderContext(getDefinitionSchema(schemas)); // query messages
 
   if (QueryMsg) {
     QueryClient = pascal(`${name}QueryClient`);
     ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
     body.push(w.importStmt([QueryClient], `./${Contract}`));
     body.push(w.createRecoilQueryClientType());
-    body.push(w.createRecoilQueryClient(name, QueryClient));
-    [].push.apply(body, w.createRecoilSelectors(name, QueryClient, QueryMsg));
+    body.push(w.createRecoilQueryClient(context, name, QueryClient));
+    [].push.apply(body, w.createRecoilSelectors(context, name, QueryClient, QueryMsg));
   }
 
   const code = header + generate(t.program(body)).code;

package/module/{generate.js → generators/ts-client.js}

@@ -1,15 +1,16 @@
 import { pascal } from "case";
-import { header } from './header';
+import { header } from '../utils/header';
 import { join } from "path";
 import { sync as mkdirp } from "mkdirp";
 import * as w from 'wasm-ast-types';
 import * as t from '@babel/types';
 import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
-import { clean } from "./clean";
+import { clean } from "../utils/clean";
 import { getMessageProperties } from "wasm-ast-types";
-import { findAndParseTypes, findExecuteMsg, findQueryMsg } from './utils';
-import { cosmjsAminoImportStatements } from './imports';
+import { findAndParseTypes, findExecuteMsg, findQueryMsg, getDefinitionSchema } from '../utils';
+import { cosmjsAminoImportStatements } from '../utils/imports';
+import { RenderContext } from "wasm-ast-types";
 export default (async (name, schemas, outPath) => {
   const Contract = pascal(`${name}Contract`) + '.ts';
   const QueryMsg = findQueryMsg(schemas);
@@ -27,13 +28,14 @@ export default (async (name, schemas, outPath) => {
     body.push(clean(type));
   }); // alias the ExecuteMsg
 
-  ExecuteMsg && body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg'))))); // query messages
+  ExecuteMsg && body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+  const context = new RenderContext(getDefinitionSchema(schemas)); // query messages
 
   if (QueryMsg) {
     QueryClient = pascal(`${name}QueryClient`);
     ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
-    body.push(w.createQueryInterface(ReadOnlyInstance, QueryMsg));
-    body.push(w.createQueryClass(QueryClient, ReadOnlyInstance, QueryMsg));
+    body.push(w.createQueryInterface(context, ReadOnlyInstance, QueryMsg));
+    body.push(w.createQueryClass(context, QueryClient, ReadOnlyInstance, QueryMsg));
   } // execute messages
 
 
@@ -43,8 +45,8 @@ export default (async (name, schemas, outPath) => {
     if (children.length > 0) {
       Client = pascal(`${name}Client`);
       Instance = pascal(`${name}Interface`);
-      body.push(w.createExecuteInterface(Instance, ReadOnlyInstance, ExecuteMsg));
-      body.push(w.createExecuteClass(Client, Instance, QueryClient, ExecuteMsg));
+      body.push(w.createExecuteInterface(context, Instance, ReadOnlyInstance, ExecuteMsg));
+      body.push(w.createExecuteClass(context, Client, Instance, QueryClient, ExecuteMsg));
     }
   }
 

package/module/index.js

@@ -1,6 +1,6 @@
-export { default as generate } from './generate';
-export { default as fromPartial } from './from-partial';
-export { default as reactQuery } from './react-query';
-export { default as recoil } from './recoil';
+export { default as tsClient } from './generators/ts-client';
+export { default as fromPartial } from './generators/from-partial';
+export { default as reactQuery } from './generators/react-query';
+export { default as recoil } from './generators/recoil';
 export * from './utils';
-export * from './imports';
+export * from './utils/imports';

package/module/{header.js → utils/header.js}

@@ -1,4 +1,4 @@
-import pkg from '../package.json';
+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}.

package/module/utils/index.js

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