wasm-ast-types 0.23.0 → 0.24.0

package/src/provider/provider.ts

@@ -0,0 +1,237 @@
+import * as t from "@babel/types";
+import { camel, pascal } from "case";
+import { ProviderInfo, RenderContext } from "../context";
+import { PROVIDER_TYPES } from "../utils/constants";
+import { identifier, tsObjectPattern } from "../utils";
+
+export const createProvider = (
+  name: string,
+  providerInfos: {
+    [key: string]: ProviderInfo;
+  }
+) => {
+  const classDeclaration = t.classDeclaration(
+    t.identifier(name),
+    t.identifier("ContractBase"),
+    t.classBody([
+      t.classMethod(
+        "constructor",
+        t.identifier("constructor"),
+        [
+          tsObjectPattern(
+            [
+              t.objectProperty(
+                t.identifier("address"),
+                t.identifier("address"),
+                false,
+                true
+              ),
+              t.objectProperty(
+                t.identifier("cosmWasmClient"),
+                t.identifier("cosmWasmClient"),
+                false,
+                true
+              ),
+              t.objectProperty(
+                t.identifier("signingCosmWasmClient"),
+                t.identifier("signingCosmWasmClient"),
+                false,
+                true
+              ),
+            ],
+            t.tsTypeAnnotation(
+              t.tsTypeReference(t.identifier("IContractConstructor"))
+            )
+          ),
+        ],
+        t.blockStatement([
+          t.expressionStatement(
+            t.callExpression(t.super(), [
+              t.identifier("address"),
+              t.identifier("cosmWasmClient"),
+              t.identifier("signingCosmWasmClient"),
+              t.identifier(
+                providerInfos[PROVIDER_TYPES.SIGNING_CLIENT_TYPE]
+                  ? providerInfos[PROVIDER_TYPES.SIGNING_CLIENT_TYPE].classname
+                  : "undefined"
+              ),
+              t.identifier(
+                providerInfos[PROVIDER_TYPES.QUERY_CLIENT_TYPE]
+                  ? providerInfos[PROVIDER_TYPES.QUERY_CLIENT_TYPE].classname
+                  : "undefined"
+              ),
+              t.identifier(
+                providerInfos[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE]
+                  ? providerInfos[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE]
+                      .classname
+                  : "undefined"
+              ),
+            ])
+          ),
+        ])
+      ),
+    ])
+  );
+
+  classDeclaration.superTypeParameters = t.tsTypeParameterInstantiation([
+    t.tsTypeReference(
+      t.identifier(
+        providerInfos[PROVIDER_TYPES.SIGNING_CLIENT_TYPE]
+          ? providerInfos[PROVIDER_TYPES.SIGNING_CLIENT_TYPE].classname
+          : "IEmptyClient"
+      )
+    ),
+    t.tsTypeReference(
+      t.identifier(
+        providerInfos[PROVIDER_TYPES.QUERY_CLIENT_TYPE]
+          ? providerInfos[PROVIDER_TYPES.QUERY_CLIENT_TYPE].classname
+          : "IEmptyClient"
+      )
+    ),
+    t.tsTypeReference(
+      t.identifier(
+        providerInfos[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE]
+          ? providerInfos[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE].classname
+          : "IEmptyClient"
+      )
+    ),
+  ]);
+
+  return t.exportNamedDeclaration(classDeclaration);
+};
+
+export const createIContractsContext = (providerInfos: {
+  [key: string]: {
+    [key: string]: ProviderInfo;
+  };
+}) => {
+  const properties: t.TSTypeElement[] = [];
+
+  for (const key in providerInfos) {
+    if (Object.prototype.hasOwnProperty.call(providerInfos, key)) {
+      const contractProviderInfo = providerInfos[key];
+
+      properties.push(createProperty(key, contractProviderInfo));
+    }
+  }
+
+  return t.exportNamedDeclaration(
+    t.tsInterfaceDeclaration(
+      t.identifier("IContractsContext"),
+      null,
+      null,
+      t.tsInterfaceBody(properties)
+    )
+  );
+};
+
+let PROVIDER_MAPPING = {};
+
+PROVIDER_MAPPING[PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = "ISigningClientProvider";
+PROVIDER_MAPPING[PROVIDER_TYPES.QUERY_CLIENT_TYPE] = "IQueryClientProvider";
+PROVIDER_MAPPING[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE] =
+  "IMessageComposerProvider";
+
+export const createProperty = (
+  name: string,
+  providerInfos: {
+    [key: string]: ProviderInfo;
+  }
+): t.TSTypeElement => {
+  let typeAnnotation: t.TSTypeAnnotation = null;
+
+  const keys = Object.keys(providerInfos);
+
+  if (keys?.length == 1) {
+    const key = keys[0];
+
+    typeAnnotation = t.tsTypeAnnotation(
+      t.tsTypeReference(
+        t.identifier(PROVIDER_MAPPING[key]),
+        t.tsTypeParameterInstantiation([
+          t.tsTypeReference(t.identifier(providerInfos[key].classname)),
+        ])
+      )
+    );
+  } else {
+    const typeRefs: t.TSTypeReference[] = [];
+
+    for (const key of keys) {
+      typeRefs.push(
+        t.tsTypeReference(
+          t.identifier(PROVIDER_MAPPING[key]),
+          t.tsTypeParameterInstantiation([
+            t.tsTypeReference(t.identifier(providerInfos[key].classname)),
+          ])
+        )
+      );
+    }
+
+    typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType(typeRefs));
+  }
+
+  return t.tsPropertySignature(t.identifier(camel(name)), typeAnnotation);
+};
+
+export const createGettingProviders = (providerInfos: {
+  [key: string]: {
+    [key: string]: ProviderInfo;
+  };
+}) => {
+  const properties = [];
+
+  for (const key of Object.keys(providerInfos)) {
+    properties.push(
+      t.objectProperty(
+        t.identifier(camel(key)),
+        t.newExpression(t.identifier(pascal(key)), [
+          t.objectExpression([
+            t.objectProperty(
+              t.identifier("address"),
+              t.identifier("address"),
+              false,
+              true
+            ),
+            t.objectProperty(
+              t.identifier("cosmWasmClient"),
+              t.identifier("cosmWasmClient"),
+              false,
+              true
+            ),
+            t.objectProperty(
+              t.identifier("signingCosmWasmClient"),
+              t.identifier("signingCosmWasmClient"),
+              false,
+              true
+            ),
+          ]),
+        ])
+      )
+    );
+  }
+
+  return t.exportNamedDeclaration(
+    t.variableDeclaration("const", [
+      t.variableDeclarator(
+        t.identifier("getProviders"),
+        t.arrowFunctionExpression(
+          [
+            identifier(
+              "address?",
+              t.tsTypeAnnotation(t.tsTypeReference(t.identifier("string")))
+            ),
+            identifier(
+              "cosmWasmClient?",
+              t.tsTypeAnnotation(t.tsTypeReference(t.identifier("CosmWasmClient")))
+            ),
+            identifier(
+              "signingCosmWasmClient?",
+              t.tsTypeAnnotation(t.tsTypeReference(t.identifier("SigningCosmWasmClient")))
+            ),
+          ],
+          t.objectExpression(properties)
+        )
+      ),
+    ])
+  );
+};

