wasm-ast-types 0.19.0 → 0.21.0

package/src/client/client.ts

@@ -1,23 +1,19 @@
 import * as t from '@babel/types';
-import { camel, pascal } from 'case';
+import { camel } from 'case';
 import {
+  arrowFunctionExpression,
   bindMethod,
-  typedIdentifier,
-  promiseTypeAnnotation,
   classDeclaration,
   classProperty,
-  arrowFunctionExpression,
-  getMessageProperties
-} from '../utils'
+  getMessageProperties,
+  promiseTypeAnnotation,
+  typedIdentifier
+} from '../utils';
 
-import {
-  QueryMsg,
-  ExecuteMsg
-} from '../types';
+import { ExecuteMsg, JSONSchema, QueryMsg } from '../types';
 
-import { getPropertyType, getType, createTypedObjectParams, getResponseType } from '../utils/types';
+import { createTypedObjectParams, getPropertyType, getResponseType, getType } from '../utils/types';
 import { RenderContext } from '../context';
-import { JSONSchema } from '../types';
 import { identifier, propertySignature } from '../utils/babel';
 
 export const CONSTANT_EXEC_PARAMS = [
@@ -89,7 +85,7 @@ export const createWasmQueryMethod = (
   const methodName = camel(underscoreName);
   const responseType = getResponseType(context, underscoreName);
 
-  const obj = createTypedObjectParams(
+  const param = createTypedObjectParams(
     context,
     jsonschema.properties[underscoreName]
   );
@@ -99,13 +95,14 @@ export const createWasmQueryMethod = (
     jsonschema.properties[underscoreName]
   );
 
-  const actionArg =
-    t.objectProperty(t.identifier(underscoreName), t.objectExpression(args));
+  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(
-      obj ? [obj] : [],
+      param ? [param] : [],
       t.blockStatement(
         [
           t.returnStatement(
@@ -120,7 +117,7 @@ export const createWasmQueryMethod = (
               [
                 t.memberExpression(t.thisExpression(), t.identifier('contractAddress')),
                 t.objectExpression([
-                  actionArg
+                  t.objectProperty(msgAction, msgActionValue)
                 ])
               ]
             )
@@ -237,9 +234,15 @@ export const getWasmMethodArgs = (
   // only 1 degree $ref-lookup
   if (!keys.length && 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
+    }
   }
 
   const args = keys.map(prop => {
@@ -265,7 +268,7 @@ export const createWasmExecMethod = (
 
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
-  const obj = createTypedObjectParams(
+  const param = createTypedObjectParams(
     context,
     jsonschema.properties[underscoreName]
   );
@@ -274,12 +277,16 @@ export const createWasmExecMethod = (
     jsonschema.properties[underscoreName]
   );
 
+  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(
-      obj ? [
+      param ? [
         // props
-        obj,
+        param,
         ...CONSTANT_EXEC_PARAMS
       ] : CONSTANT_EXEC_PARAMS,
       t.blockStatement(
@@ -306,10 +313,8 @@ export const createWasmExecMethod = (
                   t.objectExpression(
                     [
                       t.objectProperty(
-                        t.identifier(underscoreName),
-                        t.objectExpression([
-                          ...args
-                        ])
+                        msgAction,
+                        msgActionValue
                       )
 
                     ]

package/src/client/test/__snapshots__/ts-client.issue-101.spec.ts.snap

@@ -0,0 +1,47 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`execute interfaces no extends 1`] = `
+"export interface OwnershipInstance {
+  contractAddress: string;
+  sender: string;
+  setFactory: ({
+    newFactory
+  }: {
+    newFactory: string;
+  }, fee?: number | StdFee | \\"auto\\", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+  updateOwnership: (action: Action, fee?: number | StdFee | \\"auto\\", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+}"
+`;
+
+exports[`ownership client with tuple 1`] = `
+"export class OwnershipClient implements OwnershipInstance {
+  client: SigningCosmWasmClient;
+  sender: string;
+  contractAddress: string;
+
+  constructor(client: SigningCosmWasmClient, sender: string, contractAddress: string) {
+    this.client = client;
+    this.sender = sender;
+    this.contractAddress = contractAddress;
+    this.setFactory = this.setFactory.bind(this);
+    this.updateOwnership = this.updateOwnership.bind(this);
+  }
+
+  setFactory = async ({
+    newFactory
+  }: {
+    newFactory: string;
+  }, fee: number | StdFee | \\"auto\\" = \\"auto\\", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      set_factory: {
+        new_factory: newFactory
+      }
+    }, fee, memo, funds);
+  };
+  updateOwnership = async (action: Action, fee: number | StdFee | \\"auto\\" = \\"auto\\", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      update_ownership: action
+    }, fee, memo, funds);
+  };
+}"
+`;

package/src/client/test/__snapshots__/ts-client.issue-103.test.ts.snap

@@ -0,0 +1,79 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`execute execute classes array types 1`] = `
+"export class Client implements Instance {
+  client: SigningCosmWasmClient;
+  sender: string;
+  contractAddress: string;
+
+  constructor(client: SigningCosmWasmClient, sender: string, contractAddress: string) {
+    this.client = client;
+    this.sender = sender;
+    this.contractAddress = contractAddress;
+  }
+
+}"
+`;
+
+exports[`execute execute interfaces no extends 1`] = `
+"export interface SG721Instance {
+  contractAddress: string;
+  sender: string;
+}"
+`;
+
+exports[`execute execute_msg_for__empty 1`] = `"export type ExecuteMsg = ExecuteMsg;"`;
+
+exports[`execute query classes 1`] = `
+"export class QueryClient implements ReadOnlyInstance {
+  client: CosmWasmClient;
+  contractAddress: string;
+
+  constructor(client: CosmWasmClient, contractAddress: string) {
+    this.client = client;
+    this.contractAddress = contractAddress;
+  }
+
+}"
+`;
+
+exports[`execute query classes response 1`] = `"export type QueryMsg = QueryMsg;"`;
+
+exports[`query execute classes array types 1`] = `
+"export class Client implements Instance {
+  client: SigningCosmWasmClient;
+  sender: string;
+  contractAddress: string;
+
+  constructor(client: SigningCosmWasmClient, sender: string, contractAddress: string) {
+    this.client = client;
+    this.sender = sender;
+    this.contractAddress = contractAddress;
+  }
+
+}"
+`;
+
+exports[`query execute interfaces no extends 1`] = `
+"export interface SG721Instance {
+  contractAddress: string;
+  sender: string;
+}"
+`;
+
+exports[`query execute_msg_for__empty 1`] = `"export type QueryMsg = QueryMsg;"`;
+
+exports[`query query classes 1`] = `
+"export class QueryClient implements ReadOnlyInstance {
+  client: CosmWasmClient;
+  contractAddress: string;
+
+  constructor(client: CosmWasmClient, contractAddress: string) {
+    this.client = client;
+    this.contractAddress = contractAddress;
+  }
+
+}"
+`;
+
+exports[`query query classes response 1`] = `"export type QueryMsg = QueryMsg;"`;

package/src/client/test/__snapshots__/ts-client.vectis.spec.ts.snap

@@ -193,9 +193,9 @@ exports[`query classes 1`] = `
     this.wasm = this.wasm.bind(this);
   }
 
-  bank = async (): Promise<BankResponse> => {
+  bank = async (bankMsg: BankMsg): Promise<BankResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
-      bank: {}
+      bank: bankMsg
     });
   };
   custom = async (): Promise<CustomResponse> => {
@@ -203,19 +203,19 @@ exports[`query classes 1`] = `
       custom: {}
     });
   };
-  staking = async (): Promise<StakingResponse> => {
+  staking = async (stakingMsg: StakingMsg): Promise<StakingResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
-      staking: {}
+      staking: stakingMsg
     });
   };
-  distribution = async (): Promise<DistributionResponse> => {
+  distribution = async (distributionMsg: DistributionMsg): Promise<DistributionResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
-      distribution: {}
+      distribution: distributionMsg
     });
   };
-  wasm = async (): Promise<WasmResponse> => {
+  wasm = async (wasmMsg: WasmMsg): Promise<WasmResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
-      wasm: {}
+      wasm: wasmMsg
     });
   };
 }"

package/src/client/test/ts-client.issue-101.spec.ts

@@ -0,0 +1,37 @@
+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/src/client/test/ts-client.issue-103.test.ts

@@ -0,0 +1,106 @@
+import contract from '../../../../../__fixtures__/issues/103/schema.json';
+
+import {
+    createQueryClass,
+    createExecuteClass,
+    createExecuteInterface,
+    createTypeInterface
+} from '../client'
+import { expectCode, printCode, makeContext } from '../../../test-utils';
+
+const queryMessage = contract.query
+const executeMessage = contract.execute
+const queryCtx = makeContext(queryMessage);
+const executeCtx = makeContext(executeMessage);
+
+describe('query', () => {
+    it('execute_msg_for__empty', () => {
+        expectCode(createTypeInterface(
+            queryCtx,
+            queryMessage
+        ))
+    })
+
+
+    it('query classes', () => {
+        expectCode(createQueryClass(
+            queryCtx,
+            'QueryClient',
+            'ReadOnlyInstance',
+            queryMessage
+        ))
+    });
+
+    it('query classes response', () => {
+        expectCode(createTypeInterface(
+            queryCtx,
+            contract.query
+        ))
+    });
+
+    it('execute classes array types', () => {
+        expectCode(createExecuteClass(
+            queryCtx,
+            'Client',
+            'Instance',
+            null,
+            queryMessage
+        ))
+    });
+
+    it('execute interfaces no extends', () => {
+        expectCode(createExecuteInterface(
+            queryCtx,
+            'SG721Instance',
+            null,
+            queryMessage
+        ))
+    });
+
+});
+
+describe('execute', () => {
+    it('execute_msg_for__empty', () => {
+        expectCode(createTypeInterface(
+            executeCtx,
+            executeMessage
+        ))
+    })
+
+
+    it('query classes', () => {
+        expectCode(createQueryClass(
+            executeCtx,
+            'QueryClient',
+            'ReadOnlyInstance',
+            executeMessage
+        ))
+    });
+
+    it('query classes response', () => {
+        expectCode(createTypeInterface(
+            executeCtx,
+            contract.query
+        ))
+    });
+
+    it('execute classes array types', () => {
+        expectCode(createExecuteClass(
+            executeCtx,
+            'Client',
+            'Instance',
+            null,
+            executeMessage
+        ))
+    });
+
+    it('execute interfaces no extends', () => {
+        expectCode(createExecuteInterface(
+            executeCtx,
+            'SG721Instance',
+            null,
+            executeMessage
+        ))
+    });
+
+});

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

@@ -113,6 +113,27 @@ exports[`execute class 1`] = `
 }"
 `;
 
+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 = ({

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

@@ -1,9 +1,12 @@
 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);
@@ -12,6 +15,11 @@ it('execute class', () => {
 
 
 it('query class', () => {
-  const ctx = makeContext(execute_msg);
+  const ctx = makeContext(query_msg);
   expectCode(createMsgBuilderClass(ctx, 'SG721MsgBuilder', query_msg))
 });
+
+it('ownership', () => {
+  const ctx = makeContext(ownership);
+  expectCode(createMsgBuilderClass(ctx, 'Ownership', ownership))
+});