wasm-ast-types 0.2.5 → 0.3.1

package/main/wasm.vectis.spec.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _generator = _interopRequireDefault(require("@babel/generator"));
+
+var _cosmos_msg_for__empty = _interopRequireDefault(require("./../../../__fixtures__/vectis/govec/cosmos_msg_for__empty.json"));
+
+var _execute_msg_for__empty = _interopRequireDefault(require("./../../../__fixtures__/vectis/govec/execute_msg_for__empty.json"));
+
+var _can_execute_relay_response = _interopRequireDefault(require("./../../../__fixtures__/vectis/govec/can_execute_relay_response.json"));
+
+var _info_response = _interopRequireDefault(require("./../../../__fixtures__/vectis/govec/info_response.json"));
+
+var _relay_transaction = _interopRequireDefault(require("./../../../__fixtures__/vectis/govec/relay_transaction.json"));
+
+var _wasm = require("./wasm");
+
+var expectCode = function expectCode(ast) {
+  expect((0, _generator["default"])(ast).code).toMatchSnapshot();
+};
+
+var printCode = function printCode(ast) {
+  console.log((0, _generator["default"])(ast).code);
+};
+
+it('cosmos_msg_for__empty', function () {
+  expectCode((0, _wasm.createTypeInterface)(_cosmos_msg_for__empty["default"]));
+});
+it('execute_msg_for__empty', function () {
+  expectCode((0, _wasm.createTypeInterface)(_execute_msg_for__empty["default"]));
+});
+it('can_execute_relay_response', function () {
+  expectCode((0, _wasm.createTypeInterface)(_can_execute_relay_response["default"]));
+});
+it('info_response', function () {
+  expectCode((0, _wasm.createTypeInterface)(_info_response["default"]));
+});
+it('relay_transaction', function () {
+  expectCode((0, _wasm.createTypeInterface)(_relay_transaction["default"]));
+});
+it('query classes', function () {
+  expectCode((0, _wasm.createQueryClass)('SG721QueryClient', 'SG721ReadOnlyInstance', _cosmos_msg_for__empty["default"]));
+});
+it('query classes', function () {
+  expectCode((0, _wasm.createQueryClass)('SG721QueryClient', 'SG721ReadOnlyInstance', _execute_msg_for__empty["default"]));
+});
+it('execute classes array types', function () {
+  expectCode((0, _wasm.createExecuteClass)('SG721Client', 'SG721Instance', null, _execute_msg_for__empty["default"]));
+});
+it('execute interfaces no extends', function () {
+  expectCode((0, _wasm.createExecuteInterface)('SG721Instance', null, _execute_msg_for__empty["default"]));
+});

package/module/messages.js

@@ -1,134 +1,10 @@
 import * as t from '@babel/types';
 import { camel } from 'case';
 import { bindMethod, typedIdentifier, classDeclaration, classProperty, arrowFunctionExpression, getMessageProperties } from './utils';
+import { createTypedObjectParams } from './utils/types';
+import { identifier, tsTypeOperator } from './utils/babel';
 
