wasm-ast-types 0.5.1 → 0.6.0

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

@@ -0,0 +1,85 @@
+import execute_msg_named_groups from '../../../../../__fixtures__/daodao/cw-named-groups/execute_msg.json';
+import query_msg from '../../../../../__fixtures__/basic/query_msg.json';
+import execute_msg from '../../../../../__fixtures__/basic/execute_msg_for__empty.json';
+import approval_response from '../../../../../__fixtures__/basic/approval_response.json';
+import all_nft_info_response from '../../../../../__fixtures__/basic/all_nft_info_response.json';
+import approvals_response from '../../../../../__fixtures__/basic/approvals_response.json';
+import collection_info_response from '../../../../../__fixtures__/basic/collection_info_response.json';
+import contract_info_response from '../../../../../__fixtures__/basic/contract_info_response.json';
+import instantiate_msg from '../../../../../__fixtures__/basic/instantiate_msg.json';
+import nft_info_response from '../../../../../__fixtures__/basic/nft_info_response.json';
+import num_tokens_response from '../../../../../__fixtures__/basic/num_tokens_response.json';
+import operators_response from '../../../../../__fixtures__/basic/operators_response.json';
+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';
+it('approval_response', () => {
+  const ctx = new RenderContext(approval_response);
+  expectCode(createTypeInterface(ctx, approval_response));
+});
+it('all_nft_info_response', () => {
+  const ctx = new RenderContext(all_nft_info_response);
+  expectCode(createTypeInterface(ctx, all_nft_info_response));
+});
+it('approvals_response', () => {
+  const ctx = new RenderContext(approvals_response);
+  expectCode(createTypeInterface(ctx, approvals_response));
+});
+it('collection_info_response', () => {
+  const ctx = new RenderContext(collection_info_response);
+  expectCode(createTypeInterface(ctx, collection_info_response));
+});
+it('contract_info_response', () => {
+  const ctx = new RenderContext(contract_info_response);
+  expectCode(createTypeInterface(ctx, contract_info_response));
+});
+it('instantiate_msg', () => {
+  const ctx = new RenderContext(instantiate_msg);
+  expectCode(createTypeInterface(ctx, instantiate_msg));
+});
+it('nft_info_response', () => {
+  const ctx = new RenderContext(nft_info_response);
+  expectCode(createTypeInterface(ctx, nft_info_response));
+});
+it('num_tokens_response', () => {
+  const ctx = new RenderContext(num_tokens_response);
+  expectCode(createTypeInterface(ctx, num_tokens_response));
+});
+it('operators_response', () => {
+  const ctx = new RenderContext(operators_response);
+  expectCode(createTypeInterface(ctx, operators_response));
+});
+it('owner_of_response', () => {
+  const ctx = new RenderContext(owner_of_response);
+  expectCode(createTypeInterface(ctx, owner_of_response));
+});
+it('tokens_response', () => {
+  const ctx = new RenderContext(tokens_response);
+  expectCode(createTypeInterface(ctx, tokens_response));
+});
+it('query classes', () => {
+  const ctx = new RenderContext(query_msg);
+  expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', query_msg));
+});
+it('execute classes', () => {
+  const ctx = new RenderContext(execute_msg);
+  expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', 'SG721QueryClient', execute_msg));
+});
+it('execute classes no extends', () => {
+  const ctx = new RenderContext(execute_msg);
+  expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', null, execute_msg));
+});
+it('execute classes array types', () => {
+  const ctx = new RenderContext(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);
+  expectCode(createExecuteInterface(ctx, 'SG721Instance', null, execute_msg));
+});
+it('query interfaces', () => {
+  const ctx = new RenderContext(query_msg);
+  expectCode(createQueryInterface(ctx, 'SG721ReadOnlyInstance', query_msg));
+});

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

