wasm-ast-types 0.18.2 → 0.20.0

package/main/utils/index.js

@@ -28,4 +28,17 @@ Object.keys(_types).forEach(function (key) {
       return _types[key];
     }
   });
+});
+
+var _ref = require("./ref");
+
+Object.keys(_ref).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _ref[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _ref[key];
+    }
+  });
 });

package/main/utils/ref.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.refLookup = void 0;
+
+var refLookup = function refLookup($ref, schema) {
+  var _schema$definitions;
+
+  var refName = $ref.replace('#/definitions/', '');
+  return (_schema$definitions = schema.definitions) === null || _schema$definitions === void 0 ? void 0 : _schema$definitions[refName];
+};
+
+exports.refLookup = refLookup;

package/main/utils/types.js

@@ -400,9 +400,17 @@ var createTypedObjectParams = function createTypedObjectParams(context, jsonsche
   if (!keys.length) {
     // is there a ref?
     if (jsonschema.$ref) {
-      var _obj = context.refLookup(jsonschema.$ref);
+      var _obj = context.refLookup(jsonschema.$ref); // If there is a oneOf, then we need to create a type for it
 
-      if (_obj) {
+
+      if (_obj !== null && _obj !== void 0 && _obj.oneOf) {
+        // the actual type of the ref
+        var refType = jsonschema.$ref.split('/').pop();
+        var refName = (0, _case.camel)(refType);
+        var id = t.identifier(refName);
+        id.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(refType)));
+        return id;
+      } else if (_obj) {
         return createTypedObjectParams(context, _obj, camelize);
       }
     } // no results...

package/module/client/client.js

@@ -1,7 +1,7 @@
 import * as t from '@babel/types';
 import { camel } from 'case';
-import { bindMethod, typedIdentifier, promiseTypeAnnotation, classDeclaration, classProperty, arrowFunctionExpression, getMessageProperties } from '../utils';
-import { getPropertyType, getType, createTypedObjectParams, getResponseType } from '../utils/types';
+import { arrowFunctionExpression, bindMethod, classDeclaration, classProperty, getMessageProperties, promiseTypeAnnotation, typedIdentifier } from '../utils';
+import { createTypedObjectParams, getPropertyType, getResponseType, getType } 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)];
@@ -9,10 +9,12 @@ export const createWasmQueryMethod = (context, jsonschema) => {
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
   const responseType = getResponseType(context, underscoreName);
-  const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
   const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
-  const actionArg = t.objectProperty(t.identifier(underscoreName), t.objectExpression(args));
-  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(obj ? [obj] : [], t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('queryContractSmart')), [t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([actionArg])]))]), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier(responseType))]))), true));
+  const msgAction = t.identifier(underscoreName); // If the param is an identifier, we can just use it as is
+
+  const msgActionValue = param?.type === 'Identifier' ? t.identifier(param.name) : t.objectExpression(args);
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(param ? [param] : [], t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('queryContractSmart')), [t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(msgAction, msgActionValue)])]))]), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier(responseType))]))), true));
 };
 export const createQueryClass = (context, className, implementsClassName, queryMsg) => {
   context.addUtil('CosmWasmClient');
@@ -31,10 +33,14 @@ export const getWasmMethodArgs = (context, jsonschema) => {
   let keys = Object.keys(jsonschema.properties ?? {}); // only 1 degree $ref-lookup
 
   if (!keys.length && jsonschema.$ref) {
-    const obj = context.refLookup(jsonschema.$ref);
+    const obj = context.refLookup(jsonschema.$ref); // properties
 
     if (obj) {
       keys = Object.keys(obj.properties ?? {});
+    } // tuple struct or otherwise, use the name of the reference
+
+
+    if (!keys.length && obj?.oneOf) {// TODO????? ADAIR
     }
   }
 
@@ -49,10 +55,13 @@ export const createWasmExecMethod = (context, jsonschema) => {
   context.addUtil('Coin');
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
   const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
-  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(obj ? [// props
-  obj, ...CONSTANT_EXEC_PARAMS] : CONSTANT_EXEC_PARAMS, t.blockStatement([t.returnStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('execute')), [t.memberExpression(t.thisExpression(), t.identifier('sender')), t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.objectExpression([...args]))]), t.identifier('fee'), t.identifier('memo'), t.identifier('funds')])))]), // return type
+  const msgAction = t.identifier(underscoreName); // If the param is an identifier, we can just use it as is
+
+  const msgActionValue = param?.type === 'Identifier' ? t.identifier(param.name) : t.objectExpression(args);
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(param ? [// props
+  param, ...CONSTANT_EXEC_PARAMS] : CONSTANT_EXEC_PARAMS, t.blockStatement([t.returnStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('execute')), [t.memberExpression(t.thisExpression(), t.identifier('sender')), t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(msgAction, msgActionValue)]), t.identifier('fee'), t.identifier('memo'), t.identifier('funds')])))]), // return type
   t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier('ExecuteResult'))]))), true));
 };
 export const createExecuteClass = (context, className, implementsClassName, extendsClassName, execMsg) => {

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

@@ -0,0 +1,20 @@
+import { createExecuteClass, createExecuteInterface } from '../client';
+import { expectCode, makeContext } from '../../../test-utils';
+import ownership from '../../../../../__fixtures__/basic/ownership.json'; // it('query classes', () => {
+//     const ctx = makeContext(cosmos_msg_for__empty);
+//     expectCode(createQueryClass(
+//         ctx,
+//         'SG721QueryClient',
+//         'SG721ReadOnlyInstance',
+//         cosmos_msg_for__empty
+//     ))
+// });
+
+it('execute interfaces no extends', () => {
+  const ctx = makeContext(ownership);
+  expectCode(createExecuteInterface(ctx, 'OwnershipInstance', null, ownership));
+});
+it('ownership client with tuple', () => {
+  const ctx = makeContext(ownership);
+  expectCode(createExecuteClass(ctx, 'OwnershipClient', 'OwnershipInstance', null, ownership));
+});

package/module/client/test/ts-client.issue-98.test.js

@@ -0,0 +1,23 @@
+import contract from '../../../../../__fixtures__/issues/98/schema.json';
+import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
+import { expectCode, makeContext } from '../../../test-utils';
+const message = contract.query;
+const ctx = makeContext(message);
+it('execute_msg_for__empty', () => {
+  expectCode(createTypeInterface(ctx, message));
+});
+it('query classes', () => {
+  expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', message));
+}); // it('query classes response', () => {
+//     expectCode(createTypeInterface(
+//         ctx,
+//         contract.responses.all_debt_shares
+//     ))
+// });
+
+it('execute classes array types', () => {
+  expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', null, message));
+});
+it('execute interfaces no extends', () => {
+  expectCode(createExecuteInterface(ctx, 'SG721Instance', null, message));
+});

package/module/context/context.js

@@ -4,11 +4,13 @@ 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) { _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 { refLookup } from "../utils";
 import { convertUtilsToImportList, getImportStatements } from "./imports";
 import deepmerge from "deepmerge"; /// Plugin Types
 
 ;
 export const defaultOptions = {
+  enabled: true,
   types: {
     enabled: true,
     aliasExecuteMsg: false
@@ -24,6 +26,9 @@ export const defaultOptions = {
   messageComposer: {
     enabled: false
   },
+  msgBuilder: {
+    enabled: false
+  },
   reactQuery: {
     enabled: false,
     optionalClient: false,
@@ -44,7 +49,13 @@ export const getDefinitionSchema = schemas => {
   });
   return aggregateSchema;
 };
-export class RenderContext {
+/**
+ * context object for generating code.
+ * only mergeDefaultOpt needs to implementing for combine options and default options.
+ * @param TOpt option type
+ */
+
+export class RenderContextBase {
   constructor(contract, options) {
     _defineProperty(this, "contract", void 0);
 
@@ -52,22 +63,34 @@ export class RenderContext {
 
     _defineProperty(this, "schema", void 0);
 
+    _defineProperty(this, "options", void 0);
+
     this.contract = contract;
     this.schema = getDefinitionSchema(contract.schemas);
-    this.options = deepmerge(defaultOptions, options ?? {});
+    this.options = this.mergeDefaultOpt(options);
   }
+  /**
+   * merge options and default options
+   * @param options
+   */
+
 
   refLookup($ref) {
-    const refName = $ref.replace('#/definitions/', '');
-    return this.schema.definitions?.[refName];
+    return refLookup($ref, this.schema);
   }
 
   addUtil(util) {
     this.utils[util] = true;
   }
 
-  getImports() {
-    return getImportStatements(convertUtilsToImportList(this, Object.keys(this.utils)));
+  getImports(registeredUtils) {
+    return getImportStatements(convertUtilsToImportList(this, Object.keys(this.utils), registeredUtils));
+  }
+
+}
+export class RenderContext extends RenderContextBase {
+  mergeDefaultOpt(options) {
+    return deepmerge(defaultOptions, options ?? {});
   }
 
 }

package/module/context/imports.js

@@ -23,11 +23,11 @@ const makeReactQuerySwitch = varName => {
 };
 
 export const UTILS = {
+  selectorFamily: 'recoil',
   MsgExecuteContract: 'cosmjs-types/cosmwasm/wasm/v1/tx',
   MsgExecuteContractEncodeObject: 'cosmwasm',
   Coin: '@cosmjs/amino',
   toUtf8: '@cosmjs/encoding',
-  selectorFamily: 'recoil',
   StdFee: '@cosmjs/amino',
   CosmWasmClient: '@cosmjs/cosmwasm-stargate',
   ExecuteResult: '@cosmjs/cosmwasm-stargate',
@@ -38,23 +38,42 @@ export const UTILS = {
   useMutation: makeReactQuerySwitch('useMutation'),
   UseMutationOptions: makeReactQuerySwitch('UseMutationOptions')
 };
-export const convertUtilsToImportList = (context, utils) => {
+export const convertUtilsToImportList = (context, utils, registeredUtils) => {
   return utils.map(util => {
-    if (!UTILS.hasOwnProperty(util)) throw new Error(`missing Util! ::[${util}]`);
-
-    if (typeof UTILS[util] === 'string') {
-      return {
-        type: 'import',
-        path: UTILS[util],
-        name: util
-      };
-    } else if (typeof UTILS[util] === 'function') {
-      return UTILS[util](context);
-    } else {
-      UTILS[util];
+    let result = null;
+
+    if (registeredUtils) {
+      result = convertUtil(context, util, registeredUtils);
+
+      if (result) {
+        return result;
+      }
+    }
+
+    result = convertUtil(context, util, UTILS);
+
+    if (result) {
+      return result;
     }
+
+    throw new Error(`missing Util! ::[${util}]`);
   });
 };
+export const convertUtil = (context, util, registeredUtils) => {
+  if (!registeredUtils.hasOwnProperty(util)) return null;
+
+  if (typeof registeredUtils[util] === 'string') {
+    return {
+      type: 'import',
+      path: registeredUtils[util],
+      name: util
+    };
+  } else if (typeof registeredUtils[util] === 'function') {
+    return registeredUtils[util](context);
+  } else {
+    return registeredUtils[util];
+  }
+};
 export const getImportStatements = list => {
   const imports = list.reduce((m, obj) => {
     m[obj.path] = m[obj.path] || [];

package/module/index.js

@@ -4,4 +4,5 @@ export * from './context';
 export * from './recoil';
 export * from './message-composer';
 export * from './react-query';
-export * from './types';
+export * from './types';
+export * from './msg-builder';

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

@@ -12,11 +12,20 @@ const createWasmExecMethodMessageComposer = (context, jsonschema) => {
   context.addUtil('toUtf8');
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
-  const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
+  const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]); // what the underscore named property in the message is assigned to
+
+  let actionValue;
+
+  if (param?.type === 'Identifier') {
+    actionValue = t.identifier(param.name);
+  } else {
+    actionValue = t.objectExpression(args);
+  }
+
   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
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(param ? [// props
+  param, ...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), actionValue)])])])), t.objectProperty(t.identifier('funds'), t.identifier('funds'), false, true)])]))]))]), // return type
   t.tsTypeAnnotation(t.tsTypeReference(t.identifier('MsgExecuteContractEncodeObject'))), false));
 };
 

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

