wasm-ast-types 0.18.2 → 0.20.0

package/src/message-composer/__snapshots__/message-composer.spec.ts.snap

@@ -269,3 +269,63 @@ exports[`execute classes 1`] = `
   };
 }"
 `;
+
+exports[`ownershipClass 1`] = `
+"export class OwnershipMessageComposer implements OwnershipMessage {
+  sender: string;
+  contractAddress: string;
+
+  constructor(sender: string, contractAddress: string) {
+    this.sender = sender;
+    this.contractAddress = contractAddress;
+    this.setFactory = this.setFactory.bind(this);
+    this.updateOwnership = this.updateOwnership.bind(this);
+  }
+
+  setFactory = ({
+    newFactory
+  }: {
+    newFactory: string;
+  }, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          set_factory: {
+            new_factory: newFactory
+          }
+        })),
+        funds
+      })
+    };
+  };
+  updateOwnership = (action: Action, funds?: Coin[]): MsgExecuteContractEncodeObject => {
+    return {
+      typeUrl: \\"/cosmwasm.wasm.v1.MsgExecuteContract\\",
+      value: MsgExecuteContract.fromPartial({
+        sender: this.sender,
+        contract: this.contractAddress,
+        msg: toUtf8(JSON.stringify({
+          update_ownership: action
+        })),
+        funds
+      })
+    };
+  };
+}"
+`;
+
+exports[`ownershipInterface 1`] = `
+"export interface OwnershipMessage {
+  contractAddress: string;
+  sender: string;
+  setFactory: ({
+    newFactory
+  }: {
+    newFactory: string;
+  }, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+  updateOwnership: (action: Action, funds?: Coin[]) => MsgExecuteContractEncodeObject;
+}"
+`;

package/src/message-composer/message-composer.spec.ts

@@ -1,25 +1,46 @@
-import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
+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';
+  createMessageComposerClass,
+  createMessageComposerInterface,
+} from "./message-composer";
+import { expectCode, makeContext } from "../../test-utils";
+import * as t from "@babel/types";
+import { createReactQueryMutationHooks } from "../react-query";
+
+it("execute classes", () => {
+  const ctx = makeContext(execute_msg);
+  expectCode(
+    createMessageComposerClass(
+      ctx,
+      "SG721MessageComposer",
+      "SG721Message",
+      execute_msg
+    )
+  );
+});
+
+it("createMessageComposerInterface", () => {
+  const ctx = makeContext(execute_msg);
+  expectCode(createMessageComposerInterface(ctx, "SG721Message", execute_msg));
+});
 
