wasm-ast-types 0.9.0 → 0.11.0

package/main/utils/types.js

@@ -7,9 +7,11 @@ var _typeof3 = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getParamsTypeAnnotation = exports.createTypedObjectParams = void 0;
+exports.getParamsTypeAnnotation = exports.detectType = exports.createTypedObjectParams = void 0;
 exports.getPropertySignatureFromProp = getPropertySignatureFromProp;
-exports.getTypeFromRef = exports.getType = exports.getPropertyType = void 0;
+exports.getPropertyType = void 0;
+exports.getResponseType = getResponseType;
+exports.getTypeInfo = exports.getTypeFromRef = exports.getType = void 0;
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
@@ -27,6 +29,16 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(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; }
 
+function getResponseType(context, underscoreName) {
+  var _context$contract$res, _context$contract, _context$contract$res2, _context$contract$res3;
+
+  var methodName = (0, _case.camel)(underscoreName);
+  return (0, _case.pascal)((_context$contract$res = (_context$contract = context.contract) === null || _context$contract === void 0 ? void 0 : (_context$contract$res2 = _context$contract.responses) === null || _context$contract$res2 === void 0 ? void 0 : (_context$contract$res3 = _context$contract$res2[underscoreName]) === null || _context$contract$res3 === void 0 ? void 0 : _context$contract$res3.title) !== null && _context$contract$res !== void 0 ? _context$contract$res : // after v1.1 is adopted, we can deprecate this and require the above response
+  "".concat(methodName, "Response"));
+}
+
+;
+
 var getTypeStrFromRef = function getTypeStrFromRef($ref) {
   if ($ref !== null && $ref !== void 0 && $ref.startsWith('#/definitions/')) {
     return $ref.replace('#/definitions/', '');
@@ -58,7 +70,9 @@ var getTypeOrRef = function getTypeOrRef(obj) {
 };
 
 var getArrayTypeFromItems = function getArrayTypeFromItems(items) {
-  if (items.type === 'array') {
+  var detect = detectType(items.type);
+
+  if (detect.type === 'array') {
     if (Array.isArray(items.items)) {
       return t.tsArrayType(t.tsArrayType(getTypeOrRef(items.items[0])));
     } else {
@@ -66,42 +80,43 @@ var getArrayTypeFromItems = function getArrayTypeFromItems(items) {
     }
   }
 
-  return t.tsArrayType(getType(items.type));
+  return t.tsArrayType(getType(detect.type));
 };
 
-var getType = function getType(type) {
-  switch (type) {
-    case 'string':
-      return t.tsStringKeyword();
-
-    case 'boolean':
-      return t.tSBooleanKeyword();
+var detectType = function detectType(type) {
+  var optional = false;
+  var theType = '';
 
-    case 'integer':
-      return t.tsNumberKeyword();
+  if (Array.isArray(type)) {
+    if (type.length !== 2) {
+      throw new Error('[getType(array length)] case not handled by transpiler. contact maintainers.');
+    }
 
-    default:
-      throw new Error('contact maintainers [unknown type]: ' + type);
-  }
-};
+    var _type = (0, _slicedToArray2["default"])(type, 2),
+        nullableType = _type[0],
+        nullType = _type[1];
 
-exports.getType = getType;
+    if (nullType !== 'null') {
+      throw new Error('[getType(null)] case not handled by transpiler. contact maintainers.');
+    }
 
-var getPropertyType = function getPropertyType(context, schema, prop) {
-  var _schema$properties, _schema$required, _schema$required2;
+    theType = nullableType;
+    optional = true;
+  } else {
+    theType = type;
+  }
 
-  var props = (_schema$properties = schema.properties) !== null && _schema$properties !== void 0 ? _schema$properties : {};
-  var info = props[prop];
-  var type = null;
-  var optional = !((_schema$required = schema.required) !== null && _schema$required !== void 0 && _schema$required.includes(prop));
+  return {
+    type: theType,
+    optional: optional
+  };
+};
 
-  if (info.allOf && info.allOf.length === 1) {
-    info = info.allOf[0];
-  }
+exports.detectType = detectType;
 
-  if (typeof info.$ref === 'string') {
-    type = getTypeFromRef(info.$ref);
-  }
+var getTypeInfo = function getTypeInfo(info) {
+  var type = undefined;
+  var optional = undefined;
 
   if (Array.isArray(info.anyOf)) {
     // assuming 2nd is null, but let's check to ensure
@@ -146,7 +161,9 @@ var getPropertyType = function getPropertyType(context, schema, prop) {
         throw new Error('[info.items] case not handled by transpiler. contact maintainers.');
       }
     } else {
-      type = getType(info.type);
+      var detect = detectType(info.type);
+      type = getType(detect.type);
+      optional = detect.optional;
     }
   }
 
@@ -165,7 +182,16 @@ var getPropertyType = function getPropertyType(context, schema, prop) {
     }
 
     if (_nullableType === 'array' && (0, _typeof2["default"])(info.items) === 'object' && !Array.isArray(info.items)) {
-      type = t.tsArrayType(getType(info.items.type));
+      var _detect = detectType(info.items.type);
+
+      if (_detect.type === 'array') {
+        // wen recursion?
+        type = t.tsArrayType(getArrayTypeFromItems(info.items));
+      } else {
+        type = t.tsArrayType(getType(_detect.type));
+      }
+
+      optional = _detect.optional;
     } else {
       type = getType(_nullableType);
     }
@@ -173,6 +199,58 @@ var getPropertyType = function getPropertyType(context, schema, prop) {
     optional = true;
   }
 
+  return {
+    type: type,
+    optional: optional
+  };
+};
+
+exports.getTypeInfo = getTypeInfo;
+
+var getType = function getType(type) {
+  switch (type) {
+    case 'string':
+      return t.tsStringKeyword();
+
+    case 'boolean':
+      return t.tSBooleanKeyword();
+
+    case 'integer':
+      return t.tsNumberKeyword();
+
+    default:
+      throw new Error('contact maintainers [unknown type]: ' + type);
+  }
+};
+
+exports.getType = getType;
+
+var getPropertyType = function getPropertyType(context, schema, prop) {
+  var _schema$properties, _schema$required, _schema$required2;
+
+  var props = (_schema$properties = schema.properties) !== null && _schema$properties !== void 0 ? _schema$properties : {};
+  var info = props[prop];
+  var type = null;
+  var optional = !((_schema$required = schema.required) !== null && _schema$required !== void 0 && _schema$required.includes(prop));
+
+  if (info.allOf && info.allOf.length === 1) {
+    info = info.allOf[0];
+  }
+
+  if (typeof info.$ref === 'string') {
+    type = getTypeFromRef(info.$ref);
+  }
+
+  var typeInfo = getTypeInfo(info);
+
+  if (typeof typeInfo.optional !== 'undefined') {
+    optional = typeInfo.optional;
+  }
+
+  if (typeof typeInfo.type !== 'undefined') {
+    type = typeInfo.type;
+  }
+
   if (!type) {
     throw new Error('cannot find type for ' + JSON.stringify(info));
   }

package/module/client/client.js

@@ -1,14 +1,14 @@
 import * as t from '@babel/types';
-import { camel, pascal } from 'case';
+import { camel } from 'case';
 import { bindMethod, typedIdentifier, promiseTypeAnnotation, classDeclaration, classProperty, arrowFunctionExpression, getMessageProperties } from '../utils';
-import { getPropertyType, getType, createTypedObjectParams } from '../utils/types';
+import { getPropertyType, getType, createTypedObjectParams, getResponseType } from '../utils/types';
 import { identifier, propertySignature } from '../utils/babel';
 export const CONSTANT_EXEC_PARAMS = [t.assignmentPattern(identifier('fee', t.tsTypeAnnotation(t.tsUnionType([t.tSNumberKeyword(), t.tsTypeReference(t.identifier('StdFee')), t.tsLiteralType(t.stringLiteral('auto'))])), false), t.stringLiteral('auto')), identifier('memo', t.tsTypeAnnotation(t.tsStringKeyword()), true), identifier('funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true)];
 export const FIXED_EXECUTE_PARAMS = [identifier('fee', t.tsTypeAnnotation(t.tsUnionType([t.tsNumberKeyword(), t.tsTypeReference(t.identifier('StdFee')), t.tsLiteralType(t.stringLiteral('auto'))])), true), identifier('memo', t.tsTypeAnnotation(t.tsStringKeyword()), true), identifier('funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true)];
 export const createWasmQueryMethod = (context, jsonschema) => {
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const responseType = pascal(`${methodName}Response`);
+  const responseType = getResponseType(context, underscoreName);
   const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
   const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
   const actionArg = t.objectProperty(t.identifier(underscoreName), t.objectExpression(args));
@@ -113,7 +113,7 @@ export const createQueryInterface = (context, className, queryMsg) => {
   const methods = getMessageProperties(queryMsg).map(jsonschema => {
     const underscoreName = Object.keys(jsonschema.properties)[0];
     const methodName = camel(underscoreName);
-    const responseType = pascal(`${methodName}Response`);
+    const responseType = getResponseType(context, underscoreName);
     return createPropertyFunctionWithObjectParams(context, methodName, responseType, jsonschema.properties[underscoreName]);
   });
   return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(className), null, [], t.tSInterfaceBody([t.tSPropertySignature(t.identifier('contractAddress'), t.tsTypeAnnotation(t.tsStringKeyword())), ...methods])));

package/module/client/test/ts-client.arrays-ref.spec.js

@@ -1,8 +1,7 @@
 import message from '../../../../../__fixtures__/misc/schema/arrays-ref.json';
 import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
-import { RenderContext } from '../../context';
-import { expectCode } from '../../../test-utils';
-const ctx = new RenderContext(message);
+import { expectCode, makeContext } from '../../../test-utils';
+const ctx = makeContext(message);
 it('execute_msg_for__empty', () => {
   expectCode(createTypeInterface(ctx, message));
 });

package/module/client/test/ts-client.arrays.spec.js

@@ -1,8 +1,12 @@
 import message from '../../../../../__fixtures__/misc/schema/arrays.json';
 import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
-import { RenderContext } from '../../context';
-import { expectCode } from '../../../test-utils';
-const ctx = new RenderContext(message);
+import { expectCode, makeContext } from '../../../test-utils';
+import { getPropertyType } from '../../utils';
+const ctx = makeContext(message);
+it('getPropertyType', () => {
+  const ast = getPropertyType(ctx, message.oneOf[0].properties.update_edges, 'edges3');
+  expectCode(ast.type); // printCode(ast.type)
+});
 it('execute_msg_for__empty', () => {
   expectCode(createTypeInterface(ctx, message));
 });

package/module/client/test/ts-client.cw-named-groups.test.js

@@ -1,8 +1,7 @@
 import execute_msg from '../../../../../__fixtures__/daodao/cw-named-groups/execute_msg.json';
 import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
-import { RenderContext } from '../../context';
-import { expectCode } from '../../../test-utils';
-const ctx = new RenderContext(execute_msg);
+import { expectCode, makeContext } from '../../../test-utils';
+const ctx = makeContext(execute_msg);
 it('execute_msg', () => {
   expectCode(createTypeInterface(ctx, execute_msg));
 });

package/module/client/test/ts-client.cw-proposal-single.test.js

@@ -1,21 +1,20 @@
 import execute_msg from '../../../../../__fixtures__/daodao/cw-proposal-single/execute_msg.json';
 import query_msg from '../../../../../__fixtures__/daodao/cw-proposal-single/query_msg.json';
 import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
-import { RenderContext } from '../../context';
-import { expectCode } from '../../../test-utils';
+import { expectCode, makeContext } from '../../../test-utils';
 it('execute_msg_for', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createTypeInterface(ctx, execute_msg));
 });
 it('query classes', () => {
-  const ctx = new RenderContext(query_msg);
+  const ctx = makeContext(query_msg);
   expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', query_msg));
 });
 it('execute classes array types', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', null, execute_msg));
 });
 it('execute interfaces no extends', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createExecuteInterface(ctx, 'SG721Instance', null, execute_msg));
 });

package/module/client/test/ts-client.empty-enums.spec.js

@@ -1,8 +1,7 @@
 import query_msg from '../../../../../__fixtures__/daodao/cw-admin-factory/query_msg.json';
 import { createQueryClass, createQueryInterface } from '../client';
-import { RenderContext } from '../../context';
-import { expectCode } from '../../../test-utils';
-const ctx = new RenderContext(query_msg);
+import { expectCode, makeContext } from '../../../test-utils';
+const ctx = makeContext(query_msg);
 it('query classes', () => {
   expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', query_msg));
 });

package/module/client/test/ts-client.issues.test.js

@@ -1,22 +1,21 @@
-import { globContracts } from '../../../test-utils';
+import { globContracts, makeContext } from '../../../test-utils';
 import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
-import { RenderContext } from '../../context';
 import { expectCode } from '../../../test-utils';
 import cases from 'jest-in-case';
 const contracts = globContracts('issues/55');
 cases('execute_msg_for__empty', async opts => {
-  const ctx = new RenderContext(opts.content);
+  const ctx = makeContext(opts.content);
   expectCode(createTypeInterface(ctx, opts.content));
 }, contracts);
 cases('query classes', async opts => {
-  const ctx = new RenderContext(opts.content);
+  const ctx = makeContext(opts.content);
   expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', opts.content));
 }, contracts);
 cases('execute class', async opts => {
-  const ctx = new RenderContext(opts.content);
+  const ctx = makeContext(opts.content);
   expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', null, opts.content));
 }, contracts);
 cases('execute interface', async opts => {
-  const ctx = new RenderContext(opts.content);
+  const ctx = makeContext(opts.content);
   expectCode(createExecuteInterface(ctx, 'SG721Instance', null, opts.content));
 }, contracts);

package/module/client/test/ts-client.sg721.spec.js

@@ -1,8 +1,7 @@
 import execute_msg_for__empty from '../../../../../__fixtures__/sg721/execute_msg_for__empty.json';
 import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
-import { RenderContext } from '../../context';
-import { expectCode } from '../../../test-utils';
-const ctx = new RenderContext(execute_msg_for__empty);
+import { expectCode, makeContext } from '../../../test-utils';
+const ctx = makeContext(execute_msg_for__empty);
 it('execute_msg_for__empty', () => {
   expectCode(createTypeInterface(ctx, execute_msg_for__empty));
 });

package/module/client/test/ts-client.spec.js

@@ -13,73 +13,72 @@ import operators_response from '../../../../../__fixtures__/basic/operators_resp
 import owner_of_response from '../../../../../__fixtures__/basic/owner_of_response.json';
 import tokens_response from '../../../../../__fixtures__/basic/tokens_response.json';
 import { createQueryClass, createQueryInterface, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
-import { RenderContext } from '../../context';
-import { expectCode } from '../../../test-utils';
+import { expectCode, makeContext } from '../../../test-utils';
 it('approval_response', () => {
-  const ctx = new RenderContext(approval_response);
+  const ctx = makeContext(approval_response);
   expectCode(createTypeInterface(ctx, approval_response));
 });
 it('all_nft_info_response', () => {
-  const ctx = new RenderContext(all_nft_info_response);
+  const ctx = makeContext(all_nft_info_response);
   expectCode(createTypeInterface(ctx, all_nft_info_response));
 });
 it('approvals_response', () => {
-  const ctx = new RenderContext(approvals_response);
+  const ctx = makeContext(approvals_response);
   expectCode(createTypeInterface(ctx, approvals_response));
 });
 it('collection_info_response', () => {
-  const ctx = new RenderContext(collection_info_response);
+  const ctx = makeContext(collection_info_response);
   expectCode(createTypeInterface(ctx, collection_info_response));
 });
 it('contract_info_response', () => {
-  const ctx = new RenderContext(contract_info_response);
+  const ctx = makeContext(contract_info_response);
   expectCode(createTypeInterface(ctx, contract_info_response));
 });
 it('instantiate_msg', () => {
-  const ctx = new RenderContext(instantiate_msg);
+  const ctx = makeContext(instantiate_msg);
   expectCode(createTypeInterface(ctx, instantiate_msg));
 });
 it('nft_info_response', () => {
-  const ctx = new RenderContext(nft_info_response);
+  const ctx = makeContext(nft_info_response);
   expectCode(createTypeInterface(ctx, nft_info_response));
 });
 it('num_tokens_response', () => {
-  const ctx = new RenderContext(num_tokens_response);
+  const ctx = makeContext(num_tokens_response);
   expectCode(createTypeInterface(ctx, num_tokens_response));
 });
 it('operators_response', () => {
-  const ctx = new RenderContext(operators_response);
+  const ctx = makeContext(operators_response);
   expectCode(createTypeInterface(ctx, operators_response));
 });
 it('owner_of_response', () => {
-  const ctx = new RenderContext(owner_of_response);
+  const ctx = makeContext(owner_of_response);
   expectCode(createTypeInterface(ctx, owner_of_response));
 });
 it('tokens_response', () => {
-  const ctx = new RenderContext(tokens_response);
+  const ctx = makeContext(tokens_response);
   expectCode(createTypeInterface(ctx, tokens_response));
 });
 it('query classes', () => {
-  const ctx = new RenderContext(query_msg);
+  const ctx = makeContext(query_msg);
   expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', query_msg));
 });
 it('execute classes', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', 'SG721QueryClient', execute_msg));
 });
 it('execute classes no extends', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', null, execute_msg));
 });
 it('execute classes array types', () => {
-  const ctx = new RenderContext(execute_msg_named_groups);
+  const ctx = makeContext(execute_msg_named_groups);
   expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', null, execute_msg_named_groups));
 });
 it('execute interfaces no extends', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createExecuteInterface(ctx, 'SG721Instance', null, execute_msg));
 });
 it('query interfaces', () => {
-  const ctx = new RenderContext(query_msg);
+  const ctx = makeContext(query_msg);
   expectCode(createQueryInterface(ctx, 'SG721ReadOnlyInstance', query_msg));
 });

package/module/client/test/ts-client.vectis.spec.js

@@ -4,41 +4,40 @@ import can_execute_relay_response from '../../../../../__fixtures__/vectis/govec
 import info_response from '../../../../../__fixtures__/vectis/govec/info_response.json';
 import relay_transaction from '../../../../../__fixtures__/vectis/govec/relay_transaction.json';
 import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
-import { RenderContext } from '../../context';
-import { expectCode } from '../../../test-utils';
+import { expectCode, makeContext } from '../../../test-utils';
 it('cosmos_msg_for__empty', () => {
-  const ctx = new RenderContext(cosmos_msg_for__empty);
+  const ctx = makeContext(cosmos_msg_for__empty);
   expectCode(createTypeInterface(ctx, cosmos_msg_for__empty));
 });
 it('execute_msg_for__empty', () => {
-  const ctx = new RenderContext(execute_msg_for__empty);
+  const ctx = makeContext(execute_msg_for__empty);
   expectCode(createTypeInterface(ctx, execute_msg_for__empty));
 });
 it('can_execute_relay_response', () => {
-  const ctx = new RenderContext(can_execute_relay_response);
+  const ctx = makeContext(can_execute_relay_response);
   expectCode(createTypeInterface(ctx, can_execute_relay_response));
 });
 it('info_response', () => {
-  const ctx = new RenderContext(info_response);
+  const ctx = makeContext(info_response);
   expectCode(createTypeInterface(ctx, info_response));
 });
 it('relay_transaction', () => {
-  const ctx = new RenderContext(relay_transaction);
+  const ctx = makeContext(relay_transaction);
   expectCode(createTypeInterface(ctx, relay_transaction));
 });
 it('query classes', () => {
-  const ctx = new RenderContext(cosmos_msg_for__empty);
+  const ctx = makeContext(cosmos_msg_for__empty);
   expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', cosmos_msg_for__empty));
 });
 it('query classes', () => {
-  const ctx = new RenderContext(execute_msg_for__empty);
+  const ctx = makeContext(execute_msg_for__empty);
   expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', execute_msg_for__empty));
 });
 it('execute classes array types', () => {
-  const ctx = new RenderContext(execute_msg_for__empty);
+  const ctx = makeContext(execute_msg_for__empty);
   expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', null, execute_msg_for__empty));
 });
 it('execute interfaces no extends', () => {
-  const ctx = new RenderContext(execute_msg_for__empty);
+  const ctx = makeContext(execute_msg_for__empty);
   expectCode(createExecuteInterface(ctx, 'SG721Instance', null, execute_msg_for__empty));
 });

package/module/context/context.js

@@ -1,7 +1,13 @@
 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 { convertUtilsToImportList, getImportStatements } from "./imports";
 import deepmerge from "deepmerge"; /// Plugin Types
 
+;
 export const defaultOptions = {
   types: {
     enabled: true,
@@ -25,13 +31,27 @@ export const defaultOptions = {
     queryKeys: false
   }
 };
+export const getDefinitionSchema = schemas => {
+  const aggregateSchema = {
+    definitions: {//
+    }
+  };
+  schemas.forEach(schema => {
+    schema.definitions = schema.definitions || {};
+    aggregateSchema.definitions = _objectSpread(_objectSpread({}, aggregateSchema.definitions), schema.definitions);
+  });
+  return aggregateSchema;
+};
 export class RenderContext {
-  constructor(schema, options) {
-    _defineProperty(this, "schema", void 0);
+  constructor(contract, options) {
+    _defineProperty(this, "contract", void 0);
 
     _defineProperty(this, "utils", []);
 
-    this.schema = schema;
+    _defineProperty(this, "schema", void 0);
+
+    this.contract = contract;
+    this.schema = getDefinitionSchema(contract.schemas);
     this.options = deepmerge(defaultOptions, options ?? {});
   }
 

package/module/message-composer/message-composer.spec.js

@@ -1,12 +1,11 @@
 import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
 import { createMessageComposerClass, createMessageComposerInterface } from './message-composer';
-import { RenderContext } from '../context';
-import { expectCode } from '../../test-utils';
+import { expectCode, makeContext } from '../../test-utils';
 it('execute classes', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createMessageComposerClass(ctx, 'SG721MessageComposer', 'SG721Message', execute_msg));
 });
 it('createMessageComposerInterface', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createMessageComposerInterface(ctx, 'SG721Message', execute_msg));
 });