@@ -1,11 +1,20 @@
-import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
-import { createMessageComposerClass, createMessageComposerInterface } from './message-composer';
-import { expectCode, makeContext } from '../../test-utils';
-it('execute classes', () => {
+import execute_msg from "../../../../__fixtures__/basic/execute_msg_for__empty.json";
+import ownership from "../../../../__fixtures__/basic/ownership.json";
+import { createMessageComposerClass, createMessageComposerInterface } from "./message-composer";
+import { expectCode, makeContext } from "../../test-utils";
+it("execute classes", () => {
   const ctx = makeContext(execute_msg);
-  expectCode(createMessageComposerClass(ctx, 'SG721MessageComposer', 'SG721Message', execute_msg));
+  expectCode(createMessageComposerClass(ctx, "SG721MessageComposer", "SG721Message", execute_msg));
 });
-it('createMessageComposerInterface', () => {
+it("createMessageComposerInterface", () => {
   const ctx = makeContext(execute_msg);
-  expectCode(createMessageComposerInterface(ctx, 'SG721Message', execute_msg));
+  expectCode(createMessageComposerInterface(ctx, "SG721Message", execute_msg));
+});
+it("ownershipClass", () => {
+  const ctx = makeContext(ownership);
+  expectCode(createMessageComposerClass(ctx, "OwnershipMessageComposer", "OwnershipMessage", ownership));
+});
+it("ownershipInterface", () => {
+  const ownershipCtx = makeContext(ownership);
+  expectCode(createMessageComposerInterface(ownershipCtx, "OwnershipMessage", ownership));
 });

package/module/msg-builder/index.js

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

package/module/msg-builder/msg-builder.js

@@ -0,0 +1,47 @@
+import * as t from '@babel/types';
+import { camel } from 'case';
+import { abstractClassDeclaration, arrowFunctionExpression, getMessageProperties } from '../utils';
+import { createTypedObjectParams } from '../utils/types';
+import { getWasmMethodArgs } from '../client/client';
+export const createMsgBuilderClass = (context, className, msg) => {
+  const staticMethods = getMessageProperties(msg).map(schema => {
+    return createStaticExecMethodMsgBuilder(context, schema, msg.title);
+  }); // const blockStmt = bindings;
+
+  return t.exportNamedDeclaration(abstractClassDeclaration(className, staticMethods, [], null));
+};
+/**
+ * CamelCasedProperties<Extract<ExecuteMsg, { exec_on_module: unknown }>['exec_on_module']>
+ */
+
+function createExtractTypeAnnotation(underscoreName, msgTitle) {
+  return t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CamelCasedProperties'), t.tsTypeParameterInstantiation([t.tsIndexedAccessType(t.tsTypeReference(t.identifier('Extract'), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(msgTitle)), t.tsTypeLiteral([t.tsPropertySignature(t.identifier(underscoreName), t.tsTypeAnnotation(t.tsUnknownKeyword()))])])), t.tsLiteralType(t.stringLiteral(underscoreName)))])));
+}
+
+const createStaticExecMethodMsgBuilder = (context, jsonschema, msgTitle) => {
+  const underscoreName = Object.keys(jsonschema.properties)[0];
+  const methodName = camel(underscoreName);
+  const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]); // what the underscore named property in the message is assigned to
+
+  let actionValue;
+
+  if (param?.type === 'Identifier') {
+    actionValue = t.identifier(param.name);
+  } else {
+    actionValue = t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const')));
+  } // TODO: this is a hack to get the type annotation to work
+  // all type annotations in the future should be the extracted and camelized type
+
+
+  if (param && param.typeAnnotation.type === 'TSTypeAnnotation' && param.typeAnnotation.typeAnnotation.type === 'TSTypeLiteral') {
+    param.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle);
+  }
+
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression( // params
+  param ? [// props
+  param] : [], // body
+  t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier(underscoreName), actionValue)]))]), // return type
+  t.tsTypeAnnotation(t.tsTypeReference(t.identifier(msgTitle))), false), null, null, false, // static
+  true);
+};