-it('execute classes', () => {
-    const ctx = makeContext(execute_msg);
-    expectCode(createMessageComposerClass(
-        ctx,
-        'SG721MessageComposer',
-        'SG721Message',
-        execute_msg
-    ))
+it("ownershipClass", () => {
+  const ctx = makeContext(ownership);
+  expectCode(
+    createMessageComposerClass(
+      ctx,
+      "OwnershipMessageComposer",
+      "OwnershipMessage",
+      ownership
+    )
+  );
 });
 
-it('createMessageComposerInterface', () => {
-    const ctx = makeContext(execute_msg);
-    expectCode(createMessageComposerInterface(
-        ctx,
-        'SG721Message',
-        execute_msg
-    ))
+it("ownershipInterface", () => {
+  const ownershipCtx = makeContext(ownership);
+  expectCode(
+    createMessageComposerInterface(ownershipCtx, "OwnershipMessage", ownership)
+  );
 });

package/src/message-composer/message-composer.ts

@@ -14,6 +14,7 @@ import { JSONSchema } from '../types';
 import { RenderContext } from '../context';
 import { identifier } from '../utils/babel';
 import { getWasmMethodArgs } from '../client/client';
+import { Expression } from '@babel/types';
 
 const createWasmExecMethodMessageComposer = (
     context: RenderContext,
@@ -27,12 +28,20 @@ const createWasmExecMethodMessageComposer = (
 
     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]
     );
 
+  // 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.objectExpression(args)
+  }
+
     const constantParams = [
         identifier('funds', t.tsTypeAnnotation(
             t.tsArrayType(
@@ -46,9 +55,9 @@ const createWasmExecMethodMessageComposer = (
     return t.classProperty(
         t.identifier(methodName),
         arrowFunctionExpression(
-            obj ? [
+            param ? [
                 // props
-                obj,
+                param,
                 ...constantParams
             ] : constantParams,
             t.blockStatement(
@@ -95,10 +104,9 @@ const createWasmExecMethodMessageComposer = (
                                                             ),
                                                             [
                                                                 t.objectExpression(
-
                                                                     [
                                                                         t.objectProperty(
-                                                                            t.identifier(underscoreName), t.objectExpression(args)
+                                                                            t.identifier(underscoreName), actionValue
                                                                         )
                                                                     ]
 

package/src/msg-builder/__snapshots__/msg-builder.spec.ts.snap

@@ -0,0 +1,270 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`execute class 1`] = `
+"export abstract class SG721MsgBuilder {
+  static transferNft = ({
+    recipient,
+    tokenId
+  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
+    transfer_nft: unknown;
+  }>[\\"transfer_nft\\"]>): ExecuteMsg_for_Empty => {
+    return {
+      transfer_nft: ({
+        recipient,
+        token_id: tokenId
+      } as const)
+    };
+  };
+  static sendNft = ({
+    contract,
+    msg,
+    tokenId
+  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
+    send_nft: unknown;
+  }>[\\"send_nft\\"]>): ExecuteMsg_for_Empty => {
+    return {
+      send_nft: ({
+        contract,
+        msg,
+        token_id: tokenId
+      } as const)
+    };
+  };
+  static approve = ({
+    expires,
+    spender,
+    tokenId
+  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
+    approve: unknown;
+  }>[\\"approve\\"]>): ExecuteMsg_for_Empty => {
+    return {
+      approve: ({
+        expires,
+        spender,
+        token_id: tokenId
+      } as const)
+    };
+  };
+  static revoke = ({
+    spender,
+    tokenId
+  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
+    revoke: unknown;
+  }>[\\"revoke\\"]>): ExecuteMsg_for_Empty => {
+    return {
+      revoke: ({
+        spender,
+        token_id: tokenId
+      } as const)
+    };
+  };
+  static approveAll = ({
+    expires,
+    operator
+  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
+    approve_all: unknown;
+  }>[\\"approve_all\\"]>): ExecuteMsg_for_Empty => {
+    return {
+      approve_all: ({
+        expires,
+        operator
+      } as const)
+    };
+  };
+  static revokeAll = ({
+    operator
+  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
+    revoke_all: unknown;
+  }>[\\"revoke_all\\"]>): ExecuteMsg_for_Empty => {
+    return {
+      revoke_all: ({
+        operator
+      } as const)
+    };
+  };
+  static mint = ({
+    extension,
+    owner,
+    tokenId,
+    tokenUri
+  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
+    mint: unknown;
+  }>[\\"mint\\"]>): ExecuteMsg_for_Empty => {
+    return {
+      mint: ({
+        extension,
+        owner,
+        token_id: tokenId,
+        token_uri: tokenUri
+      } as const)
+    };
+  };
+  static burn = ({
+    tokenId
+  }: CamelCasedProperties<Extract<ExecuteMsg_for_Empty, {
+    burn: unknown;
+  }>[\\"burn\\"]>): ExecuteMsg_for_Empty => {
+    return {
+      burn: ({
+        token_id: tokenId
+      } as const)
+    };
+  };
+}"
+`;
+
+exports[`ownership 1`] = `
+"export abstract class Ownership {
+  static setFactory = ({
+    newFactory
+  }: CamelCasedProperties<Extract<ExecuteMsg, {
+    set_factory: unknown;
+  }>[\\"set_factory\\"]>): ExecuteMsg => {
+    return {
+      set_factory: ({
+        new_factory: newFactory
+      } as const)
+    };
+  };
+  static updateOwnership = (action: Action): ExecuteMsg => {
+    return {
+      update_ownership: action
+    };
+  };
+}"
+`;
+
+exports[`query class 1`] = `
+"export abstract class SG721MsgBuilder {
+  static ownerOf = ({
+    includeExpired,
+    tokenId
+  }: CamelCasedProperties<Extract<QueryMsg, {
+    owner_of: unknown;
+  }>[\\"owner_of\\"]>): QueryMsg => {
+    return {
+      owner_of: ({
+        include_expired: includeExpired,
+        token_id: tokenId
+      } as const)
+    };
+  };
+  static approval = ({
+    includeExpired,
+    spender,
+    tokenId
+  }: CamelCasedProperties<Extract<QueryMsg, {
+    approval: unknown;
+  }>[\\"approval\\"]>): QueryMsg => {
+    return {
+      approval: ({
+        include_expired: includeExpired,
+        spender,
+        token_id: tokenId
+      } as const)
+    };
+  };
+  static approvals = ({
+    includeExpired,
+    tokenId
+  }: CamelCasedProperties<Extract<QueryMsg, {
+    approvals: unknown;
+  }>[\\"approvals\\"]>): QueryMsg => {
+    return {
+      approvals: ({
+        include_expired: includeExpired,
+        token_id: tokenId
+      } as const)
+    };
+  };
+  static allOperators = ({
+    includeExpired,
+    limit,
+    owner,
+    startAfter
+  }: CamelCasedProperties<Extract<QueryMsg, {
+    all_operators: unknown;
+  }>[\\"all_operators\\"]>): QueryMsg => {
+    return {
+      all_operators: ({
+        include_expired: includeExpired,
+        limit,
+        owner,
+        start_after: startAfter
+      } as const)
+    };
+  };
+  static numTokens = (): QueryMsg => {
+    return {
+      num_tokens: ({} as const)
+    };
+  };
+  static contractInfo = (): QueryMsg => {
+    return {
+      contract_info: ({} as const)
+    };
+  };
+  static nftInfo = ({
+    tokenId
+  }: CamelCasedProperties<Extract<QueryMsg, {
+    nft_info: unknown;
+  }>[\\"nft_info\\"]>): QueryMsg => {
+    return {
+      nft_info: ({
+        token_id: tokenId
+      } as const)
+    };
+  };
+  static allNftInfo = ({
+    includeExpired,
+    tokenId
+  }: CamelCasedProperties<Extract<QueryMsg, {
+    all_nft_info: unknown;
+  }>[\\"all_nft_info\\"]>): QueryMsg => {
+    return {
+      all_nft_info: ({
+        include_expired: includeExpired,
+        token_id: tokenId
+      } as const)
+    };
+  };
+  static tokens = ({
+    limit,
+    owner,
+    startAfter
+  }: CamelCasedProperties<Extract<QueryMsg, {
+    tokens: unknown;
+  }>[\\"tokens\\"]>): QueryMsg => {
+    return {
+      tokens: ({
+        limit,
+        owner,
+        start_after: startAfter
+      } as const)
+    };
+  };
+  static allTokens = ({
+    limit,
+    startAfter
+  }: CamelCasedProperties<Extract<QueryMsg, {
+    all_tokens: unknown;
+  }>[\\"all_tokens\\"]>): QueryMsg => {
+    return {
+      all_tokens: ({
+        limit,
+        start_after: startAfter
+      } as const)
+    };
+  };
+  static minter = (): QueryMsg => {
+    return {
+      minter: ({} as const)
+    };
+  };
+  static collectionInfo = (): QueryMsg => {
+    return {
+      collection_info: ({} as const)
+    };
+  };
+}"
+`;

package/src/msg-builder/index.ts

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

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

@@ -0,0 +1,25 @@
+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';
+import { findExecuteMsg } from '@cosmwasm/ts-codegen/src';
+
+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/src/msg-builder/msg-builder.ts

@@ -0,0 +1,119 @@
+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,
+  className: string,
+  msg: ExecuteMsg | QueryMsg
+): t.ExportNamedDeclaration => {
+  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: string, msgTitle: string) {
+  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: RenderContext,
+  jsonschema: any,
+  msgTitle: string
+) => {
+  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: 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
+      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/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/react-query/react-query.ts

@@ -432,7 +432,7 @@ export const createReactQueryMutationArgsInterface = ({
             // @ts-ignore:next-line
             param.typeAnnotation,
             param.optional
-          )
+          ) as t.TSTypeElement
         )
       )
     )