wasm-ast-types 0.23.0 → 0.24.0

package/module/provider/provider.spec.js

@@ -0,0 +1,58 @@
+import { createGettingProviders, createIContractsContext, createProvider } from "./provider";
+import { expectCode } from "../../test-utils";
+import { PROVIDER_TYPES } from "../utils/constants";
+it("execute class", () => {
+  let info = {};
+  info[PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "WhitelistClient"
+  };
+  info[PROVIDER_TYPES.QUERY_CLIENT_TYPE] = {
+    classname: "WhitelistQueryClient"
+  };
+  info[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE] = {
+    classname: "WhitelistMessageComposer"
+  };
+  expectCode(createProvider("Whitelist", info));
+});
+it("execute class without message composer", () => {
+  let info = {};
+  info[PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "WhitelistClient"
+  };
+  info[PROVIDER_TYPES.QUERY_CLIENT_TYPE] = {
+    classname: "WhitelistQueryClient"
+  };
+  expectCode(createProvider("Whitelist", info));
+});
+it("create IContractsContext", () => {
+  let info = {
+    Whitelist: {},
+    Marketplace: {}
+  };
+  info["Whitelist"][PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "WhitelistClient"
+  };
+  info["Whitelist"][PROVIDER_TYPES.QUERY_CLIENT_TYPE] = {
+    classname: "WhitelistQueryClient"
+  };
+  info["Marketplace"][PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "MarketplaceClient"
+  };
+  expectCode(createIContractsContext(info));
+});
+it("create getProviders", () => {
+  let info = {
+    Whitelist: {},
+    Marketplace: {}
+  };
+  info["Whitelist"][PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "WhitelistClient"
+  };
+  info["Whitelist"][PROVIDER_TYPES.QUERY_CLIENT_TYPE] = {
+    classname: "WhitelistQueryClient"
+  };
+  info["Marketplace"][PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "MarketplaceClient"
+  };
+  expectCode(createGettingProviders(info));
+});

package/module/utils/constants.js