package/module/react-query/react-query.js

@@ -2,7 +2,7 @@ import * as t from '@babel/types';
 import { camel, pascal } from 'case';
 import { callExpression, getMessageProperties, identifier, tsObjectPattern, tsPropertySignature } from '../utils';
 import { omitTypeReference, optionalConditionalExpression, propertySignature, shorthandProperty } from '../utils/babel';
-import { getParamsTypeAnnotation, getPropertyType } from '../utils/types';
+import { getParamsTypeAnnotation, getPropertyType, getResponseType } from '../utils/types';
 import { FIXED_EXECUTE_PARAMS } from '../client';
 export const createReactQueryHooks = ({
   context,
@@ -40,7 +40,7 @@ export const createReactQueryHooks = ({
 
     const hookName = `use${hookParamsTypeName}`; // listVotersResponse
 
-    const responseType = pascal(`${methodName}Response`); // cw3FlexMultisigListVoters
+    const responseType = getResponseType(context, underscoreName); // cw3FlexMultisigListVoters
 
     const getterKey = camel(`${contractName}${pascal(methodName)}`);
     const jsonschema = schema.properties[underscoreName];

package/module/react-query/react-query.spec.js

@@ -1,11 +1,10 @@
 import * as t from '@babel/types';
 import query_msg from '../../../../__fixtures__/basic/query_msg.json';
 import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
-import { RenderContext } from '../context';
 import { createReactQueryHooks, createReactQueryMutationHooks } from './react-query';
-import { expectCode } from '../../test-utils';
-const execCtx = new RenderContext(execute_msg);
-const queryCtx = new RenderContext(query_msg);
+import { expectCode, makeContext } from '../../test-utils';
+const execCtx = makeContext(execute_msg);
+const queryCtx = makeContext(query_msg);
 it('createReactQueryHooks', () => {
   expectCode(t.program(createReactQueryHooks({
     context: queryCtx,
@@ -14,7 +13,7 @@ it('createReactQueryHooks', () => {
     QueryClient: 'Sg721QueryClient'
   })));
   expectCode(t.program(createReactQueryHooks({
-    context: new RenderContext(query_msg, {
+    context: makeContext(query_msg, {
       reactQuery: {
         optionalClient: true
       }
@@ -24,7 +23,7 @@ it('createReactQueryHooks', () => {
     QueryClient: 'Sg721QueryClient'
   })));
   expectCode(t.program(createReactQueryHooks({
-    context: new RenderContext(query_msg, {
+    context: makeContext(query_msg, {
       reactQuery: {
         version: 'v4'
       }
@@ -34,7 +33,7 @@ it('createReactQueryHooks', () => {
     QueryClient: 'Sg721QueryClient'
   })));
   expectCode(t.program(createReactQueryHooks({
-    context: new RenderContext(query_msg, {
+    context: makeContext(query_msg, {
       reactQuery: {
         optionalClient: true,
         version: 'v4'

package/module/recoil/recoil.js

@@ -1,10 +1,9 @@
 import * as t from '@babel/types';
 import { camel, pascal } from 'case';
-import { callExpression, getMessageProperties } from '../utils';
-export const createRecoilSelector = (context, keyPrefix, QueryClient, methodName) => {
+import { callExpression, getMessageProperties, getResponseType } from '../utils';
+export const createRecoilSelector = (context, keyPrefix, QueryClient, methodName, responseType) => {
   context.addUtil('selectorFamily');
   const selectorName = camel(`${methodName}Selector`);
-  const responseType = pascal(`${methodName}Response`);
   const getterKey = camel(`${keyPrefix}${pascal(methodName)}`);
   return t.exportNamedDeclaration(t.variableDeclaration('const', [t.variableDeclarator(t.identifier(selectorName), callExpression(t.identifier('selectorFamily'), [t.objectExpression([t.objectProperty(t.identifier('key'), t.stringLiteral(getterKey)), t.objectProperty(t.identifier('get'), t.arrowFunctionExpression([t.objectPattern([t.objectProperty(t.identifier('params'), t.identifier('params'), false, true), t.restElement(t.identifier('queryClientParams'))])], t.arrowFunctionExpression([t.objectPattern([t.objectProperty(t.identifier('get'), t.identifier('get'), false, true)])], t.blockStatement([t.variableDeclaration('const', [t.variableDeclarator(t.identifier('client'), t.callExpression(t.identifier('get'), [t.callExpression(t.identifier('queryClient'), [t.identifier('queryClientParams')])]))]), t.returnStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('client'), t.identifier(methodName)), [t.spreadElement(t.identifier('params'))])))]), true)))])], t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(responseType)), t.tsIntersectionType([t.tsTypeReference(t.identifier('QueryClientParams')), t.tsTypeLiteral([t.tsPropertySignature(t.identifier('params'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Parameters'), t.tsTypeParameterInstantiation([t.tsIndexedAccessType(t.tsTypeReference(t.identifier(QueryClient)), t.tsLiteralType(t.stringLiteral(methodName)))]))))])])])))]));
 };
@@ -12,7 +11,8 @@ export const createRecoilSelectors = (context, keyPrefix, QueryClient, queryMsg)
   return getMessageProperties(queryMsg).map(schema => {
     const underscoreName = Object.keys(schema.properties)[0];
     const methodName = camel(underscoreName);
-    return createRecoilSelector(context, keyPrefix, QueryClient, methodName);
+    const responseType = getResponseType(context, underscoreName);
+    return createRecoilSelector(context, keyPrefix, QueryClient, methodName, responseType);
   });
 };
 export const createRecoilQueryClientType = () => ({