package/module/msg-builder/msg-builder.spec.js

@@ -0,0 +1,17 @@
+import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
+import query_msg from '../../../../__fixtures__/basic/query_msg.json';
+import ownership from '../../../../__fixtures__/basic/ownership.json';
+import { createMsgBuilderClass } from './msg-builder';
+import { expectCode, makeContext } from '../../test-utils';
+it('execute class', () => {
+  const ctx = makeContext(execute_msg);
+  expectCode(createMsgBuilderClass(ctx, 'SG721MsgBuilder', execute_msg));
+});
+it('query class', () => {
+  const ctx = makeContext(query_msg);
+  expectCode(createMsgBuilderClass(ctx, 'SG721MsgBuilder', query_msg));
+});
+it('ownership', () => {
+  const ctx = makeContext(ownership);
+  expectCode(createMsgBuilderClass(ctx, 'Ownership', ownership));
+});

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

@@ -1,6 +1,7 @@
 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 ownership from '../../../../__fixtures__/basic/ownership.json';
 import { createReactQueryHooks, createReactQueryMutationHooks } from './react-query';
 import { expectCode, makeContext } from '../../test-utils';
 const execCtx = makeContext(execute_msg);
@@ -62,4 +63,13 @@ it('createReactQueryHooks', () => {
     contractName: 'Sg721',
     ExecuteClient: 'Sg721Client'
   })));