-const getTypeFromRef = $ref => {
-  switch ($ref) {
-    case '#/definitions/Binary':
-      return t.tsTypeReference(t.identifier('Binary'));
-
-    default:
-      if ($ref.startsWith('#/definitions/')) {
-        return t.tsTypeReference(t.identifier($ref.replace('#/definitions/', '')));
-      }
-
-      throw new Error('what is $ref: ' + $ref);
-  }
-};
-
-const getArrayTypeFromRef = $ref => {
-  return t.tsArrayType(getTypeFromRef($ref));
-};
-
-const getArrayTypeFromType = type => {
-  return t.tsArrayType(getType(type));
-}; // MARKED AS NOT DRY 
-
-
-const identifier = (name, typeAnnotation, optional = false) => {
-  const type = t.identifier(name);
-  type.typeAnnotation = typeAnnotation;
-  type.optional = optional;
-  return type;
-};
-
-const getType = type => {
-  switch (type) {
-    case 'string':
-      return t.tsStringKeyword();
-
-    case 'boolean':
-      return t.tSBooleanKeyword();
-
-    case 'integer':
-      return t.tsNumberKeyword();
-
-    default:
-      throw new Error('what is type: ' + type);
-  }
-}; // MARKED AS NOT DRY 
-
-
-const getPropertyType = (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);
-  }
-
-  if (Array.isArray(info.anyOf)) {
-    // assuming 2nd is null, but let's check to ensure
-    if (info.anyOf.length !== 2) {
-      throw new Error('case not handled by transpiler. contact maintainers.');
-    }
-
-    const [nullableType, nullType] = info.anyOf;
-
-    if (nullType?.type !== 'null') {
-      throw new Error('case not handled by transpiler. contact maintainers.');
-    }
-
-    type = getTypeFromRef(nullableType?.$ref);
-    optional = true;
-  }
-
-  if (typeof info.type === 'string') {
-    if (info.type === 'array') {
-      if (info.items.$ref) {
-        type = getArrayTypeFromRef(info.items.$ref);
-      } else {
-        type = getArrayTypeFromType(info.items.type);
-      }
-    } else {
-      type = getType(info.type);
-    }
-  }
-
-  if (Array.isArray(info.type)) {
-    // assuming 2nd is null, but let's check to ensure
-    if (info.type.length !== 2) {
-      throw new Error('case not handled by transpiler. contact maintainers.');
-    }
-
-    const [nullableType, nullType] = info.type;
-
-    if (nullType !== 'null') {
-      throw new Error('case not handled by transpiler. contact maintainers.');
-    }
-
-    type = getType(nullableType);
-    optional = true;
-  }
-
-  if (!type) {
-    throw new Error('cannot find type for ' + JSON.stringify(info));
-  }
-
-  if (schema.required?.includes(prop)) {
-    optional = false;
-  }
-
-  return {
-    type,
-    optional
-  };
-};
-
-const tsTypeOperator = (typeAnnotation, operator) => {
-  const obj = t.tsTypeOperator(typeAnnotation);
-  obj.operator = operator;
-  return obj;
-}; // MARKED AS NOT DRY 
-
-
-const createWasmExecMethod = jsonschema => {
+const createWasmExecMethodPartial = jsonschema => {
   const underscoreName = Object.keys(jsonschema.properties)[0];
   const methodName = camel(underscoreName);
   const properties = jsonschema.properties[underscoreName].properties ?? {};
@@ -169,7 +45,7 @@ export const createFromPartialClass = (className, implementsClassName, execMsg)
   const propertyNames = getMessageProperties(execMsg).map(method => Object.keys(method.properties)?.[0]).filter(Boolean);
   const bindings = propertyNames.map(camel).map(bindMethod);
   const methods = getMessageProperties(execMsg).map(schema => {
-    return createWasmExecMethod(schema);
+    return createWasmExecMethodPartial(schema);
   });
   const blockStmt = [];
   [].push.apply(blockStmt, [t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('sender')), t.identifier('sender'))), t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.identifier('contractAddress'))), ...bindings]);
@@ -190,42 +66,6 @@ export const createFromPartialInterface = (className, execMsg) => {
   t.tSPropertySignature(t.identifier('sender'), t.tsTypeAnnotation(t.tsStringKeyword())), ...methods])));
 }; // MARKED AS NOT DRY 
 