package/src/react-query/react-query.ts

@@ -429,9 +429,9 @@ export const createReactQueryMutationArgsInterface = ({
     t.tsTypeAnnotation(
       // @ts-ignore:next-line
       t.tsTypeLiteral([
-        propertySignature('fee', OPTIONAL_FEE_PARAM.typeAnnotation, true),
-        propertySignature('memo', OPTIONAL_MEMO_PARAM.typeAnnotation, true),
-        propertySignature('funds', OPTIONAL_FUNDS_PARAM.typeAnnotation, true)
+        propertySignature('fee', OPTIONAL_FEE_PARAM.typeAnnotation as t.TSTypeAnnotation, true),
+        propertySignature('memo', OPTIONAL_MEMO_PARAM.typeAnnotation as t.TSTypeAnnotation, true),
+        propertySignature('funds', OPTIONAL_FUNDS_PARAM.typeAnnotation as t.TSTypeAnnotation, true)
       ])
     )
   );

package/src/utils/constants.ts

@@ -28,3 +28,10 @@ export const FIXED_EXECUTE_PARAMS = [
   OPTIONAL_MEMO_PARAM,
   OPTIONAL_FUNDS_PARAM
 ];
+
+export const PROVIDER_TYPES = {
+  SIGNING_CLIENT_TYPE: "client",
+  QUERY_CLIENT_TYPE: "queryClient",
+  MESSAGE_COMPOSER_TYPE : 'message-composer',
+  PROVIDER_TYPE : 'provider'
+};

package/src/utils/index.ts

@@ -3,3 +3,4 @@ export * from './types';
 export * from './ref';
 export { OPTIONAL_FUNDS_PARAM } from './constants';
 export { FIXED_EXECUTE_PARAMS } from './constants';
+export { PROVIDER_TYPES } from './constants';

package/types/client/client.d.ts

@@ -1,9 +1,7 @@
 import * as t from '@babel/types';
-import { QueryMsg, ExecuteMsg } from '../types';
+import { ExecuteMsg, JSONSchema, QueryMsg } from '../types';
 import { RenderContext } from '../context';
-import { JSONSchema } from '../types';
 export declare const CONSTANT_EXEC_PARAMS: (t.AssignmentPattern | t.Identifier)[];
-export declare const FIXED_EXECUTE_PARAMS: t.Identifier[];
 export declare const createWasmQueryMethod: (context: RenderContext, jsonschema: any) => t.ClassProperty;
 export declare const createQueryClass: (context: RenderContext, className: string, implementsClassName: string, queryMsg: QueryMsg) => t.ExportNamedDeclaration;
 export declare const getWasmMethodArgs: (context: RenderContext, jsonschema: JSONSchema) => t.ObjectProperty[];

package/types/context/context.d.ts

@@ -25,7 +25,6 @@ export interface RecoilOptions {
 }
 export interface TSTypesOptions {
     enabled?: boolean;
-    // deprecated
     aliasExecuteMsg?: boolean;
     aliasEntryPoints?: boolean;
 }
@@ -57,28 +56,53 @@ export interface RenderOptions {
     client?: TSClientOptions;
     reactQuery?: ReactQueryOptions;
 }
+export interface ProviderInfo {
+    classname: string;
+    filename: string;
+    basename: string;
+}
 export interface IContext {
     refLookup($ref: string): any;
     addUtil(util: string): any;
-    getImports(registeredUtils?: UtilMapping): any;
+    getImports(registeredUtils?: UtilMapping, filepath?: string): any;
 }
 export interface IRenderContext<TOpt = RenderOptions> extends IContext {
     contract: ContractInfo;
     options: TOpt;
+    addProviderInfo(contractName: string, type: string, classname: string, filename: string): void;
+    getProviderInfos(): {
+        [key: string]: {
+            [key: string]: ProviderInfo;
+        };
+    };
 }
 export declare const defaultOptions: RenderOptions;
 export declare const getDefinitionSchema: (schemas: JSONSchema[]) => JSONSchema;
+export declare class BuilderContext {
+    providers: {
+        [key: string]: {
+            [key: string]: ProviderInfo;
+        };
+    };
+    addProviderInfo(contractName: string, type: string, classname: string, filename: string): void;
+    getProviderInfos(): {
+        [key: string]: {
+            [key: string]: ProviderInfo;
+        };
+    };
+}
 /**
  * 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> {
+    builderContext: BuilderContext;
     contract: ContractInfo;
     utils: string[];
     schema: JSONSchema;
     options: TOpt;
-    constructor(contract: ContractInfo, options?: TOpt);
+    constructor(contract: ContractInfo, options?: TOpt, builderContext?: BuilderContext);
     /**
      * merge options and default options
      * @param options
@@ -86,7 +110,13 @@ export declare abstract class RenderContextBase<TOpt = RenderOptions> implements
     abstract mergeDefaultOpt(options: TOpt): TOpt;
     refLookup($ref: string): JSONSchema;
     addUtil(util: string): void;
-    getImports(registeredUtils?: UtilMapping): any;
+    addProviderInfo(contractName: string, type: string, classname: string, filename: string): void;
+    getProviderInfos(): {
+        [key: string]: {
+            [key: string]: ProviderInfo;
+        };
+    };
+    getImports(registeredUtils?: UtilMapping, filepath?: string): any;
 }
 export declare class RenderContext extends RenderContextBase {
     mergeDefaultOpt(options: RenderOptions): RenderOptions;

package/types/context/imports.d.ts

@@ -40,6 +40,8 @@ export declare const UTILS: {
         name: any;
     };
 };
+export declare const UTIL_HELPERS: string[];
 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[];
+export declare const getImportStatements: (list: ImportObj[], filepath?: string) => any[];
+export declare const getRelativePath: (f1: string, f2: string) => string;

package/types/index.d.ts

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

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

@@ -1,4 +1,4 @@
-import * as t from "@babel/types";
-import { ExecuteMsg, QueryMsg } from "../types";
-import { RenderContext } from "../context";
+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/provider/index.d.ts

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

package/types/provider/provider.d.ts

@@ -0,0 +1,18 @@
+import * as t from "@babel/types";
+import { ProviderInfo } from "../context";
+export declare const createProvider: (name: string, providerInfos: {
+    [key: string]: ProviderInfo;
+}) => t.ExportNamedDeclaration;
+export declare const createIContractsContext: (providerInfos: {
+    [key: string]: {
+        [key: string]: ProviderInfo;
+    };
+}) => t.ExportNamedDeclaration;
+export declare const createProperty: (name: string, providerInfos: {
+    [key: string]: ProviderInfo;
+}) => t.TSTypeElement;
+export declare const createGettingProviders: (providerInfos: {
+    [key: string]: {
+        [key: string]: ProviderInfo;
+    };
+}) => t.ExportNamedDeclaration;

package/types/utils/babel.d.ts

@@ -1,12 +1,7 @@
 import * as t from '@babel/types';
 import { Field } from '../types';
 import { TSTypeAnnotation, TSExpressionWithTypeArguments } from '@babel/types';
-export declare const propertySignature: (name: string, typeAnnotation: t.TSTypeAnnotation, optional?: boolean) => {
-    type: string;
-    key: t.Identifier;
-    typeAnnotation: t.TSTypeAnnotation;
-    optional: boolean;
-};
+export declare const propertySignature: (name: string, typeAnnotation: TSTypeAnnotation, optional?: boolean) => t.TSPropertySignature;
 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: any) => any[];

package/types/utils/constants.d.ts

@@ -0,0 +1,11 @@
+import * as t from '@babel/types';
+export declare const OPTIONAL_FUNDS_PARAM: t.Identifier;
+export declare const OPTIONAL_FEE_PARAM: t.Identifier;
+export declare const OPTIONAL_MEMO_PARAM: t.Identifier;
+export declare const FIXED_EXECUTE_PARAMS: t.Identifier[];
+export declare const PROVIDER_TYPES: {
+    SIGNING_CLIENT_TYPE: string;
+    QUERY_CLIENT_TYPE: string;
+    MESSAGE_COMPOSER_TYPE: string;
+    PROVIDER_TYPE: string;
+};

package/types/utils/index.d.ts

@@ -1,3 +1,6 @@
 export * from './babel';
 export * from './types';
 export * from './ref';
+export { OPTIONAL_FUNDS_PARAM } from './constants';
+export { FIXED_EXECUTE_PARAMS } from './constants';
+export { PROVIDER_TYPES } from './constants';

package/types/utils/types.d.ts

@@ -17,11 +17,6 @@ export declare const getPropertyType: (context: RenderContext, schema: JSONSchem
     type: any;
     optional: boolean;
 };
-export declare function getPropertySignatureFromProp(context: RenderContext, jsonschema: JSONSchema, prop: string, camelize: boolean): {
-    type: string;
-    key: t.Identifier;
-    typeAnnotation: t.TSTypeAnnotation;
-    optional: boolean;
-};
+export declare function getPropertySignatureFromProp(context: RenderContext, jsonschema: JSONSchema, prop: string, camelize: boolean): t.TSPropertySignature;
 export declare const getParamsTypeAnnotation: (context: RenderContext, jsonschema: any, camelize?: boolean) => t.TSTypeAnnotation;
-export declare const createTypedObjectParams: (context: RenderContext, jsonschema: JSONSchema, camelize?: boolean) => t.ObjectPattern;
+export declare const createTypedObjectParams: (context: RenderContext, jsonschema: JSONSchema, camelize?: boolean) => (t.Identifier | t.Pattern | t.RestElement);