wasm-ast-types 0.18.2 → 0.20.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-98.test.ts.snap

@@ -0,0 +1,117 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`execute classes array types 1`] = `
+"export class SG721Client implements SG721Instance {
+  client: SigningCosmWasmClient;
+  sender: string;
+  contractAddress: string;
+
+  constructor(client: SigningCosmWasmClient, sender: string, contractAddress: string) {
+    this.client = client;
+    this.sender = sender;
+    this.contractAddress = contractAddress;
+    this.getConfig = this.getConfig.bind(this);
+    this.getPlugins = this.getPlugins.bind(this);
+    this.getPluginById = this.getPluginById.bind(this);
+  }
+
+  getConfig = async (fee: number | StdFee | \\"auto\\" = \\"auto\\", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      get_config: {}
+    }, fee, memo, funds);
+  };
+  getPlugins = async ({
+    limit,
+    startAfter
+  }: {
+    limit?: number;
+    startAfter?: number;
+  }, fee: number | StdFee | \\"auto\\" = \\"auto\\", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      get_plugins: {
+        limit,
+        start_after: startAfter
+      }
+    }, fee, memo, funds);
+  };
+  getPluginById = async ({
+    id
+  }: {
+    id: number;
+  }, fee: number | StdFee | \\"auto\\" = \\"auto\\", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
+    return await this.client.execute(this.sender, this.contractAddress, {
+      get_plugin_by_id: {
+        id
+      }
+    }, fee, memo, funds);
+  };
+}"
+`;
+
+exports[`execute interfaces no extends 1`] = `
+"export interface SG721Instance {
+  contractAddress: string;
+  sender: string;
+  getConfig: (fee?: number | StdFee | \\"auto\\", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+  getPlugins: ({
+    limit,
+    startAfter
+  }: {
+    limit?: number;
+    startAfter?: number;
+  }, fee?: number | StdFee | \\"auto\\", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+  getPluginById: ({
+    id
+  }: {
+    id: number;
+  }, fee?: number | StdFee | \\"auto\\", memo?: string, funds?: Coin[]) => Promise<ExecuteResult>;
+}"
+`;
+
+exports[`execute_msg_for__empty 1`] = `"export type QueryMsg = QueryMsg;"`;
+
+exports[`query classes 1`] = `
+"export class SG721QueryClient implements SG721ReadOnlyInstance {
+  client: CosmWasmClient;
+  contractAddress: string;
+
+  constructor(client: CosmWasmClient, contractAddress: string) {
+    this.client = client;
+    this.contractAddress = contractAddress;
+    this.getConfig = this.getConfig.bind(this);
+    this.getPlugins = this.getPlugins.bind(this);
+    this.getPluginById = this.getPluginById.bind(this);
+  }
+
+  getConfig = async (): Promise<GetConfigResponse> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      get_config: {}
+    });
+  };
+  getPlugins = async ({
+    limit,
+    startAfter
+  }: {
+    limit?: number;
+    startAfter?: number;
+  }): Promise<GetPluginsResponse> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      get_plugins: {
+        limit,
+        start_after: startAfter
+      }
+    });
+  };
+  getPluginById = async ({
+    id
+  }: {
+    id: number;
+  }): Promise<GetPluginByIdResponse> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      get_plugin_by_id: {
+        id
+      }
+    });
+  };
+}"
+`;

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-98.test.ts