@@ -0,0 +1,44 @@
+import cosmos_msg_for__empty from '../../../../../__fixtures__/vectis/govec/cosmos_msg_for__empty.json';
+import execute_msg_for__empty from '../../../../../__fixtures__/vectis/govec/execute_msg_for__empty.json';
+import can_execute_relay_response from '../../../../../__fixtures__/vectis/govec/can_execute_relay_response.json';
+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';
+it('cosmos_msg_for__empty', () => {
+  const ctx = new RenderContext(cosmos_msg_for__empty);
+  expectCode(createTypeInterface(ctx, cosmos_msg_for__empty));
+});
+it('execute_msg_for__empty', () => {
+  const ctx = new RenderContext(execute_msg_for__empty);
+  expectCode(createTypeInterface(ctx, execute_msg_for__empty));
+});
+it('can_execute_relay_response', () => {
+  const ctx = new RenderContext(can_execute_relay_response);
+  expectCode(createTypeInterface(ctx, can_execute_relay_response));
+});
+it('info_response', () => {
+  const ctx = new RenderContext(info_response);
+  expectCode(createTypeInterface(ctx, info_response));
+});
+it('relay_transaction', () => {
+  const ctx = new RenderContext(relay_transaction);
+  expectCode(createTypeInterface(ctx, relay_transaction));
+});
+it('query classes', () => {
+  const ctx = new RenderContext(cosmos_msg_for__empty);
+  expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', cosmos_msg_for__empty));
+});
+it('query classes', () => {
+  const ctx = new RenderContext(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);
+  expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', null, execute_msg_for__empty));
+});
+it('execute interfaces no extends', () => {
+  const ctx = new RenderContext(execute_msg_for__empty);
+  expectCode(createExecuteInterface(ctx, 'SG721Instance', null, execute_msg_for__empty));
+});

package/module/context/context.js

@@ -0,0 +1,25 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import deepmerge from "deepmerge"; /// Plugin Types
+
+export const defaultOptions = {
+  reactQuery: {
+    optionalClient: false,
+    v4: false,
+    mutations: false,
+    camelize: true
+  }
+};
+export class RenderContext {
+  constructor(schema, options) {
+    _defineProperty(this, "schema", void 0);
+
+    this.schema = schema;
+    this.options = deepmerge(defaultOptions, options ?? {});
+  }
+
+  refLookup($ref) {
+    const refName = $ref.replace('#/definitions/', '');
+    return this.schema.definitions?.[refName];
+  }
+
+}

package/module/context/index.js

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

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

@@ -1,51 +1,26 @@
 import * as t from '@babel/types';
 import { camel } from 'case';
-import { bindMethod, typedIdentifier, classDeclaration, classProperty, arrowFunctionExpression, getMessageProperties } from './utils';
-import { createTypedObjectParams } from './utils/types';
-import { identifier, tsTypeOperator } from './utils/babel';
+import { bindMethod, typedIdentifier, classDeclaration, classProperty, arrowFunctionExpression, getMessageProperties } from '../utils';
+import { createTypedObjectParams } from '../utils/types';
+import { identifier } from '../utils/babel';
+import { getWasmMethodArgs } from '../client/client';
 
