wasm-ast-types 0.18.2 → 0.20.0

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

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { camel, pascal } from 'case';
+import { camel, pascal, snake } from 'case';
 import { propertySignature } from './babel';
 import { TSTypeAnnotation } from '@babel/types';
 import { RenderContext } from '../context';
@@ -425,15 +425,22 @@ export const createTypedObjectParams = (
   context: RenderContext,
   jsonschema: JSONSchema,
   camelize: boolean = true
-): t.ObjectPattern => {
+): (t.Identifier | t.Pattern | t.RestElement) => {
 
   const keys = Object.keys(jsonschema.properties ?? {});
   if (!keys.length) {
-
     // is there a ref?
     if (jsonschema.$ref) {
       const obj = context.refLookup(jsonschema.$ref);
-      if (obj) {
+      // If there is a oneOf, then we need to create a type for it
+      if (obj?.oneOf) {
+        // the actual type of the ref
+        const refType = jsonschema.$ref.split('/').pop();
+        const refName = camel(refType);
+        const id = t.identifier(refName);
+        id.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(refType)));
+        return id
+      } else if (obj) {
         return createTypedObjectParams(
           context,
           obj,

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;