wasm-ast-types 0.19.0 → 0.21.0

package/src/msg-builder/msg-builder.ts

@@ -1,16 +1,11 @@
-import * as t from "@babel/types";
-import { camel } from "case";
-import {
-  abstractClassDeclaration,
-  arrowFunctionExpression,
-  bindMethod,
-  classDeclaration,
-  getMessageProperties,
-} from "../utils";
-import { ExecuteMsg, QueryMsg } from "../types";
-import { createTypedObjectParams } from "../utils/types";
-import { RenderContext } from "../context";
-import { getWasmMethodArgs } from "../client/client";
+import * as t from '@babel/types';
+import { camel } from 'case';
+import { abstractClassDeclaration, arrowFunctionExpression, getMessageProperties } from '../utils';
+import { ExecuteMsg, QueryMsg } from '../types';
+import { createTypedObjectParams } from '../utils/types';
+import { RenderContext } from '../context';
+import { getWasmMethodArgs } from '../client/client';
+import { Expression, Identifier, PatternLike, TSAsExpression } from '@babel/types';
 
 export const createMsgBuilderClass = (
   context: RenderContext,
@@ -34,10 +29,10 @@ export const createMsgBuilderClass = (
 function createExtractTypeAnnotation(underscoreName: string, msgTitle: string) {
   return t.tsTypeAnnotation(
     t.tsTypeReference(
-      t.identifier("CamelCasedProperties"),
+      t.identifier('CamelCasedProperties'),
       t.tsTypeParameterInstantiation([
         t.tsIndexedAccessType(
-          t.tsTypeReference(t.identifier("Extract"),
+          t.tsTypeReference(t.identifier('Extract'),
             t.tsTypeParameterInstantiation([
               t.tsTypeReference(t.identifier(msgTitle)),
               t.tsTypeLiteral([
@@ -62,7 +57,7 @@ const createStaticExecMethodMsgBuilder = (
 ) => {
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const obj = createTypedObjectParams(
+  const param = createTypedObjectParams(
     context,
     jsonschema.properties[underscoreName]
   );
@@ -71,17 +66,34 @@ const createStaticExecMethodMsgBuilder = (
     jsonschema.properties[underscoreName]
   );
 
-  if (obj) obj.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle)
+  // what the underscore named property in the message is assigned to
+  let actionValue: Expression
+  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
-      obj
+      param
         ? [
-            // props
-            obj,
-          ]
+          // props
+          param
+        ]
         : [],
       // body
       t.blockStatement([
@@ -89,10 +101,10 @@ const createStaticExecMethodMsgBuilder = (
           t.objectExpression([
             t.objectProperty(
               t.identifier(underscoreName),
-              t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const')))
-            ),
+              actionValue
+            )
           ])
-        ),
+        )
       ]),
       // return type
       t.tsTypeAnnotation(t.tsTypeReference(t.identifier(msgTitle))),

package/src/react-query/__snapshots__/react-query.spec.ts.snap

@@ -1312,3 +1312,48 @@ export function useSg721TransferNftMutation(options?: Omit<UseMutationOptions<Ex
   }) => client.transferNft(msg, fee, memo, funds), options);
 }"
 `;
+
+exports[`ownership 1`] = `
+"export interface OwnershipUpdateOwnershipMutation {
+  client: OwnershipClient;
+  msg: Action;
+  args?: {
+    fee?: number | StdFee | \\"auto\\";
+    memo?: string;
+    funds?: Coin[];
+  };
+}
+export function useOwnershipUpdateOwnershipMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, OwnershipUpdateOwnershipMutation>, \\"mutationFn\\">) {
+  return useMutation<ExecuteResult, Error, OwnershipUpdateOwnershipMutation>(({
+    client,
+    msg,
+    args: {
+      fee,
+      memo,
+      funds
+    } = {}
+  }) => client.updateOwnership(msg, fee, memo, funds), options);
+}
+export interface OwnershipSetFactoryMutation {
+  client: OwnershipClient;
+  msg: {
+    newFactory: string;
+  };
+  args?: {
+    fee?: number | StdFee | \\"auto\\";
+    memo?: string;
+    funds?: Coin[];
+  };
+}
+export function useOwnershipSetFactoryMutation(options?: Omit<UseMutationOptions<ExecuteResult, Error, OwnershipSetFactoryMutation>, \\"mutationFn\\">) {
+  return useMutation<ExecuteResult, Error, OwnershipSetFactoryMutation>(({
+    client,
+    msg,
+    args: {
+      fee,
+      memo,
+      funds
+    } = {}
+  }) => client.setFactory(msg, fee, memo, funds), options);
+}"
+`;

package/src/react-query/react-query.spec.ts

@@ -1,13 +1,15 @@
 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 ownership from '../../../../__fixtures__/basic/ownership.json';
+
 
 import {
   createReactQueryHooks,
   createReactQueryMutationHooks,
 } from './react-query'
 import { expectCode, makeContext } from '../../test-utils';
+import { createMsgBuilderClass } from '../msg-builder';
 
 const execCtx = makeContext(execute_msg);
 const queryCtx = makeContext(query_msg);
@@ -90,3 +92,17 @@ it('createReactQueryHooks', () => {
     )))
 });
 
+it('ownership', () => {
+  const ownershipCtx = makeContext(ownership);
+  expectCode(t.program(
+    createReactQueryMutationHooks(
+      {
+        context: ownershipCtx,
+        execMsg: ownership,
+        contractName: 'Ownership',
+        ExecuteClient: 'OwnershipClient',
+      }
+    )))
+});
+
+

package/src/utils/types.ts

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { camel, pascal } from 'case';
+import { camel, pascal, snake } from 'case';
 import { propertySignature } from './babel';
 import { TSTypeAnnotation } from '@babel/types';
 import { RenderContext } from '../context';
@@ -425,15 +425,22 @@ export const createTypedObjectParams = (
   context: RenderContext,
   jsonschema: JSONSchema,
   camelize: boolean = true
-): t.ObjectPattern => {
+): (t.Identifier | t.Pattern | t.RestElement) => {
 
   const keys = Object.keys(jsonschema.properties ?? {});
   if (!keys.length) {
-
     // is there a ref?
     if (jsonschema.$ref) {
       const obj = context.refLookup(jsonschema.$ref);
-      if (obj) {
+      // 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,