wasm-ast-types 0.10.0 → 0.11.1

package/main/client/test/ts-client.account-nfts.spec.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _accountNft = _interopRequireDefault(require("../../../../../__fixtures__/idl-version/accounts-nft/account-nft.json"));
+
+var _client = require("../client");
+
+var _testUtils = require("../../../test-utils");
+
+var message = _accountNft["default"].query;
+var ctx = (0, _testUtils.makeContext)(message);
+it('execute_msg_for__empty', function () {
+  (0, _testUtils.expectCode)((0, _client.createTypeInterface)(ctx, message));
+});
+it('query classes', function () {
+  (0, _testUtils.expectCode)((0, _client.createQueryClass)(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', message));
+});
+it('execute classes array types', function () {
+  (0, _testUtils.expectCode)((0, _client.createExecuteClass)(ctx, 'SG721Client', 'SG721Instance', null, message));
+});
+it('execute interfaces no extends', function () {
+  (0, _testUtils.expectCode)((0, _client.createExecuteInterface)(ctx, 'SG721Instance', null, message));
+});

package/main/client/test/ts-client.arrays.spec.js

@@ -8,7 +8,13 @@ var _client = require("../client");
 
 var _testUtils = require("../../../test-utils");
 
+var _utils = require("../../utils");
+
 var ctx = (0, _testUtils.makeContext)(_arrays["default"]);
+it('getPropertyType', function () {
+  var ast = (0, _utils.getPropertyType)(ctx, _arrays["default"].oneOf[0].properties.update_edges, 'edges3');
+  (0, _testUtils.expectCode)(ast.type); // printCode(ast.type)
+});
 it('execute_msg_for__empty', function () {
   (0, _testUtils.expectCode)((0, _client.createTypeInterface)(ctx, _arrays["default"]));
 });

package/main/utils/types.js

@@ -7,11 +7,11 @@ var _typeof3 = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.getParamsTypeAnnotation = exports.createTypedObjectParams = void 0;
+exports.getParamsTypeAnnotation = exports.detectType = exports.createTypedObjectParams = void 0;
 exports.getPropertySignatureFromProp = getPropertySignatureFromProp;
 exports.getPropertyType = void 0;
 exports.getResponseType = getResponseType;
-exports.getTypeFromRef = exports.getType = void 0;
+exports.getTypeInfo = exports.getTypeFromRef = exports.getType = void 0;
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
@@ -70,7 +70,15 @@ var getTypeOrRef = function getTypeOrRef(obj) {
 };
 
 var getArrayTypeFromItems = function getArrayTypeFromItems(items) {
-  if (items.type === 'array') {
+  // passing in [{"type":"string"}]
+  if (Array.isArray(items)) {
+    return t.tsArrayType(t.tsArrayType(getTypeOrRef(items[0])));
+  } // passing in {"items": [{"type":"string"}]}
+
+
+  var detect = detectType(items.type);
+
+  if (detect.type === 'array') {
     if (Array.isArray(items.items)) {
       return t.tsArrayType(t.tsArrayType(getTypeOrRef(items.items[0])));
     } else {
@@ -78,42 +86,43 @@ var getArrayTypeFromItems = function getArrayTypeFromItems(items) {
     }
   }
 
-  return t.tsArrayType(getType(items.type));
+  return t.tsArrayType(getType(detect.type));
 };
 
-var getType = function getType(type) {
-  switch (type) {
-    case 'string':
-      return t.tsStringKeyword();
-
-    case 'boolean':
-      return t.tSBooleanKeyword();
+var detectType = function detectType(type) {
+  var optional = false;
+  var theType = '';
 
-    case 'integer':
-      return t.tsNumberKeyword();
+  if (Array.isArray(type)) {
+    if (type.length !== 2) {
+      throw new Error('[getType(array length)] case not handled by transpiler. contact maintainers.');
+    }
 
-    default:
-      throw new Error('contact maintainers [unknown type]: ' + type);
-  }
-};
+    var _type = (0, _slicedToArray2["default"])(type, 2),
+        nullableType = _type[0],
+        nullType = _type[1];
 
-exports.getType = getType;
+    if (nullType !== 'null') {
+      throw new Error('[getType(null)] case not handled by transpiler. contact maintainers.');
+    }
 
-var getPropertyType = function getPropertyType(context, schema, prop) {
-  var _schema$properties, _schema$required, _schema$required2;
+    theType = nullableType;
+    optional = true;
+  } else {
+    theType = type;
+  }
 
-  var props = (_schema$properties = schema.properties) !== null && _schema$properties !== void 0 ? _schema$properties : {};
-  var info = props[prop];
-  var type = null;
-  var optional = !((_schema$required = schema.required) !== null && _schema$required !== void 0 && _schema$required.includes(prop));
+  return {
+    type: theType,
+    optional: optional
+  };
+};
 
-  if (info.allOf && info.allOf.length === 1) {
-    info = info.allOf[0];
-  }
+exports.detectType = detectType;
 
-  if (typeof info.$ref === 'string') {
-    type = getTypeFromRef(info.$ref);
-  }
+var getTypeInfo = function getTypeInfo(info) {
+  var type = undefined;
+  var optional = undefined;
 
   if (Array.isArray(info.anyOf)) {
     // assuming 2nd is null, but let's check to ensure
@@ -158,7 +167,9 @@ var getPropertyType = function getPropertyType(context, schema, prop) {
         throw new Error('[info.items] case not handled by transpiler. contact maintainers.');
       }
     } else {
-      type = getType(info.type);
+      var detect = detectType(info.type);
+      type = getType(detect.type);
+      optional = detect.optional;
     }
   }
 
@@ -177,14 +188,83 @@ var getPropertyType = function getPropertyType(context, schema, prop) {
     }
 
     if (_nullableType === 'array' && (0, _typeof2["default"])(info.items) === 'object' && !Array.isArray(info.items)) {
-      type = t.tsArrayType(getType(info.items.type));
+      var _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);
+      var _detect2 = detectType(_nullableType);
+
+      optional = _detect2.optional;
+
+      if (_detect2.type === 'array') {
+        type = getArrayTypeFromItems(info.items);
+      } else {
+        type = getType(_detect2.type);
+      }
     }
 
     optional = true;
   }
 
+  return {
+    type: type,
+    optional: optional
+  };
+};
+
+exports.getTypeInfo = getTypeInfo;
+
+var getType = function 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);
+  }
+};
+
+exports.getType = getType;
+
+var getPropertyType = function getPropertyType(context, schema, prop) {
+  var _schema$properties, _schema$required, _schema$required2;
+
+  var props = (_schema$properties = schema.properties) !== null && _schema$properties !== void 0 ? _schema$properties : {};
+  var info = props[prop];
+  var type = null;
+  var optional = !((_schema$required = schema.required) !== null && _schema$required !== void 0 && _schema$required.includes(prop));
+
+  if (info.allOf && info.allOf.length === 1) {
+    info = info.allOf[0];
+  }
+
+  if (typeof info.$ref === 'string') {
+    type = getTypeFromRef(info.$ref);
+  }
+
+  var 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));
   }
