wasm-ast-types 0.18.1 → 0.19.0

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/msg-builder/index.js

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

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

@@ -0,0 +1,33 @@
+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 obj = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+  const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
+  if (obj) obj.typeAnnotation = createExtractTypeAnnotation(underscoreName, msgTitle);
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression( // params
+  obj ? [// props
+  obj] : [], // body
+  t.blockStatement([t.returnStatement(t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.tsAsExpression(t.objectExpression(args), t.tsTypeReference(t.identifier('const'))))]))]), // 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,12 @@
+import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
+import query_msg from '../../../../__fixtures__/basic/query_msg.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(execute_msg);
+  expectCode(createMsgBuilderClass(ctx, 'SG721MsgBuilder', query_msg));
+});

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

@@ -40,7 +40,7 @@ const getArrayTypeFromItems = items => {
   // passing in [{"type":"string"}]
   if (Array.isArray(items)) {
     if (items[0]?.type === 'array') {
-      return t.tsArrayType(t.tsArrayType(getArrayTypeFromItems(items[0])));
+      return getArrayTypeFromItems(items[0]);
     }
 
     return t.tsArrayType(t.tsArrayType(getTypeOrRef(items[0])));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-ast-types",
-  "version": "0.18.1",
+  "version": "0.19.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": "e6daf701507cad95127613a815fc0fca1a883f8a"
+  "gitHead": "dccd0edd182dc4d5e58b30e7f46732e0be483bc1"
 }

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.wager.spec.ts.snap

@@ -36,7 +36,7 @@ exports[`execute classes 1`] = `
   }: {
     currentPrices: number[][];
     prevPrices: number[][];
-    wagerKey: Addr[][][][];
+    wagerKey: Addr[][];
   }, fee: number | StdFee | \\"auto\\" = \\"auto\\", memo?: string, funds?: Coin[]): Promise<ExecuteResult> => {
     return await this.client.execute(this.sender, this.contractAddress, {
       set_winner: {

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