+});
+it('ownership', () => {
+  const ownershipCtx = makeContext(ownership);
+  expectCode(t.program(createReactQueryMutationHooks({
+    context: ownershipCtx,
+    execMsg: ownership,
+    contractName: 'Ownership',
+    ExecuteClient: 'OwnershipClient'
+  })));
 });

package/module/utils/babel.js

@@ -1,6 +1,7 @@
 import * as t from '@babel/types';
 import { snake } from "case";
-// t.TSPropertySignature - kind?
+import { refLookup } from './ref'; // t.TSPropertySignature - kind?
+
 export const propertySignature = (name, typeAnnotation, optional = false) => {
   return {
     type: 'TSPropertySignature',
@@ -21,10 +22,30 @@ export const tsTypeOperator = (typeAnnotation, operator) => {
   return obj;
 };
 export const getMessageProperties = msg => {
-  if (msg.anyOf) return msg.anyOf;
-  if (msg.oneOf) return msg.oneOf;
-  if (msg.allOf) return msg.allOf;
-  return [];
+  let results = [];
+  let objs = [];
+
+  if (msg.anyOf) {
+    objs = msg.anyOf;
+  } else if (msg.oneOf) {
+    objs = msg.oneOf;
+  } else if (msg.allOf) {
+    objs = msg.allOf;
+  }
+
+  for (const obj of objs) {
+    if (obj.properties) {
+      results.push(obj);
+    } else {
+      if (obj.$ref) {
+        const ref = refLookup(obj.$ref, msg);
+        const refProps = getMessageProperties(ref);
+        results = [...results, ...refProps];
+      }
+    }
+  }
+
+  return results;
 };
 export const tsPropertySignature = (key, typeAnnotation, optional) => {
   const obj = t.tsPropertySignature(key, typeAnnotation);
@@ -53,6 +74,11 @@ export const typedIdentifier = (name, typeAnnotation, optional = false) => {
 export const promiseTypeAnnotation = name => {
   return t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(name))])));
 };