@@ -0,0 +1,55 @@
+import contract from '../../../../../__fixtures__/issues/98/schema.json';
+
+import {
+    createQueryClass,
+    createExecuteClass,
+    createExecuteInterface,
+    createTypeInterface
+} from '../client'
+import { expectCode, printCode, 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/src/context/context.ts

@@ -1,5 +1,6 @@
 import { JSONSchema } from "../types";
-import { convertUtilsToImportList, getImportStatements } from "./imports";
+import { refLookup } from "../utils";
+import { convertUtilsToImportList, getImportStatements, UtilMapping } from "./imports";
 import deepmerge from "deepmerge";
 
 /// Plugin Types
@@ -21,6 +22,9 @@ export interface TSClientOptions {
 export interface MessageComposerOptions {
     enabled?: boolean;
 }
+export interface MsgBuilderOptions {
+    enabled?: boolean;
+}
 export interface RecoilOptions {
     enabled?: boolean;
 }
@@ -52,19 +56,29 @@ export interface ContractInfo {
     idlObject?: IDLObject;
 };
 export interface RenderOptions {
+    enabled?: boolean;
     types?: TSTypesOptions;
     recoil?: RecoilOptions;
     messageComposer?: MessageComposerOptions;
+    msgBuilder?: MsgBuilderOptions;
     client?: TSClientOptions;
     reactQuery?: ReactQueryOptions;
 }
 
-export interface RenderContext {
+
+export interface IContext {
+  refLookup($ref: string);
+  addUtil(util: string);
+  getImports(registeredUtils?: UtilMapping);
+}
+
+export interface IRenderContext<TOpt = RenderOptions> extends IContext {
     contract: ContractInfo;
-    options: RenderOptions;
+    options: TOpt;
 }
 
 export const defaultOptions: RenderOptions = {
+    enabled: true,
     types: {
         enabled: true,
         aliasExecuteMsg: false
@@ -80,6 +94,9 @@ export const defaultOptions: RenderOptions = {
     messageComposer: {
         enabled: false
     },
+    msgBuilder: {
+      enabled: false,
+    },
     reactQuery: {
         enabled: false,
         optionalClient: false,
@@ -107,31 +124,49 @@ export const getDefinitionSchema = (schemas: JSONSchema[]): JSONSchema => {
 
     return aggregateSchema;
 };
-export class RenderContext implements RenderContext {
+
+/**
+ * context object for generating code.
+ * only mergeDefaultOpt needs to implementing for combine options and default options.
+ * @param TOpt option type
+ */
+export abstract class RenderContextBase<TOpt = RenderOptions> implements IRenderContext<TOpt> {
     contract: ContractInfo;
     utils: string[] = [];
     schema: JSONSchema;
+    options: TOpt;
     constructor(
         contract: ContractInfo,
-        options?: RenderOptions
+        options?: TOpt
     ) {
         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
+     */
+    abstract mergeDefaultOpt(options: TOpt): TOpt;
     refLookup($ref: string) {
-        const refName = $ref.replace('#/definitions/', '')
-        return this.schema.definitions?.[refName];
+      return refLookup($ref, this.schema)
     }
     addUtil(util: string) {
         this.utils[util] = true;
     }
-    getImports() {
+    getImports(registeredUtils?: UtilMapping) {
         return getImportStatements(
             convertUtilsToImportList(
                 this,
-                Object.keys(this.utils)
+                Object.keys(this.utils),
+                registeredUtils,
             )
         );
     }
 }
+
+export class RenderContext extends RenderContextBase{
+  mergeDefaultOpt(options: RenderOptions): RenderOptions {
+    return deepmerge(defaultOptions, options ?? {});
+  }
+}

package/src/context/imports.ts

@@ -2,6 +2,7 @@ import * as t from '@babel/types';
 import { importAs, importStmt } from "../utils";
 import { RenderContext } from './context';
 
+
 export interface ImportObj {
   type: 'import' | 'default' | 'namespace';
   name: string;
@@ -9,6 +10,14 @@ export interface ImportObj {
   importAs?: string;
 }
 
+export type GetUtilFn = (<TContext = RenderContext>(...args: any[]) => (context: TContext) => ImportObj);
+export type UtilMapping = {
+  [key: string]:
+    | ImportObj
+    | string
+    | GetUtilFn
+};
+
 const makeReactQuerySwitch = (varName) => {
   return (context: RenderContext) => {
     switch (context.options.reactQuery.version) {
@@ -30,11 +39,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',
@@ -50,23 +59,48 @@ export const UTILS = {
 
 export const convertUtilsToImportList = (
   context: RenderContext,
-  utils: string[]
+  utils: string[],
+  registeredUtils?: UtilMapping
 ): ImportObj[] => {
-  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];
+  return utils.map((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: RenderContext,
+  util: string,
+  registeredUtils: object
+): ImportObj => {
+  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: ImportObj[]) => {
   const imports = list.reduce((m, obj) => {

package/src/index.ts

@@ -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';