@@ -256,7 +336,7 @@ function getPropertySignatureFromProp(context, jsonschema, prop, camelize) {
     getPropertyType(context, jsonschema, prop);
   } catch (e) {
     console.log(e);
-    console.log(jsonschema, prop);
+    console.log(JSON.stringify(jsonschema, null, 2), prop);
   }
 
   var _getPropertyType = getPropertyType(context, jsonschema, prop),

package/module/client/test/ts-client.account-nfts.spec.js

@@ -0,0 +1,17 @@
+import contract from '../../../../../__fixtures__/idl-version/accounts-nft/account-nft.json';
+import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
+import { expectCode, makeContext } from '../../../test-utils';
+const message = contract.query;
+const ctx = makeContext(message);
+it('execute_msg_for__empty', () => {
+  expectCode(createTypeInterface(ctx, message));
+});
+it('query classes', () => {
+  expectCode(createQueryClass(ctx, 'SG721QueryClient', 'SG721ReadOnlyInstance', message));
+});
+it('execute classes array types', () => {
+  expectCode(createExecuteClass(ctx, 'SG721Client', 'SG721Instance', null, message));
+});
+it('execute interfaces no extends', () => {
+  expectCode(createExecuteInterface(ctx, 'SG721Instance', null, message));
+});

package/module/client/test/ts-client.arrays.spec.js

@@ -1,7 +1,12 @@
 import message from '../../../../../__fixtures__/misc/schema/arrays.json';
 import { createQueryClass, createExecuteClass, createExecuteInterface, createTypeInterface } from '../client';
 import { expectCode, makeContext } from '../../../test-utils';
+import { getPropertyType } from '../../utils';
 const ctx = makeContext(message);
+it('getPropertyType', () => {
+  const ast = getPropertyType(ctx, message.oneOf[0].properties.update_edges, 'edges3');
+  expectCode(ast.type); // printCode(ast.type)
+});
 it('execute_msg_for__empty', () => {
   expectCode(createTypeInterface(ctx, message));
 });

package/module/utils/types.js

@@ -37,7 +37,15 @@ const getTypeOrRef = obj => {
 };
 
 const getArrayTypeFromItems = items => {
-  if (items.type === 'array') {
+  // passing in [{"type":"string"}]
+  if (Array.isArray(items)) {
+    return t.tsArrayType(t.tsArrayType(getTypeOrRef(items[0])));
+  } // passing in {"items": [{"type":"string"}]}
+
+
+  const detect = detectType(items.type);
+
+  if (detect.type === 'array') {
     if (Array.isArray(items.items)) {
       return t.tsArrayType(t.tsArrayType(getTypeOrRef(items.items[0])));
     } else {
@@ -45,37 +53,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
@@ -118,7 +127,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;
     }
   }
 
@@ -135,14 +146,74 @@ 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);
+      const detect = detectType(nullableType);
+      optional = detect.optional;
+
+      if (detect.type === 'array') {
+        type = getArrayTypeFromItems(info.items);
+      } else {
+        type = getType(detect.type);
+      }
     }
 
     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));
   }
@@ -201,7 +272,7 @@ export function getPropertySignatureFromProp(context, jsonschema, prop, camelize
     getPropertyType(context, jsonschema, prop);
   } catch (e) {
     console.log(e);
-    console.log(jsonschema, prop);
+    console.log(JSON.stringify(jsonschema, null, 2), prop);
   }
 
   const {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-ast-types",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "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": "94c5785d947e329df1cc9108cc33bb7a0c21af60"
+  "gitHead": "4d6287ab9d17ea8cef91b183c00e9bae6e8529e1"
 }

package/types/utils/types.d.ts

@@ -4,7 +4,15 @@ 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;