wasm-ast-types 0.18.1 → 0.19.0

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

@@ -0,0 +1,249 @@
+// 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[`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,17 @@
+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/src/msg-builder/msg-builder.ts

@@ -0,0 +1,107 @@
+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";
+
+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 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/src/react-query/react-query.ts

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

package/src/utils/babel.ts

@@ -2,6 +2,7 @@ import * as t from '@babel/types';
 import { snake } from "case";
 import { Field, QueryMsg, ExecuteMsg } from '../types';
 import { TSTypeAnnotation, TSExpressionWithTypeArguments } from '@babel/types';
+import { refLookup } from './ref';
 
 // t.TSPropertySignature - kind?
 export const propertySignature = (
@@ -30,11 +31,28 @@ export const tsTypeOperator = (typeAnnotation: t.TSType, operator: string) => {
     return obj;
 };
 
-export const getMessageProperties = (msg: QueryMsg | ExecuteMsg) => {
-    if (msg.anyOf) return msg.anyOf;
-    if (msg.oneOf) return msg.oneOf;
-    if (msg.allOf) return msg.allOf;
-    return [];
+export const getMessageProperties = (msg) => {
+    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 = (
@@ -112,6 +130,17 @@ export const promiseTypeAnnotation = (name) => {
     );
 }
 
+export const abstractClassDeclaration = (name: string, body: any[], implementsExressions: TSExpressionWithTypeArguments[] = [], superClass: t.Identifier = null) => {
+  const declaration = classDeclaration(
+    name,
+    body,
+    implementsExressions,
+    superClass
+  );
+  declaration.abstract = true
+  return declaration;
+};
+
 export const classDeclaration = (name: string, body: any[], implementsExressions: TSExpressionWithTypeArguments[] = [], superClass: t.Identifier = null) => {
     const declaration = t.classDeclaration(
         t.identifier(name),

package/src/utils/index.ts

@@ -1,2 +1,3 @@
 export * from './babel';
 export * from './types';
+export * from './ref';

package/src/utils/ref.ts

@@ -0,0 +1,6 @@
+import { JSONSchema } from "../types";
+
+export const refLookup = ($ref: string, schema: JSONSchema) => {
+  const refName = $ref.replace('#/definitions/', '')
+  return schema.definitions?.[refName];
+}

package/src/utils/types.ts

@@ -49,12 +49,8 @@ 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(

package/types/context/context.d.ts

@@ -1,4 +1,5 @@
 import { JSONSchema } from "../types";
+import { UtilMapping } from "./imports";
 export interface ReactQueryOptions {
     enabled?: boolean;
     optionalClient?: boolean;
@@ -16,6 +17,9 @@ export interface TSClientOptions {
 export interface MessageComposerOptions {
     enabled?: boolean;
 }
+export interface MsgBuilderOptions {
+    enabled?: boolean;
+}
 export interface RecoilOptions {
     enabled?: boolean;
 }
@@ -43,25 +47,46 @@ 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): any;
+    addUtil(util: string): any;
+    getImports(registeredUtils?: UtilMapping): any;
+}
+export interface IRenderContext<TOpt = RenderOptions> extends IContext {
     contract: ContractInfo;
-    options: RenderOptions;
+    options: TOpt;
 }
 export declare const defaultOptions: RenderOptions;
 export declare const getDefinitionSchema: (schemas: JSONSchema[]) => JSONSchema;
-export declare 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 declare abstract class RenderContextBase<TOpt = RenderOptions> implements IRenderContext<TOpt> {
     contract: ContractInfo;
     utils: string[];
     schema: JSONSchema;
-    constructor(contract: ContractInfo, options?: RenderOptions);
+    options: TOpt;
+    constructor(contract: ContractInfo, options?: TOpt);
+    /**
+     * merge options and default options
+     * @param options
+     */
+    abstract mergeDefaultOpt(options: TOpt): TOpt;
     refLookup($ref: string): JSONSchema;
     addUtil(util: string): void;
-    getImports(): any[];
+    getImports(registeredUtils?: UtilMapping): any;
+}
+export declare class RenderContext extends RenderContextBase {
+    mergeDefaultOpt(options: RenderOptions): RenderOptions;
 }
 export {};

package/types/context/imports.d.ts

@@ -5,12 +5,16 @@ export interface ImportObj {
     path: string;
     importAs?: string;
 }
+export type GetUtilFn = (<TContext = RenderContext>(...args: any[]) => (context: TContext) => ImportObj);
+export type UtilMapping = {
+    [key: string]: ImportObj | string | GetUtilFn;
+};
 export declare const UTILS: {
+    selectorFamily: string;
     MsgExecuteContract: string;
     MsgExecuteContractEncodeObject: string;
     Coin: string;
     toUtf8: string;
-    selectorFamily: string;
     StdFee: string;
     CosmWasmClient: string;
     ExecuteResult: string;
@@ -36,5 +40,6 @@ export declare const UTILS: {
         name: any;
     };
 };
-export declare const convertUtilsToImportList: (context: RenderContext, utils: string[]) => ImportObj[];
+export declare const convertUtilsToImportList: (context: RenderContext, utils: string[], registeredUtils?: UtilMapping) => ImportObj[];
+export declare const convertUtil: (context: RenderContext, util: string, registeredUtils: object) => ImportObj;
 export declare const getImportStatements: (list: ImportObj[]) => any[];

package/types/index.d.ts

@@ -5,3 +5,4 @@ export * from './recoil';
 export * from './message-composer';
 export * from './react-query';
 export * from './types';
+export * from './msg-builder';

package/types/msg-builder/index.d.ts

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

package/types/msg-builder/msg-builder.d.ts

@@ -0,0 +1,4 @@
+import * as t from "@babel/types";
+import { ExecuteMsg, QueryMsg } from "../types";
+import { RenderContext } from "../context";
+export declare const createMsgBuilderClass: (context: RenderContext, className: string, msg: ExecuteMsg | QueryMsg) => t.ExportNamedDeclaration;

package/types/react-query/react-query.d.ts

@@ -30,16 +30,17 @@ interface ReactQueryMutationHookInterface {
 /**
  * Example:
 ```
-export interface Cw4UpdateMembersMutation {
-  client: Cw4GroupClient
-  args: {
-    tokenId: string
-    remove: string[]
-  }
-  options?: Omit<
-    UseMutationOptions<ExecuteResult, Error, Pick<Cw4UpdateMembersMutation, 'args'>>,
-    'mutationFn'
-  >
+ export interface Cw721RevokeMutation {
+  client: Cw721Client;
+  msg: {
+    spender: string;
+    tokenId: string;
+  };
+  args?: {
+    fee?: number | StdFee | "auto";
+    memo?: string;
+    funds?: Coin[];
+  };
 }
 ```
  */

package/types/recoil/recoil.d.ts

@@ -2,7 +2,7 @@ import * as t from '@babel/types';
 import { QueryMsg } from '../types';
 import { RenderContext } from '../context';
 export declare const createRecoilSelector: (context: RenderContext, keyPrefix: string, QueryClient: string, methodName: string, responseType: string) => t.ExportNamedDeclaration;
-export declare const createRecoilSelectors: (context: RenderContext, keyPrefix: string, QueryClient: string, queryMsg: QueryMsg) => any;
+export declare const createRecoilSelectors: (context: RenderContext, keyPrefix: string, QueryClient: string, queryMsg: QueryMsg) => t.ExportNamedDeclaration[];
 export declare const createRecoilQueryClientType: () => {
     type: string;
     id: {

package/types/utils/babel.d.ts

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { Field, QueryMsg, ExecuteMsg } from '../types';
+import { Field } from '../types';
 import { TSTypeAnnotation, TSExpressionWithTypeArguments } from '@babel/types';
 export declare const propertySignature: (name: string, typeAnnotation: t.TSTypeAnnotation, optional?: boolean) => {
     type: string;
@@ -9,13 +9,14 @@ export declare const propertySignature: (name: string, typeAnnotation: t.TSTypeA
 };
 export declare const identifier: (name: string, typeAnnotation: t.TSTypeAnnotation, optional?: boolean) => t.Identifier;
 export declare const tsTypeOperator: (typeAnnotation: t.TSType, operator: string) => t.TSTypeOperator;
-export declare const getMessageProperties: (msg: QueryMsg | ExecuteMsg) => any;
+export declare const getMessageProperties: (msg: any) => any[];
 export declare const tsPropertySignature: (key: t.Expression, typeAnnotation: t.TSTypeAnnotation, optional: boolean) => t.TSPropertySignature;
 export declare const tsObjectPattern: (properties: (t.RestElement | t.ObjectProperty)[], typeAnnotation: t.TSTypeAnnotation) => t.ObjectPattern;
 export declare const callExpression: (callee: t.Expression | t.V8IntrinsicIdentifier, _arguments: (t.Expression | t.SpreadElement | t.ArgumentPlaceholder)[], typeParameters: t.TSTypeParameterInstantiation) => t.CallExpression;
 export declare const bindMethod: (name: string) => t.ExpressionStatement;
 export declare const typedIdentifier: (name: string, typeAnnotation: TSTypeAnnotation, optional?: boolean) => t.Identifier;
 export declare const promiseTypeAnnotation: (name: any) => t.TSTypeAnnotation;
+export declare const abstractClassDeclaration: (name: string, body: any[], implementsExressions?: TSExpressionWithTypeArguments[], superClass?: t.Identifier) => t.ClassDeclaration;
 export declare const classDeclaration: (name: string, body: any[], implementsExressions?: TSExpressionWithTypeArguments[], superClass?: t.Identifier) => t.ClassDeclaration;
 export declare const classProperty: (name: string, typeAnnotation?: TSTypeAnnotation, isReadonly?: boolean, isStatic?: boolean, noImplicitOverride?: boolean) => t.ClassProperty;
 export declare const arrowFunctionExpression: (params: (t.Identifier | t.Pattern | t.RestElement)[], body: t.BlockStatement, returnType: t.TSTypeAnnotation, isAsync?: boolean) => t.ArrowFunctionExpression;

package/types/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from './babel';
 export * from './types';
+export * from './ref';

package/types/utils/ref.d.ts

@@ -0,0 +1,2 @@
+import { JSONSchema } from "../types";
+export declare const refLookup: ($ref: string, schema: JSONSchema) => JSONSchema;