-const createWasmExecMethodPartial = jsonschema => {
+const createWasmExecMethodPartial = (context, jsonschema) => {
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const properties = jsonschema.properties[underscoreName].properties ?? {};
-  const obj = createTypedObjectParams(jsonschema.properties[underscoreName]);
-  const args = Object.keys(properties).map(prop => {
-    return t.objectProperty(t.identifier(prop), t.identifier(camel(prop)), false, prop === camel(prop));
-  });
-  const constantParams = [// 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(tsTypeOperator(t.tsArrayType(t.tsTypeReference(t.identifier('Coin'))), 'readonly')), true)];
+  const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
+  const constantParams = [identifier('funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true)];
   return t.classProperty(t.identifier(methodName), arrowFunctionExpression(obj ? [// props
   obj, ...constantParams] : constantParams, t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier('typeUrl'), t.stringLiteral('/cosmwasm.wasm.v1.MsgExecuteContract')), t.objectProperty(t.identifier('value'), t.callExpression(t.memberExpression(t.identifier('MsgExecuteContract'), t.identifier('fromPartial')), [t.objectExpression([t.objectProperty(t.identifier('sender'), t.memberExpression(t.thisExpression(), t.identifier('sender'))), t.objectProperty(t.identifier('contract'), t.memberExpression(t.thisExpression(), t.identifier('contractAddress'))), t.objectProperty(t.identifier('msg'), t.callExpression(t.identifier('toUtf8'), [t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('stringify')), [t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.objectExpression(args))])])])), t.objectProperty(t.identifier('funds'), t.identifier('funds'), false, true)])]))]))]), // return type
   t.tsTypeAnnotation(t.tsTypeReference(t.identifier('MsgExecuteContractEncodeObject'))), false));
 };
 
-export const createFromPartialClass = (className, implementsClassName, execMsg) => {
+export const createFromPartialClass = (context, className, implementsClassName, execMsg) => {
   const propertyNames = getMessageProperties(execMsg).map(method => Object.keys(method.properties)?.[0]).filter(Boolean);
   const bindings = propertyNames.map(camel).map(bindMethod);
   const methods = getMessageProperties(execMsg).map(schema => {
-    return createWasmExecMethodPartial(schema);
+    return createWasmExecMethodPartial(context, schema);
   });
   const blockStmt = [];
   [].push.apply(blockStmt, [t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('sender')), t.identifier('sender'))), t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.identifier('contractAddress'))), ...bindings]);