-const propertySignature = (name, typeAnnotation, optional = false) => {
-  // prop.leadingComments = [{
-  //   type: 'Comment',
-  //   value: ' Data on the token itself'
-  // }];
-  // prop.leadingComments = [{
-  //   type: 'CommentBlock',
-  //   value: '* Data on the token itself'
-  // }];
-  return {
-    type: 'TSPropertySignature',
-    key: t.identifier(name),
-    typeAnnotation,
-    optional
-  };
-}; // MARKED AS NOT DRY 
-
-
-const createTypedObjectParams = (jsonschema, camelize = true) => {
-  const keys = Object.keys(jsonschema.properties ?? {});
-  if (!keys.length) return;
-  const typedParams = keys.map(prop => {
-    const {
-      type,
-      optional
-    } = getPropertyType(jsonschema, prop);
-    return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(type), optional);
-  });
-  const params = keys.map(prop => {
-    return t.objectProperty(camelize ? t.identifier(camel(prop)) : t.identifier(prop), camelize ? t.identifier(camel(prop)) : t.identifier(prop), false, true);
-  });
-  const obj = t.objectPattern([...params]);
-  obj.typeAnnotation = t.tsTypeAnnotation(t.tsTypeLiteral([...typedParams]));
-  return obj;
-};
-
 const createPropertyFunctionWithObjectParamsForPartial = (methodName, responseType, jsonschema) => {
   const obj = createTypedObjectParams(jsonschema);
   const fixedParams = [// identifier('fee', t.tsTypeAnnotation(

package/module/messages.spec.js

@@ -1,5 +1,5 @@
 import generate from '@babel/generator';
-import execute_msg from './__fixtures__/schema/execute_msg_for__empty.json';
+import execute_msg from './../../../__fixtures__/basic/execute_msg_for__empty.json';
 import { createFromPartialClass, createFromPartialInterface } from './messages';
 
 const expectCode = ast => {

package/module/react-query.js

@@ -1,7 +1,8 @@
 import * as t from '@babel/types';
 import { camel, pascal } from 'case';
 import { tsPropertySignature, tsObjectPattern, callExpression, getMessageProperties } from './utils';
-import { propertySignature, getPropertyType } from './wasm';
+import { propertySignature } from './utils/babel';
+import { getPropertyType } from './utils/types';
 export const createReactQueryHooks = (queryMsg, contractName, QueryClient) => {
   return getMessageProperties(queryMsg).reduce((m, schema) => {
     const underscoreName = Object.keys(schema.properties)[0];

package/module/react-query.spec.js

@@ -1,6 +1,6 @@
 import generate from '@babel/generator';
 import * as t from '@babel/types';
-import query_msg from './__fixtures__/schema/query_msg.json';
+import query_msg from './../../../__fixtures__/basic/query_msg.json';
 import { createReactQueryHooks } from './react-query';
 
 const expectCode = ast => {
@@ -21,6 +21,6 @@ const printCode = ast => {
 
 
 it('createReactQueryHooks', () => {
-  printCode(t.program(createReactQueryHooks(query_msg, 'Sg721', 'Sg721QueryClient')));
+  expectCode(t.program(createReactQueryHooks(query_msg, 'Sg721', 'Sg721QueryClient')));
   expectCode(t.program(createReactQueryHooks(query_msg, 'Sg721', 'Sg721QueryClient')));
 });

package/module/recoil.spec.js

@@ -1,6 +1,6 @@
 import generate from '@babel/generator';
 import * as t from '@babel/types';
-import query_msg from './__fixtures__/schema/query_msg.json';
+import query_msg from './../../../__fixtures__/basic/query_msg.json';
 import { createRecoilSelector, createRecoilSelectors, createRecoilQueryClient } from './recoil';
 
 const expectCode = ast => {

package/module/{utils.js → utils/babel.js}

@@ -1,5 +1,24 @@
 import * as t from '@babel/types';
 import { snake } from "case";
+export const propertySignature = (name, typeAnnotation, optional = false) => {
+  return {
+    type: 'TSPropertySignature',
+    key: t.identifier(name),
+    typeAnnotation,
+    optional
+  };
+};
+export const identifier = (name, typeAnnotation, optional = false) => {
+  const type = t.identifier(name);
+  type.typeAnnotation = typeAnnotation;
+  type.optional = optional;
+  return type;
+};
+export const tsTypeOperator = (typeAnnotation, operator) => {
+  const obj = t.tsTypeOperator(typeAnnotation);
+  obj.operator = operator;
+  return obj;
+};
 export const getMessageProperties = msg => {
   if (msg.anyOf) return msg.anyOf;
   if (msg.oneOf) return msg.oneOf;

package/module/{utils.spec.js → utils/babel.spec.js}

@@ -1,7 +1,7 @@
-import { importStmt } from './utils';
+import { importStmt } from './babel';
 import generate from '@babel/generator';
 import * as t from '@babel/types';
-import { bindMethod, typedIdentifier, promiseTypeAnnotation, classDeclaration, classProperty, arrowFunctionExpression } from './utils';
+import { bindMethod, typedIdentifier, promiseTypeAnnotation, classDeclaration, classProperty, arrowFunctionExpression } from './babel';
 
 const expectCode = ast => {
   expect(generate(ast).code).toMatchSnapshot();

package/module/utils/index.js

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

package/module/utils/types.js

@@ -0,0 +1,200 @@
+import * as t from '@babel/types';
+import { camel } from 'case';
+import { propertySignature } from './babel';
+export const forEmptyNameFix = name => {
+  if (name.endsWith('For_Empty')) {
+    return name.replace(/For_Empty$/, '_for_Empty');
+  }
+
+  return name;
+};
+
+const getTypeFromRef = $ref => {
+  switch ($ref) {
+    case '#/definitions/Binary':
+      return t.tsTypeReference(t.identifier('Binary'));
+
+    default:
+      if ($ref?.startsWith('#/definitions/')) {
+        return t.tsTypeReference(t.identifier($ref.replace('#/definitions/', '')));
+      }
+
+      throw new Error('what is $ref: ' + $ref);
+  }
+};
+
+const getArrayTypeFromRef = $ref => {
+  return t.tsArrayType(getTypeFromRef($ref));
+};
+
+const getArrayTypeFromType = type => {
+  return t.tsArrayType(getType(type));
+};
+
+export const getType = type => {
+  switch (type) {
+    case 'string':
+      return t.tsStringKeyword();
+
+    case 'boolean':
+      return t.tSBooleanKeyword();
+
+    case 'integer':
+      return t.tsNumberKeyword();
+    // case 'object':
+    // return t.tsObjectKeyword();
+
+    default:
+      throw new Error('contact maintainers [unknown type]: ' + type);
+  }
+};
+export const getPropertyType = (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);
+  }
+
+  if (Array.isArray(info.anyOf)) {
+    // assuming 2nd is null, but let's check to ensure
+    if (info.anyOf.length !== 2) {
+      throw new Error('case not handled by transpiler. contact maintainers.');
+    }
+
+    const [nullableType, nullType] = info.anyOf;
+
+    if (nullType?.type !== 'null') {
+      throw new Error('[nullableType.type]: case not handled by transpiler. contact maintainers.');
+    }
+
+    if (!nullableType?.$ref) {
+      if (nullableType.title) {
+        type = t.tsTypeReference(t.identifier(nullableType.title));
+      } else {
+        throw new Error('[nullableType.title] case not handled by transpiler. contact maintainers.');
+      }
+    } else {
+      type = getTypeFromRef(nullableType?.$ref);
+    }
+
+    optional = true;
+  }
+
+  if (typeof info.type === 'string') {
+    if (info.type === 'array') {
+      if (info.items.$ref) {
+        type = getArrayTypeFromRef(info.items.$ref);
+      } else if (info.items.title) {
+        type = t.tsArrayType(t.tsTypeReference(t.identifier(info.items.title)));
+      } else if (info.items.type) {
+        type = getArrayTypeFromType(info.items.type);
+      } else {
+        throw new Error('[info.items] case not handled by transpiler. contact maintainers.');
+      }
+    } else {
+      type = getType(info.type);
+    }
+  }
+
+  if (Array.isArray(info.type)) {
+    // assuming 2nd is null, but let's check to ensure
+    if (info.type.length !== 2) {
+      throw new Error('please report this to maintainers (field type): ' + JSON.stringify(info, null, 2));
+    }
+
+    const [nullableType, nullType] = info.type;
+
+    if (nullType !== 'null') {
+      throw new Error('please report this to maintainers (field type): ' + JSON.stringify(info, null, 2));
+    }
+
+    if (nullableType === 'array') {
+      type = t.tsArrayType(getType(info.items.type));
+    } else {
+      type = getType(nullableType);
+    }
+
+    optional = true;
+  }
+
+  if (!type) {
+    throw new Error('cannot find type for ' + JSON.stringify(info));
+  }
+
+  if (schema.required?.includes(prop)) {
+    optional = false;
+  }
+
+  return {
+    type,
+    optional
+  };
+};
+export const createTypedObjectParams = (jsonschema, camelize = true) => {
+  const keys = Object.keys(jsonschema.properties ?? {});
+  if (!keys.length) return;
+  const typedParams = keys.map(prop => {
+    if (jsonschema.properties[prop].type === 'object') {
+      if (jsonschema.properties[prop].title) {
+        return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsTypeReference(t.identifier(forEmptyNameFix(jsonschema.properties[prop].title)))));
+      } else {
+        throw new Error('createTypedObjectParams() contact maintainer');
+      }
+    }
+
+    if (Array.isArray(jsonschema.properties[prop].allOf)) {
+      const isOptional = !jsonschema.required?.includes(prop);
+      const unionTypes = jsonschema.properties[prop].allOf.map(el => {
+        if (el.title) return el.title;
+        return el.type;
+      });
+      const uniqUnionTypes = [...new Set(unionTypes)];
+
+      if (uniqUnionTypes.length === 1) {
+        return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsTypeReference(t.identifier(forEmptyNameFix(uniqUnionTypes[0])))), isOptional);
+      } else {
+        return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsUnionType(uniqUnionTypes.map(typ => t.tsTypeReference(t.identifier(forEmptyNameFix(typ)))))), isOptional);
+      }
+    } else if (Array.isArray(jsonschema.properties[prop].oneOf)) {
+      const oneOf = JSON.stringify(jsonschema.properties[prop].oneOf, null, 2);
+      const isOptional = !jsonschema.required?.includes(prop);
+      const unionTypes = jsonschema.properties[prop].oneOf.map(el => {
+        if (el.title) return el.title;
+        return el.type;
+      });
+      const uniqUnionTypes = [...new Set(unionTypes)];
+
+      if (uniqUnionTypes.length === 1) {
+        return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsTypeReference(t.identifier(forEmptyNameFix(uniqUnionTypes[0])))), isOptional);
+      } else {
+        return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsUnionType(uniqUnionTypes.map(typ => t.tsTypeReference(t.identifier(forEmptyNameFix(typ)))))), isOptional);
+      }
+    }
+
+    try {
+      getPropertyType(jsonschema, prop);
+    } catch (e) {
+      console.log(e);
+      console.log(jsonschema, prop);
+    }
+
+    const {
+      type,
+      optional
+    } = getPropertyType(jsonschema, prop);
+    return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(type), optional);
+  });
+  const params = keys.map(prop => {
+    return t.objectProperty(camelize ? t.identifier(camel(prop)) : t.identifier(prop), camelize ? t.identifier(camel(prop)) : t.identifier(prop), false, true);
+  });
+  const obj = t.objectPattern([...params]);
+  obj.typeAnnotation = t.tsTypeAnnotation(t.tsTypeLiteral([...typedParams]));
+  return obj;
+};