wasm-ast-types 0.9.0 → 0.11.0

package/module/recoil/recoil.spec.js

@@ -1,11 +1,10 @@
 import * as t from '@babel/types';
 import query_msg from '../../../../__fixtures__/basic/query_msg.json';
 import { createRecoilSelector, createRecoilSelectors, createRecoilQueryClient } from './recoil';
-import { RenderContext } from '../context';
-import { expectCode } from '../../test-utils';
-const ctx = new RenderContext(query_msg);
+import { expectCode, makeContext } from '../../test-utils';
+const ctx = makeContext(query_msg);
 it('selector', () => {
-  expectCode(createRecoilSelector(ctx, 'SG721', 'SG721QueryClient', 'governanceModules'));
+  expectCode(createRecoilSelector(ctx, 'SG721', 'SG721QueryClient', 'governanceModules', 'GovernanceModulesResponse'));
 });
 it('selectors', () => {
   expectCode(t.program(createRecoilSelectors(ctx, 'SG721', 'SG721QueryClient', query_msg)));

package/module/utils/types.js

@@ -1,6 +1,12 @@
 import * as t from '@babel/types';
-import { camel } from 'case';
+import { camel, pascal } from 'case';
 import { propertySignature } from './babel';
+export function getResponseType(context, underscoreName) {
+  const methodName = camel(underscoreName);
+  return pascal(context.contract?.responses?.[underscoreName]?.title ?? // after v1.1 is adopted, we can deprecate this and require the above response
+  `${methodName}Response`);
+}
+;
 
 const getTypeStrFromRef = $ref => {
   if ($ref?.startsWith('#/definitions/')) {
@@ -31,7 +37,9 @@ const getTypeOrRef = obj => {
 };
 
 const getArrayTypeFromItems = items => {
-  if (items.type === 'array') {
+  const detect = detectType(items.type);
+
+  if (detect.type === 'array') {
     if (Array.isArray(items.items)) {
       return t.tsArrayType(t.tsArrayType(getTypeOrRef(items.items[0])));
     } else {
@@ -39,37 +47,38 @@ const getArrayTypeFromItems = items => {
     }
   }
 
-  return t.tsArrayType(getType(items.type));
+  return t.tsArrayType(getType(detect.type));
 };
 
-export const getType = type => {
-  switch (type) {
-    case 'string':
-      return t.tsStringKeyword();
+export const detectType = type => {
+  let optional = false;
+  let theType = '';
 
-    case 'boolean':
-      return t.tSBooleanKeyword();
+  if (Array.isArray(type)) {
+    if (type.length !== 2) {
+      throw new Error('[getType(array length)] case not handled by transpiler. contact maintainers.');
+    }
 
-    case 'integer':
-      return t.tsNumberKeyword();
+    const [nullableType, nullType] = type;
 
-    default:
-      throw new Error('contact maintainers [unknown type]: ' + type);
-  }
-};
-export const getPropertyType = (context, schema, prop) => {
-  const props = schema.properties ?? {};
-  let info = props[prop];
-  let type = null;
-  let optional = !schema.required?.includes(prop);
+    if (nullType !== 'null') {
+      throw new Error('[getType(null)] case not handled by transpiler. contact maintainers.');
+    }
 
-  if (info.allOf && info.allOf.length === 1) {
-    info = info.allOf[0];
+    theType = nullableType;
+    optional = true;
+  } else {
+    theType = type;
   }
 
-  if (typeof info.$ref === 'string') {
-    type = getTypeFromRef(info.$ref);
-  }
+  return {
+    type: theType,
+    optional
+  };
+};
+export const getTypeInfo = info => {
+  let type = undefined;
+  let optional = undefined;
 
   if (Array.isArray(info.anyOf)) {
     // assuming 2nd is null, but let's check to ensure
@@ -112,7 +121,9 @@ export const getPropertyType = (context, schema, prop) => {
         throw new Error('[info.items] case not handled by transpiler. contact maintainers.');
       }
     } else {
-      type = getType(info.type);
+      const detect = detectType(info.type);
+      type = getType(detect.type);
+      optional = detect.optional;
     }
   }
 
@@ -129,7 +140,16 @@ export const getPropertyType = (context, schema, prop) => {
     }
 
     if (nullableType === 'array' && typeof info.items === 'object' && !Array.isArray(info.items)) {
-      type = t.tsArrayType(getType(info.items.type));
+      const detect = detectType(info.items.type);
+
+      if (detect.type === 'array') {
+        // wen recursion?
+        type = t.tsArrayType(getArrayTypeFromItems(info.items));
+      } else {
+        type = t.tsArrayType(getType(detect.type));
+      }
+
+      optional = detect.optional;
     } else {
       type = getType(nullableType);
     }
@@ -137,6 +157,50 @@ export const getPropertyType = (context, schema, prop) => {
     optional = true;
   }
 
+  return {
+    type,
+    optional
+  };
+};
+export const getType = type => {
+  switch (type) {
+    case 'string':
+      return t.tsStringKeyword();
+
+    case 'boolean':
+      return t.tSBooleanKeyword();
+
+    case 'integer':
+      return t.tsNumberKeyword();
+
+    default:
+      throw new Error('contact maintainers [unknown type]: ' + type);
+  }
+};
+export const getPropertyType = (context, schema, prop) => {
+  const props = schema.properties ?? {};
+  let info = props[prop];
+  let type = null;
+  let optional = !schema.required?.includes(prop);
+
+  if (info.allOf && info.allOf.length === 1) {
+    info = info.allOf[0];
+  }
+
+  if (typeof info.$ref === 'string') {
+    type = getTypeFromRef(info.$ref);
+  }
+
+  const typeInfo = getTypeInfo(info);
+
+  if (typeof typeInfo.optional !== 'undefined') {
+    optional = typeInfo.optional;
+  }
+
+  if (typeof typeInfo.type !== 'undefined') {
+    type = typeInfo.type;
+  }
+
   if (!type) {
     throw new Error('cannot find type for ' + JSON.stringify(info));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-ast-types",
-  "version": "0.9.0",
+  "version": "0.11.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",
@@ -86,5 +86,5 @@
     "case": "1.6.3",
     "deepmerge": "4.2.2"
   },
-  "gitHead": "3b7ca02c9283c346a365d8426d3034af355afcac"
+  "gitHead": "d7f8c715f76edac8c5c2762e58fe8c73351d2af5"
 }

package/types/context/context.d.ts

@@ -20,6 +20,25 @@ export interface TSTypesOptions {
     enabled?: boolean;
     aliasExecuteMsg?: boolean;
 }
+interface KeyedSchema {
+    [key: string]: JSONSchema;
+}
+export interface IDLObject {
+    contract_name: string;
+    contract_version: string;
+    idl_version: string;
+    instantiate: JSONSchema;
+    execute: JSONSchema;
+    query: JSONSchema;
+    migrate: JSONSchema;
+    sudo: JSONSchema;
+    responses: KeyedSchema;
+}
+export interface ContractInfo {
+    schemas: JSONSchema[];
+    responses?: Record<string, JSONSchema>;
+    idlObject?: IDLObject;
+}
 export interface RenderOptions {
     types?: TSTypesOptions;
     recoil?: RecoilOptions;
@@ -28,15 +47,18 @@ export interface RenderOptions {
     reactQuery?: ReactQueryOptions;
 }
 export interface RenderContext {
-    schema: JSONSchema;
+    contract: ContractInfo;
     options: RenderOptions;
 }
 export declare const defaultOptions: RenderOptions;
+export declare const getDefinitionSchema: (schemas: JSONSchema[]) => JSONSchema;
 export declare class RenderContext implements RenderContext {
-    schema: JSONSchema;
+    contract: ContractInfo;
     utils: string[];
-    constructor(schema: JSONSchema, options?: RenderOptions);
+    schema: JSONSchema;
+    constructor(contract: ContractInfo, options?: RenderOptions);
     refLookup($ref: string): JSONSchema;
     addUtil(util: string): void;
     getImports(): any[];
 }
+export {};

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

@@ -7,6 +7,7 @@ interface ReactQueryHookQuery {
     hookName: string;
     hookParamsTypeName: string;
     hookKeyName: string;
+    queryKeysName: string;
     responseType: string;
     methodName: string;
     jsonschema: any;
@@ -17,8 +18,8 @@ interface ReactQueryHooks {
     contractName: string;
     QueryClient: string;
 }
-export declare const createReactQueryHooks: ({ context, queryMsg, contractName, QueryClient }: ReactQueryHooks) => t.ExportNamedDeclaration[];
-export declare const createReactQueryHook: ({ context, hookName, hookParamsTypeName, responseType, hookKeyName, methodName, jsonschema }: ReactQueryHookQuery) => t.ExportNamedDeclaration;
+export declare const createReactQueryHooks: ({ context, queryMsg, contractName, QueryClient }: ReactQueryHooks) => any[];
+export declare const createReactQueryHook: ({ context, hookName, hookParamsTypeName, responseType, hookKeyName, queryKeysName, methodName, jsonschema }: ReactQueryHookQuery) => t.ExportNamedDeclaration;
 interface ReactQueryMutationHookInterface {
     context: RenderContext;
     ExecuteClient: string;

package/types/recoil/recoil.d.ts

@@ -1,7 +1,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) => t.ExportNamedDeclaration;
+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 createRecoilQueryClientType: () => {
     type: string;

package/types/utils/types.d.ts

@@ -2,8 +2,17 @@ import * as t from '@babel/types';
 import { TSTypeAnnotation } from '@babel/types';
 import { RenderContext } from '../context';
 import { JSONSchema } from '../types';
+export declare function getResponseType(context: RenderContext, underscoreName: string): string;
 export declare const getTypeFromRef: ($ref: any) => t.TSTypeReference;
-export declare const getType: (type: any) => t.TSBooleanKeyword | t.TSNumberKeyword | t.TSStringKeyword;
+export declare const detectType: (type: string | string[]) => {
+    type: string;
+    optional: boolean;
+};
+export declare const getTypeInfo: (info: JSONSchema) => {
+    type: any;
+    optional: any;
+};
+export declare const getType: (type: string) => t.TSBooleanKeyword | t.TSNumberKeyword | t.TSStringKeyword;
 export declare const getPropertyType: (context: RenderContext, schema: JSONSchema, prop: string) => {
     type: any;
     optional: boolean;