@@ -54,37 +29,21 @@ export const createFromPartialClass = (className, implementsClassName, execMsg)
   classProperty('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword())), // constructor
   t.classMethod('constructor', t.identifier('constructor'), [typedIdentifier('sender', t.tsTypeAnnotation(t.tsStringKeyword())), typedIdentifier('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword()))], t.blockStatement(blockStmt)), ...methods], [t.tSExpressionWithTypeArguments(t.identifier(implementsClassName))], null));
 };
-export const createFromPartialInterface = (className, execMsg) => {
+export const createFromPartialInterface = (context, className, execMsg) => {
   const methods = getMessageProperties(execMsg).map(jsonschema => {
     const underscoreName = Object.keys(jsonschema.properties)[0];
     const methodName = camel(underscoreName);
-    return createPropertyFunctionWithObjectParamsForPartial(methodName, 'MsgExecuteContractEncodeObject', jsonschema.properties[underscoreName]);
+    return createPropertyFunctionWithObjectParamsForPartial(context, methodName, 'MsgExecuteContractEncodeObject', jsonschema.properties[underscoreName]);
   });
   const extendsAst = [];
   return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(className), null, extendsAst, t.tSInterfaceBody([// contract address
   t.tSPropertySignature(t.identifier('contractAddress'), t.tsTypeAnnotation(t.tsStringKeyword())), // contract address
   t.tSPropertySignature(t.identifier('sender'), t.tsTypeAnnotation(t.tsStringKeyword())), ...methods])));
-}; // MARKED AS NOT DRY 
+};
 
-const createPropertyFunctionWithObjectParamsForPartial = (methodName, responseType, jsonschema) => {
-  const obj = createTypedObjectParams(jsonschema);
-  const fixedParams = [// 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(tsTypeOperator(t.tsArrayType(t.tsTypeReference(t.identifier('Coin'))), 'readonly')), true)];
+const createPropertyFunctionWithObjectParamsForPartial = (context, methodName, responseType, jsonschema) => {
+  const obj = createTypedObjectParams(context, jsonschema);
+  const fixedParams = [identifier('funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true)];
   const func = {
     type: 'TSFunctionType',
     typeAnnotation: t.tsTypeAnnotation(t.tsTypeReference(t.identifier(responseType))),

package/module/from-partial/from-partial.spec.js

@@ -0,0 +1,12 @@
+import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
+import { createFromPartialClass, createFromPartialInterface } from './from-partial';
+import { RenderContext } from '../context';
+import { expectCode } from '../../test-utils';
+it('execute classes', () => {
+  const ctx = new RenderContext(execute_msg);
+  expectCode(createFromPartialClass(ctx, 'SG721MessageComposer', 'SG721Message', execute_msg));
+});
+it('createFromPartialInterface', () => {
+  const ctx = new RenderContext(execute_msg);
+  expectCode(createFromPartialInterface(ctx, 'SG721Message', execute_msg));
+});

package/module/from-partial/index.js

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

package/module/index.js

@@ -1,5 +1,7 @@
 export * from './utils';
-export * from './wasm';
+export * from './client';
+export * from './context';
 export * from './recoil';
-export * from './messages';
-export * from './react-query';
+export * from './from-partial';
+export * from './react-query';
+export * from './types';

package/module/react-query/index.js

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

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

@@ -1,29 +1,16 @@
-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 t from '@babel/types';
 import { camel, pascal } from 'case';
-import { callExpression, getMessageProperties, identifier, tsObjectPattern, tsPropertySignature } from './utils';
-import { omitTypeReference, optionalConditionalExpression, propertySignature, shorthandProperty, typeRefOrOptionalUnion } from './utils/babel';
-import { getParamsTypeAnnotation, getPropertyType, getTypeFromRef } from './utils/types';
-import { FIXED_EXECUTE_PARAMS } from './wasm'; // TODO: this mutations boolean is not actually used here and only at a higher level
-
-const DEFAULT_OPTIONS = {
-  optionalClient: false,
-  v4: false,
-  mutations: false
-};
+import { callExpression, getMessageProperties, identifier, tsObjectPattern, tsPropertySignature } from '../utils';
+import { omitTypeReference, optionalConditionalExpression, propertySignature, shorthandProperty, typeRefOrOptionalUnion } from '../utils/babel';
+import { getParamsTypeAnnotation, getPropertyType } from '../utils/types';
+import { FIXED_EXECUTE_PARAMS } from '../client';
 export const createReactQueryHooks = ({
+  context,
   queryMsg,
   contractName,
-  QueryClient,
-  options = {}
+  QueryClient
 }) => {
-  // merge the user options with the defaults
-  options = _objectSpread(_objectSpread({}, DEFAULT_OPTIONS), options);
+  const options = context.options.reactQuery;
   return getMessageProperties(queryMsg).reduce((m, schema) => {
     const underscoreName = Object.keys(schema.properties)[0];
     const methodName = camel(underscoreName);
@@ -33,33 +20,33 @@ export const createReactQueryHooks = ({
     const getterKey = camel(`${contractName}${pascal(methodName)}`);
     const jsonschema = schema.properties[underscoreName];
     return [createReactQueryHookInterface({
+      context,
       hookParamsTypeName,
       responseType,
       QueryClient,
       jsonschema,
       options
     }), createReactQueryHook({
+      context,
       methodName,
       hookName,
       hookParamsTypeName,
       responseType,
       hookKeyName: getterKey,
-      jsonschema,
-      options
+      jsonschema
     }), ...m];
   }, []);
 };
 export const createReactQueryHook = ({
+  context,
   hookName,
   hookParamsTypeName,
   responseType,
   hookKeyName,
   methodName,
-  jsonschema,
-  options = {}
+  jsonschema
 }) => {
-  // merge the user options with the defaults
-  options = _objectSpread(_objectSpread({}, DEFAULT_OPTIONS), options);
+  const options = context.options.reactQuery;
   const keys = Object.keys(jsonschema.properties ?? {});
   let args = [];
 
@@ -98,6 +85,7 @@ export interface Cw4UpdateMembersMutation {
 ```
  */
 export const createReactQueryMutationArgsInterface = ({
+  context,
   ExecuteClient,
   mutationHookParamsTypeName,
   useMutationTypeParameter,
@@ -105,21 +93,11 @@ export const createReactQueryMutationArgsInterface = ({
 }) => {
   const typedUseMutationOptions = t.tsTypeReference(t.identifier('UseMutationOptions'), useMutationTypeParameter);
   const body = [tsPropertySignature(t.identifier('client'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(ExecuteClient))), false)];
-  let msgType = getParamsTypeAnnotation(jsonschema); // TODO: this should not have to be done manually.
-
-  if (!msgType && jsonschema?.$ref?.startsWith('#/definitions/')) {
-    let refName = jsonschema?.$ref;
-
-    if (/_for_[A-Z]/.test(refName)) {
-      refName = refName.replace(/_for_/, 'For');
-    }
-
-    msgType = t.tsTypeAnnotation(getTypeFromRef(refName));
-  }
+  const msgType = getParamsTypeAnnotation(context, jsonschema);
 
   if (msgType) {
     body.push(t.tsPropertySignature(t.identifier('msg'), msgType));
-  } //  fee: number | StdFee | "auto" = "auto", memo?: string, funds?: readonly Coin[]
+  } //  fee: number | StdFee | "auto" = "auto", memo?: string, funds?: Coin[]
 
 
   const optionalArgs = t.tsPropertySignature(t.identifier('args'), t.tsTypeAnnotation(t.tsTypeLiteral(FIXED_EXECUTE_PARAMS.map(param => propertySignature(param.name, param.typeAnnotation, param.optional)))));
@@ -128,10 +106,10 @@ export const createReactQueryMutationArgsInterface = ({
   return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(mutationHookParamsTypeName), null, [], t.tsInterfaceBody(body)));
 };
 export const createReactQueryMutationHooks = ({
+  context,
   execMsg,
   contractName,
-  ExecuteClient,
-  options = {}
+  ExecuteClient
 }) => {
   // merge the user options with the defaults
   return getMessageProperties(execMsg).reduce((m, schema) => {
@@ -150,11 +128,13 @@ export const createReactQueryMutationHooks = ({
 
     const useMutationTypeParameter = generateMutationTypeParameter(mutationHookParamsTypeName, hasMsg);
     return [createReactQueryMutationArgsInterface({
+      context,
       mutationHookParamsTypeName,
       ExecuteClient,
       jsonschema,
       useMutationTypeParameter
     }), createReactQueryMutationHook({
+      context,
       execMethodName,
       mutationHookName,
       mutationHookParamsTypeName,
@@ -186,6 +166,7 @@ export const useCw4UpdateMembersMutation = ({ client, options }: Omit<Cw4UpdateM
 ```
  */
 export const createReactQueryMutationHook = ({
+  context,
   mutationHookName,
   mutationHookParamsTypeName,
   execMethodName,
@@ -199,17 +180,17 @@ export const createReactQueryMutationHook = ({
   ), t.identifier('options')], useMutationTypeParameter))])));
 };
 export const createReactQueryHookInterface = ({
+  context,
   QueryClient,
   hookParamsTypeName,
   responseType,
-  jsonschema,
-  options = {}
+  jsonschema
 }) => {
   // merge the user options with the defaults
-  options = _objectSpread(_objectSpread({}, DEFAULT_OPTIONS), options);
+  const options = context.options.reactQuery;
   const typedUseQueryOptions = t.tsTypeReference(t.identifier('UseQueryOptions'), t.tsTypeParameterInstantiation([typeRefOrOptionalUnion(t.identifier(responseType), options.optionalClient), t.tsTypeReference(t.identifier('Error')), t.tsTypeReference(t.identifier(responseType)), t.tsArrayType(t.tsParenthesizedType(t.tsUnionType([t.tsStringKeyword(), t.tsUndefinedKeyword()])))]));
   const body = [tsPropertySignature(t.identifier('client'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(QueryClient))), options.optionalClient), tsPropertySignature(t.identifier('options'), t.tsTypeAnnotation(options.v4 ? t.tSIntersectionType([omitTypeReference(typedUseQueryOptions, "'queryKey' | 'queryFn' | 'initialData'"), t.tSTypeLiteral([t.tsPropertySignature(t.identifier('initialData?'), t.tsTypeAnnotation(t.tsUndefinedKeyword()))])]) : typedUseQueryOptions), true)];
-  const props = getProps(jsonschema, true);
+  const props = getProps(context, jsonschema);
 
   if (props.length) {
     body.push(t.tsPropertySignature(t.identifier('args'), t.tsTypeAnnotation(t.tsTypeLiteral(props))));
@@ -218,19 +199,19 @@ export const createReactQueryHookInterface = ({
   return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(hookParamsTypeName), null, [], t.tsInterfaceBody(body)));
 };
 
-const getProps = (jsonschema, camelize) => {
+const getProps = (context, jsonschema) => {
   const keys = Object.keys(jsonschema.properties ?? {});
   if (!keys.length) return [];
   return keys.map(prop => {
     const {
       type,
       optional
-    } = getPropertyType(jsonschema, prop);
-    return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(type), optional);
+    } = getPropertyType(context, jsonschema, prop);
+    return propertySignature(context.options.reactQuery.camelize ? camel(prop) : prop, t.tsTypeAnnotation(type), optional);
   });
 };
 
-function generateUseQueryQueryKey(hookKeyName, props, optionalClient) {
+const generateUseQueryQueryKey = (hookKeyName, props, optionalClient) => {
   const queryKey = [t.stringLiteral(hookKeyName), t.optionalMemberExpression(t.identifier('client'), t.identifier('contractAddress'), false, optionalClient)];
 
   if (props.includes('args')) {
@@ -238,4 +219,4 @@ function generateUseQueryQueryKey(hookKeyName, props, optionalClient) {
   }
 
   return queryKey;
-}
+};

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

@@ -0,0 +1,53 @@
+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);
+it('createReactQueryHooks', () => {
+  expectCode(t.program(createReactQueryHooks({
+    context: queryCtx,
+    queryMsg: query_msg,
+    contractName: 'Sg721',
+    QueryClient: 'Sg721QueryClient'
+  })));
+  expectCode(t.program(createReactQueryHooks({
+    context: new RenderContext(query_msg, {
+      reactQuery: {
+        optionalClient: true
+      }
+    }),
+    queryMsg: query_msg,
+    contractName: 'Sg721',
+    QueryClient: 'Sg721QueryClient'
+  })));
+  expectCode(t.program(createReactQueryHooks({
+    context: new RenderContext(query_msg, {
+      reactQuery: {
+        v4: true
+      }
+    }),
+    queryMsg: query_msg,
+    contractName: 'Sg721',
+    QueryClient: 'Sg721QueryClient'
+  })));
+  expectCode(t.program(createReactQueryHooks({
+    context: new RenderContext(query_msg, {
+      reactQuery: {
+        optionalClient: true,
+        v4: true
+      }
+    }),
+    queryMsg: query_msg,
+    contractName: 'Sg721',
+    QueryClient: 'Sg721QueryClient'
+  })));
+  expectCode(t.program(createReactQueryMutationHooks({
+    context: execCtx,
+    execMsg: execute_msg,
+    contractName: 'Sg721',
+    ExecuteClient: 'Sg721Client'
+  })));
+});

package/module/recoil/index.js

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

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

@@ -1,31 +1,17 @@
 import * as t from '@babel/types';
 import { camel, pascal } from 'case';
-import { callExpression, getMessageProperties } from './utils';
-export const createWasmRecoilMethod = jsonschema => {
-  const underscoreName = Object.keys(jsonschema.properties)[0];
-  const methodName = camel(underscoreName);
-  const responseType = pascal(`${methodName}Response`);
-  const properties = jsonschema.properties[underscoreName].properties ?? {};
-
-  if (Object.keys(properties).length > 0) {} else {}
-};
-export const createRecoilSelector = (keyPrefix, QueryClient, methodName) => {
-  // const propertyNames = getMessageProperties(queryMsg)
-  //   .map(method => Object.keys(method.properties)?.[0])
-  //   .filter(Boolean);
-  // const methods = getMessageProperties(queryMsg)
-  //   .map(schema => createWasmRecoilMethod(schema))
+import { callExpression, getMessageProperties } from '../utils';
+export const createRecoilSelector = (context, keyPrefix, QueryClient, methodName) => {
   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.identifier('params')
-  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)))]))))])])])))]));
+  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)))]))))])])])))]));
 };