@@ -3,4 +3,10 @@ import * as t from '@babel/types';
 export const OPTIONAL_FUNDS_PARAM = identifier('_funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true);
 export const OPTIONAL_FEE_PARAM = identifier('fee', t.tsTypeAnnotation(t.tsUnionType([t.tsNumberKeyword(), t.tsTypeReference(t.identifier('StdFee')), t.tsLiteralType(t.stringLiteral('auto'))])), true);
 export const OPTIONAL_MEMO_PARAM = identifier('memo', t.tsTypeAnnotation(t.tsStringKeyword()), true);
-export const FIXED_EXECUTE_PARAMS = [OPTIONAL_FEE_PARAM, OPTIONAL_MEMO_PARAM, OPTIONAL_FUNDS_PARAM];
+export const FIXED_EXECUTE_PARAMS = [OPTIONAL_FEE_PARAM, 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/module/utils/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-ast-types",
-  "version": "0.23.0",
+  "version": "0.24.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": "9979ae4b7209f920fe1b822ede2ba80ee0f2eade"
+  "gitHead": "4553eb80cd89969583df6164d1c764ab5b289c63"
 }

package/src/context/context.ts

@@ -2,6 +2,7 @@ import { JSONSchema } from "../types";
 import { refLookup } from "../utils";
 import { convertUtilsToImportList, getImportStatements, UtilMapping } from "./imports";
 import deepmerge from "deepmerge";
+import { basename, extname } from 'path'
 
 /// Plugin Types
 export interface ReactQueryOptions {
@@ -67,16 +68,28 @@ export interface RenderOptions {
     reactQuery?: ReactQueryOptions;
 }
 
+export interface ProviderInfo{
+  classname: string,
+  filename: string,
+  basename: string,
+}
 
 export interface IContext {
   refLookup($ref: string);
   addUtil(util: string);
-  getImports(registeredUtils?: UtilMapping);
+  getImports(registeredUtils?: UtilMapping, filepath?: string);
 }
 
 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 const defaultOptions: RenderOptions = {
@@ -127,23 +140,54 @@ export const getDefinitionSchema = (schemas: JSONSchema[]): JSONSchema => {
     return aggregateSchema;
 };
 
+export class BuilderContext{
+    providers:{
+      [key: string]: {
+        [key: string]: ProviderInfo;
+      };
+    } = {};
+
+    addProviderInfo(contractName:string, type: string, classname: string, filename: string): void {
+      if(!this.providers[contractName]){
+        this.providers[contractName] = {}
+      }
+
+      this.providers[contractName][type] = {
+        classname,
+        filename,
+        basename: basename(filename, extname(filename))
+      };
+    }
+    getProviderInfos(): {
+      [key: string]: {
+        [key: string]: ProviderInfo;
+      };
+    }{
+      return this.providers;
+    }
+}
+
 /**
  * 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> {
+    builderContext: BuilderContext;
     contract: ContractInfo;
     utils: string[] = [];
     schema: JSONSchema;
     options: TOpt;
+
     constructor(
         contract: ContractInfo,
-        options?: TOpt
+        options?: TOpt,
+        builderContext?: BuilderContext
     ) {
         this.contract = contract;
         this.schema = getDefinitionSchema(contract.schemas);
         this.options = this.mergeDefaultOpt(options);
+        this.builderContext = builderContext;
     }
     /**
      * merge options and default options
@@ -156,13 +200,24 @@ export abstract class RenderContextBase<TOpt = RenderOptions> implements IRender
     addUtil(util: string) {
         this.utils[util] = true;
     }
-    getImports(registeredUtils?: UtilMapping) {
+    addProviderInfo(contractName:string, type: string, classname: string, filename: string): void {
+        this.builderContext.addProviderInfo(contractName, type, classname, filename);
+    }
+    getProviderInfos(): {
+      [key: string]: {
+        [key: string]: ProviderInfo;
+      };
+    } {
+        return this.builderContext.providers;
+    }
+    getImports(registeredUtils?: UtilMapping, filepath?: string) {
         return getImportStatements(
             convertUtilsToImportList(
                 this,
                 Object.keys(this.utils),
                 registeredUtils,
-            )
+            ),
+            filepath
         );
     }
 }

package/src/context/imports.ts

@@ -1,6 +1,7 @@
 import * as t from '@babel/types';
 import { importAs, importStmt } from "../utils";
 import { RenderContext } from './context';
+import { relative, dirname, extname } from 'path';
 
 
 export interface ImportObj {
@@ -57,6 +58,10 @@ export const UTILS = {
 
 };
 
+export const UTIL_HELPERS = [
+  '__contractContextBase__',
+];
+
 export const convertUtilsToImportList = (
   context: RenderContext,
   utils: string[],
@@ -102,59 +107,89 @@ export const convertUtil = (
   }
 };
 
-export const getImportStatements = (list: ImportObj[]) => {
-  const imports = list.reduce((m, obj) => {
-    m[obj.path] = m[obj.path] || [];
-    const exists = m[obj.path].find(el => el.type === obj.type && el.path === obj.path && el.name === obj.name);
 
-    // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
-    if (/\./.test(obj.name)) {
-      obj.name = obj.name.split('.')[obj.name.split('.').length - 1];
-    }
+// __helpers__
+export const getImportStatements = (
+  list: ImportObj[],
+  filepath?: string
+) => {
+
+  // swap helpers with helpers file...
+  const modifiedImports = list.map(imp => {
+      if (filepath && UTIL_HELPERS.includes(imp.path)) {
+          const name = imp.path.replace(/__/g, '');
+          return {
+              ...imp,
+              path: getRelativePath(filepath, `./${name}`)
+          }
+      }
+      return imp;
+  });
 
-    if (!exists) m[obj.path].push(obj);
-    return m;
+  const imports = modifiedImports.reduce((m, obj) => {
+      m[obj.path] = m[obj.path] || [];
+      const exists = m[obj.path].find(el =>
+          el.type === obj.type && el.path === obj.path && el.name === obj.name);
+
+      // MARKED AS NOT DRY [google.protobuf names]
+      // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
+      if (/\./.test(obj.name)) {
+          obj.name = obj.name.split('.')[obj.name.split('.').length - 1];
+      }
+
+      if (!exists) {
+          m[obj.path].push(obj);
+      }
+      return m;
   }, {})
 
+
   return Object.entries(imports)
-    .reduce((m, [importPath, imports]: [string, ImportObj[]]) => {
-      const defaultImports = imports.filter(a => a.type === 'default');
-      if (defaultImports.length) {
-        if (defaultImports.length > 1) throw new Error('more than one default name NOT allowed.')
-        m.push(
-          t.importDeclaration(
-            [
-              t.importDefaultSpecifier(
-                t.identifier(defaultImports[0].name)
+      .reduce((m, [importPath, imports]: [string, ImportObj[]]) => {
+          const defaultImports = imports.filter(a => a.type === 'default');
+          if (defaultImports.length) {
+              if (defaultImports.length > 1) throw new Error('more than one default name NOT allowed.')
+              m.push(
+                  t.importDeclaration(
+                      [
+                          t.importDefaultSpecifier(
+                              t.identifier(defaultImports[0].name)
+                          )
+                      ],
+                      t.stringLiteral(defaultImports[0].path)
+                  )
               )
-            ],
-            t.stringLiteral(defaultImports[0].path)
-          )
-        )
-      }
-      const namedImports = imports.filter(a => a.type === 'import' && (!a.importAs || (a.name === a.importAs)));
-      if (namedImports.length) {
-        m.push(importStmt(namedImports.map(i => i.name), namedImports[0].path));
-      }
-      const aliasNamedImports = imports.filter(a => a.type === 'import' && (a.importAs && (a.name !== a.importAs)));
-      aliasNamedImports.forEach(imp => {
-        m.push(importAs(imp.name, imp.importAs, imp.path));
-      });
-
-      const namespaced = imports.filter(a => a.type === 'namespace');
-      if (namespaced.length) {
-        if (namespaced.length > 1) throw new Error('more than one namespaced name NOT allowed.')
-        m.push(
-          t.importDeclaration(
-            [
-              t.importNamespaceSpecifier(
-                t.identifier(namespaced[0].name)
+          }
+          const namedImports = imports.filter(a => a.type === 'import' && (!a.importAs || (a.name === a.importAs)));
+          if (namedImports.length) {
+              m.push(importStmt(namedImports.map(i => i.name), namedImports[0].path));
+          }
+          const aliasNamedImports = imports.filter(a => a.type === 'import' && (a.importAs && (a.name !== a.importAs)));
+          aliasNamedImports.forEach(imp => {
+              m.push(importAs(imp.name, imp.importAs, imp.path));
+          });
+
+          const namespaced = imports.filter(a => a.type === 'namespace');
+          if (namespaced.length) {
+              if (namespaced.length > 1) throw new Error('more than one namespaced name NOT allowed.')
+              m.push(
+                  t.importDeclaration(
+                      [
+                          t.importNamespaceSpecifier(
+                              t.identifier(namespaced[0].name)
+                          )
+                      ],
+                      t.stringLiteral(namespaced[0].path)
+                  )
               )
-            ],
-            t.stringLiteral(namespaced[0].path)
-          )
-        )
-      }
-      return m;
-    }, [])
-};
+          }
+          return m;
+      }, [])
+};
+
+export const getRelativePath = (f1: string, f2: string) => {
+  const rel = relative(dirname(f1), f2);
+  let importPath = rel.replace(extname(rel), '');
+  if (!/^\./.test(importPath)) importPath = `./${importPath}`;
+  return importPath;
+}

package/src/index.ts

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

package/src/provider/__snapshots__/provider.spec.ts.snap

@@ -0,0 +1,49 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`create IContractsContext 1`] = `
+"export interface IContractsContext {
+  whitelist: ISigningClientProvider<WhitelistClient> & IQueryClientProvider<WhitelistQueryClient>;
+  marketplace: ISigningClientProvider<MarketplaceClient>;
+}"
+`;
+
+exports[`create getProviders 1`] = `
+"export const getProviders = (address?: string, cosmWasmClient?: CosmWasmClient, signingCosmWasmClient?: SigningCosmWasmClient) => ({
+  whitelist: new Whitelist({
+    address,
+    cosmWasmClient,
+    signingCosmWasmClient
+  }),
+  marketplace: new Marketplace({
+    address,
+    cosmWasmClient,
+    signingCosmWasmClient
+  })
+});"
+`;
+
+exports[`execute class 1`] = `
+"export class Whitelist extends ContractBase<WhitelistClient, WhitelistQueryClient, WhitelistMessageComposer> {
+  constructor({
+    address,
+    cosmWasmClient,
+    signingCosmWasmClient
+  }: IContractConstructor) {
+    super(address, cosmWasmClient, signingCosmWasmClient, WhitelistClient, WhitelistQueryClient, WhitelistMessageComposer);
+  }
+
+}"
+`;
+
+exports[`execute class without message composer 1`] = `
+"export class Whitelist extends ContractBase<WhitelistClient, WhitelistQueryClient, IEmptyClient> {
+  constructor({
+    address,
+    cosmWasmClient,
+    signingCosmWasmClient
+  }: IContractConstructor) {
+    super(address, cosmWasmClient, signingCosmWasmClient, WhitelistClient, WhitelistQueryClient, undefined);
+  }
+
+}"
+`;

package/src/provider/index.ts

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

package/src/provider/provider.spec.ts

@@ -0,0 +1,81 @@
+import execute_msg from "../../../../__fixtures__/basic/execute_msg_for__empty.json";
+import query_msg from "../../../../__fixtures__/basic/query_msg.json";
+import ownership from "../../../../__fixtures__/basic/ownership.json";
+import { createGettingProviders, createIContractsContext, createProvider } from "./provider";
+
+import { expectCode, makeContext } from "../../test-utils";
+import { PROVIDER_TYPES } from "../utils/constants";
+
+it("execute class", () => {
+  let info = {};
+
+  info[PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "WhitelistClient",
+  };
+
+  info[PROVIDER_TYPES.QUERY_CLIENT_TYPE] = {
+    classname: "WhitelistQueryClient",
+  };
+
+  info[PROVIDER_TYPES.MESSAGE_COMPOSER_TYPE] = {
+    classname: "WhitelistMessageComposer",
+  };
+
+  expectCode(createProvider("Whitelist", info));
+});
+
+it("execute class without message composer", () => {
+  let info = {};
+
+  info[PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "WhitelistClient",
+  };
+
+  info[PROVIDER_TYPES.QUERY_CLIENT_TYPE] = {
+    classname: "WhitelistQueryClient",
+  };
+
+  expectCode(createProvider("Whitelist", info));
+});
+
+it("create IContractsContext", () => {
+  let info = {
+    Whitelist: {},
+    Marketplace: {},
+  };
+
+  info["Whitelist"][PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "WhitelistClient",
+  };
+
+  info["Whitelist"][PROVIDER_TYPES.QUERY_CLIENT_TYPE] = {
+    classname: "WhitelistQueryClient",
+  };
+
+  info["Marketplace"][PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "MarketplaceClient",
+  };
+
+  expectCode(createIContractsContext(info));
+});
+
+it("create getProviders", () => {
+  let info = {
+    Whitelist: {},
+    Marketplace: {},
+  };
+
+  info["Whitelist"][PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "WhitelistClient",
+  };
+
+  info["Whitelist"][PROVIDER_TYPES.QUERY_CLIENT_TYPE] = {
+    classname: "WhitelistQueryClient",
+  };
+
+  info["Marketplace"][PROVIDER_TYPES.SIGNING_CLIENT_TYPE] = {
+    classname: "MarketplaceClient",
+  };
+
+  expectCode(createGettingProviders(info));
+});