+export const abstractClassDeclaration = (name, body, implementsExressions = [], superClass = null) => {
+  const declaration = classDeclaration(name, body, implementsExressions, superClass);
+  declaration.abstract = true;
+  return declaration;
+};
 export const classDeclaration = (name, body, implementsExressions = [], superClass = null) => {
   const declaration = t.classDeclaration(t.identifier(name), superClass, t.classBody(body));
 

package/module/utils/index.js

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

package/module/utils/ref.js

@@ -0,0 +1,4 @@
+export const refLookup = ($ref, schema) => {
+  const refName = $ref.replace('#/definitions/', '');
+  return schema.definitions?.[refName];
+};

package/module/utils/types.js

@@ -322,9 +322,16 @@ export const createTypedObjectParams = (context, jsonschema, camelize = true) =>
   if (!keys.length) {
     // is there a ref?
     if (jsonschema.$ref) {
-      const obj = context.refLookup(jsonschema.$ref);
-
-      if (obj) {
+      const obj = context.refLookup(jsonschema.$ref); // If there is a oneOf, then we need to create a type for it
+
+      if (obj?.oneOf) {
+        // the actual type of the ref
+        const refType = jsonschema.$ref.split('/').pop();
+        const refName = camel(refType);
+        const id = t.identifier(refName);
+        id.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(refType)));
+        return id;
+      } else if (obj) {
         return createTypedObjectParams(context, obj, camelize);
       }
     } // no results...

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-ast-types",
-  "version": "0.18.2",
+  "version": "0.20.0",
   "description": "CosmWasm TypeScript AST generation",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "homepage": "https://github.com/pyramation/cosmwasm-typescript-gen/tree/master/packages/wasm-ast-types#readme",
@@ -88,5 +88,5 @@
     "case": "1.6.3",
     "deepmerge": "4.2.2"
   },
-  "gitHead": "a980b8040099876a056027f4bb45e83de86fb278"
+  "gitHead": "d2edba320c63e2db5fe2db0bfb1f4cd5e44f2188"
 }