-export const createRecoilSelectors = (keyPrefix, QueryClient, queryMsg) => {
+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(keyPrefix, QueryClient, methodName);
+    return createRecoilSelector(context, keyPrefix, QueryClient, methodName);
   });
 };
 export const createRecoilQueryClientType = () => ({
@@ -52,7 +38,7 @@ export const createRecoilQueryClientType = () => ({
     }]
   }
 });
-export const createRecoilQueryClient = (keyPrefix, QueryClient) => {
+export const createRecoilQueryClient = (context, keyPrefix, QueryClient) => {
   const getterKey = camel(`${keyPrefix}${'QueryClient'}`);
   return t.exportNamedDeclaration(t.variableDeclaration('const', [t.variableDeclarator(t.identifier('queryClient'), 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('contractAddress'), t.identifier('contractAddress'), false, true)])], 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.identifier('cosmWasmClient')]))]), t.returnStatement(t.newExpression(t.identifier(QueryClient), [t.identifier('client'), t.identifier('contractAddress')]))]), false)))])], t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(QueryClient)), t.tsTypeReference(t.identifier('QueryClientParams'))])))]));
 };

package/module/recoil/recoil.spec.js

@@ -0,0 +1,15 @@
+import * as t from '@babel/types';
+import query_msg from '../../../../__fixtures__/basic/query_msg.json';
+import { createRecoilSelector, createRecoilSelectors, createRecoilQueryClient } from './recoil';
+import { RenderContext } from '../context';
+import { expectCode } from '../../test-utils';
+const ctx = new RenderContext(query_msg);
+it('selector', () => {
+  expectCode(createRecoilSelector(ctx, 'SG721', 'SG721QueryClient', 'governanceModules'));
+});
+it('selectors', () => {
+  expectCode(t.program(createRecoilSelectors(ctx, 'SG721', 'SG721QueryClient', query_msg)));
+});
+it('client', () => {
+  expectCode(createRecoilQueryClient(ctx, 'SG721', 'SG721QueryClient'));
+});

package/module/utils/babel.spec.js

@@ -1,16 +1,7 @@
 import { importStmt } from './babel';
-import generate from '@babel/generator';
 import * as t from '@babel/types';
 import { bindMethod, typedIdentifier, promiseTypeAnnotation, classDeclaration, classProperty, arrowFunctionExpression } from './babel';
-
-const expectCode = ast => {
-  expect(generate(ast).code).toMatchSnapshot();
-};
-
-const printCode = ast => {
-  console.log(generate(ast).code);
-};
-
+import { expectCode } from '../../test-utils';
 it('top import', async () => {
   expectCode(importStmt(['CosmWasmClient', 'ExecuteResult', 'SigningCosmWasmClient'], '@cosmjs/cosmwasm-stargate'));
 });

package/module/utils/index.js

@@ -1 +1,2 @@
-export * from './babel';
+export * from './babel';
+export * from './types';