@cosmwasm/ts-codegen 0.3.9

package/module/commands/recoil.js

@@ -0,0 +1,33 @@
+import { prompt } from '../prompt';
+import recoil from '../recoil';
+import { readSchemas } from '../utils';
+export default (async argv => {
+  const questions = [{
+    _: true,
+    type: 'path',
+    name: 'schema',
+    message: 'which directory contains the the Rust contracts?',
+    default: './schema'
+  }, {
+    _: true,
+    type: 'path',
+    name: 'out',
+    message: 'where is the output directory?',
+    default: './ts'
+  }, {
+    _: true,
+    type: 'string',
+    name: 'name',
+    message: 'contract name?'
+  }];
+  const {
+    schema,
+    out,
+    name
+  } = await prompt(questions, argv);
+  const schemas = readSchemas({
+    schemaDir: schema,
+    argv
+  });
+  await recoil(name, schemas, out);
+});

package/module/cosmwasm-typescript-gen.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { cli } from './cli';
+
+var argv = require('minimist')(process.argv.slice(2));
+
+(async () => {
+  await cli(argv);
+})();

package/module/file.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { prompt } from './prompt';
+import { cli } from './cli';
+import { readFileSync } from 'fs';
+
+const argv = require('minimist')(process.argv.slice(2));
+
+const question = [{
+  _: true,
+  type: 'string',
+  name: 'file',
+  message: 'file'
+}];
+
+(async () => {
+  const {
+    file
+  } = await prompt(question, argv);
+  const argvv = JSON.parse(readFileSync(file, 'utf-8'));
+  await cli(argvv);
+})();

package/module/from-partial.js

@@ -0,0 +1,41 @@
+import { pascal } from "case";
+import { header } from './header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from 'wasm-ast-types';
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { getMessageProperties } from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg } from "./utils";
+export default (async (name, schemas, outPath) => {
+  const FromPartialFile = pascal(`${name}Contract`) + '.from-partial.ts';
+  const Contract = pascal(`${name}Contract`) + '.ts';
+  const ExecuteMsg = findExecuteMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+  const body = [];
+  body.push(w.importStmt(['MsgExecuteContractEncodeObject'], 'cosmwasm'));
+  body.push(w.importStmt(['MsgExecuteContract'], 'cosmjs-types/cosmwasm/wasm/v1/tx'));
+  body.push(w.importStmt(['toUtf8'], '@cosmjs/encoding'));
+
+  if (!typeHash.hasOwnProperty('Coin')) {
+    body.push(w.importStmt(['Coin'], '@cosmjs/amino'));
+  }
+
+  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, ''))); // execute messages
+
+  if (ExecuteMsg) {
+    const children = getMessageProperties(ExecuteMsg);
+
+    if (children.length > 0) {
+      const TheClass = pascal(`${name}MessageComposer`);
+      const Interface = pascal(`${name}Message`);
+      body.push(w.createFromPartialInterface(Interface, ExecuteMsg));
+      body.push(w.createFromPartialClass(TheClass, Interface, ExecuteMsg));
+    }
+  }
+
+  const code = header + generate(t.program(body)).code;
+  mkdirp(outPath);
+  writeFileSync(join(outPath, FromPartialFile), code);
+});

package/module/generate.js

@@ -0,0 +1,57 @@
+import { pascal } from "case";
+import { header } from './header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from 'wasm-ast-types';
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { clean } from "./clean";
+import { getMessageProperties } from "wasm-ast-types";
+import { findAndParseTypes, findExecuteMsg, findQueryMsg } from "./utils";
+export default (async (name, schemas, outPath) => {
+  const Contract = pascal(`${name}Contract`) + '.ts';
+  const QueryMsg = findQueryMsg(schemas);
+  const ExecuteMsg = findExecuteMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+  let Client = null;
+  let Instance = null;
+  let QueryClient = null;
+  let ReadOnlyInstance = null;
+  const body = [];
+  body.push(w.importStmt(['CosmWasmClient', 'ExecuteResult', 'SigningCosmWasmClient'], '@cosmjs/cosmwasm-stargate'));
+
+  if (typeHash.hasOwnProperty('Coin')) {
+    body.push(w.importStmt(['StdFee'], '@cosmjs/amino'));
+  } else {
+    body.push(w.importStmt(['Coin', 'StdFee'], '@cosmjs/amino'));
+  } // TYPES
+
+
+  Object.values(typeHash).forEach(type => {
+    body.push(clean(type));
+  }); // query messages
+
+  if (QueryMsg) {
+    QueryClient = pascal(`${name}QueryClient`);
+    ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
+    body.push(w.createQueryInterface(ReadOnlyInstance, QueryMsg));
+    body.push(w.createQueryClass(QueryClient, ReadOnlyInstance, QueryMsg));
+  } // execute messages
+
+
+  if (ExecuteMsg) {
+    const children = getMessageProperties(ExecuteMsg);
+
+    if (children.length > 0) {
+      Client = pascal(`${name}Client`);
+      Instance = pascal(`${name}Interface`);
+      body.push(w.createExecuteInterface(Instance, ReadOnlyInstance, ExecuteMsg));
+      body.push(w.createExecuteClass(Client, Instance, QueryClient, ExecuteMsg));
+    }
+  }
+
+  const code = header + generate(t.program(body)).code;
+  mkdirp(outPath);
+  writeFileSync(join(outPath, Contract), code);
+});

package/module/header.js

@@ -0,0 +1,8 @@
+import pkg from '../package.json';
+const version = process.env.NODE_ENV === 'test' ? 'latest' : pkg.version;
+export const header = `/**
+* This file was automatically generated by ${pkg.name}@${version}.
+* DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+* and run the ${pkg.name} generate command to regenerate this file.
+*/
+\n`;

package/module/index.js

@@ -0,0 +1,5 @@
+export { default as generate } from './generate';
+export { default as fromPartial } from './from-partial';
+export { default as reactQuery } from './react-query';
+export { default as recoil } from './recoil';
+export * from './utils';

package/module/parse.js

@@ -0,0 +1,37 @@
+import babelTraverse from '@babel/traverse';
+import { parse } from '@babel/parser';
+export const parser = codes => {
+  const hash = {};
+  codes.forEach(code => {
+    const plugins = ['typescript'];
+    const ast = parse(code, {
+      sourceType: 'module',
+      plugins
+    });
+    const visitor = visitorFn({
+      addType(key, node) {
+        hash[key] = node;
+      }
+
+    });
+    babelTraverse(ast, visitor);
+  });
+  return hash;
+};
+
+const visitorFn = parser => ({
+  TSTypeAliasDeclaration(path) {
+    parser.addType(path.node.id.name, path.parentPath.node); // if (path.node.id.name.endsWith('For_Empty')) {
+    //     const newName = path.node.id.name.replace(/For_Empty$/, '_for_Empty');
+    //     path.parentPath.node.declaration.id.name = newName;
+    //     parser.addType(newName, path.parentPath.node);
+    // } else {
+    //     parser.addType(path.node.id.name, path.parentPath.node);
+    // }
+  },
+
+  TSInterfaceDeclaration(path) {
+    parser.addType(path.node.id.name, path.parentPath.node);
+  }
+
+});

package/module/prompt.js

@@ -0,0 +1,68 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { filter } from 'fuzzy';
+import { prompt as inquirerer } from 'inquirerer';
+export const getFuzzySearch = list => {
+  return (answers, input) => {
+    input = input || '';
+    return new Promise(function (resolve) {
+      setTimeout(function () {
+        const fuzzyResult = filter(input, list);
+        resolve(fuzzyResult.map(function (el) {
+          return el.original;
+        }));
+      }, 25);
+    });
+  };
+};
+export const getFuzzySearchNames = nameValueItemList => {
+  const list = nameValueItemList.map(({
+    name,
+    value
+  }) => name);
+  return (answers, input) => {
+    input = input || '';
+    return new Promise(function (resolve) {
+      setTimeout(function () {
+        const fuzzyResult = filter(input, list);
+        resolve(fuzzyResult.map(function (el) {
+          return nameValueItemList.find(({
+            name,
+            value
+          }) => el.original == name);
+        }));
+      }, 25);
+    });
+  };
+};
+
+const transform = questions => {
+  return questions.map(q => {
+    if (q.type === 'fuzzy') {
+      const choices = q.choices;
+      delete q.choices;
+      return _objectSpread(_objectSpread({}, q), {}, {
+        type: 'autocomplete',
+        source: getFuzzySearch(choices)
+      });
+    } else if (q.type === 'fuzzy:objects') {
+      const choices = q.choices;
+      delete q.choices;
+      return _objectSpread(_objectSpread({}, q), {}, {
+        type: 'autocomplete',
+        source: getFuzzySearchNames(choices)
+      });
+    } else {
+      return q;
+    }
+  });
+};
+
+export const prompt = async (questions = [], argv = {}) => {
+  questions = transform(questions);
+  return await inquirerer(questions, argv);
+};

package/module/react-query.js

@@ -0,0 +1,31 @@
+import { pascal } from "case";
+import { header } from './header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from 'wasm-ast-types';
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { findAndParseTypes, findQueryMsg } from "./utils";
+export default (async (name, schemas, outPath) => {
+  const RecoilFile = pascal(`${name}Contract`) + '.react-query.ts';
+  const Contract = pascal(`${name}Contract`) + '.ts';
+  const QueryMsg = findQueryMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+  let QueryClient = null;
+  let ReadOnlyInstance = null;
+  const body = [];
+  body.push(w.importStmt(['useQuery', 'UseQueryOptions'], 'react-query'));
+  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, ''))); // query messages
+
+  if (QueryMsg) {
+    QueryClient = pascal(`${name}QueryClient`);
+    ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
+    body.push(w.importStmt([QueryClient], `./${Contract}`));
+    [].push.apply(body, w.createReactQueryHooks(QueryMsg, name, QueryClient));
+  }
+
+  const code = header + generate(t.program(body)).code;
+  mkdirp(outPath);
+  writeFileSync(join(outPath, RecoilFile), code);
+});

package/module/recoil.js

@@ -0,0 +1,34 @@
+import { pascal } from "case";
+import { header } from './header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as w from 'wasm-ast-types';
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { findAndParseTypes, findQueryMsg } from "./utils";
+export default (async (name, schemas, outPath) => {
+  const RecoilFile = pascal(`${name}Contract`) + '.recoil.ts';
+  const Contract = pascal(`${name}Contract`) + '.ts';
+  const QueryMsg = findQueryMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+  let QueryClient = null;
+  let ReadOnlyInstance = null;
+  const body = [];
+  body.push(w.importStmt(['selectorFamily'], 'recoil'));
+  body.push(w.importStmt(['cosmWasmClient'], './chain'));
+  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, ''))); // query messages
+
+  if (QueryMsg) {
+    QueryClient = pascal(`${name}QueryClient`);
+    ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
+    body.push(w.importStmt([QueryClient], `./${Contract}`));
+    body.push(w.createRecoilQueryClientType());
+    body.push(w.createRecoilQueryClient(name, QueryClient));
+    [].push.apply(body, w.createRecoilSelectors(name, QueryClient, QueryMsg));
+  }
+
+  const code = header + generate(t.program(body)).code;
+  mkdirp(outPath);
+  writeFileSync(join(outPath, RecoilFile), code);
+});

package/module/utils.js

@@ -0,0 +1,52 @@
+import { sync as glob } from 'glob';
+import { readFileSync } from 'fs';
+import { cleanse } from './cleanse';
+import { compile } from 'json-schema-to-typescript';
+import { parser } from "./parse";
+export const readSchemas = ({
+  schemaDir,
+  argv,
+  clean = true
+}) => {
+  const fn = clean ? cleanse : str => str;
+  const files = glob(schemaDir + '/**/*.json');
+  const schemas = files.map(file => JSON.parse(readFileSync(file, 'utf-8')));
+
+  if (argv.packed) {
+    if (schemas.length !== 1) {
+      throw new Error('packed option only supports one file');
+    }
+
+    return Object.values(fn(schemas[0]));
+  }
+
+  return fn(schemas);
+};
+export const findQueryMsg = schemas => {
+  const QueryMsg = schemas.find(schema => schema.title === 'QueryMsg');
+  return QueryMsg;
+};
+export const findExecuteMsg = schemas => {
+  const ExecuteMsg = schemas.find(schema => schema.title === 'ExecuteMsg' || schema.title === 'ExecuteMsg_for_Empty' || // if cleanse is used, this is never
+  schema.title === 'ExecuteMsgForEmpty');
+  return ExecuteMsg;
+};
+export const findAndParseTypes = async schemas => {
+  const Types = schemas;
+  const allTypes = [];
+
+  for (const typ in Types) {
+    if (Types[typ].definitions) {
+      for (const key of Object.keys(Types[typ].definitions)) {
+        // set title
+        Types[typ].definitions[key].title = key;
+      }
+    }
+
+    const result = await compile(Types[typ], Types[typ].title);
+    allTypes.push(result);
+  }
+
+  const typeHash = parser(allTypes);
+  return typeHash;
+};

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@cosmwasm/ts-codegen",
+  "version": "0.3.9",
+  "description": "A TypeScript Transpiler for CosmWasm Smart Contracts",
+  "author": "Dan Lynch <pyramation@gmail.com>",
+  "homepage": "https://github.com/pyramation/cosmwasm-typescript-gen",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "main/index.js",
+  "module": "module/index.js",
+  "typings": "types/index.d.ts",
+  "bin": {
+    "cosmwasm-typescript-gen": "main/cosmwasm-typescript-gen.js"
+  },
+  "directories": {
+    "lib": "src",
+    "test": "__tests__"
+  },
+  "files": [
+    "types",
+    "main",
+    "module"
+  ],
+  "scripts": {
+    "build:main": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start --extensions \".tsx,.ts,.js\"",
+    "build:module": "cross-env MODULE=true babel src --out-dir module --delete-dir-on-start  --extensions \".tsx,.ts,.js\"",
+    "build": "npm run build:module && npm run build:main",
+    "build:ts": "tsc --project ./tsconfig.json",
+    "prepare": "npm run build",
+    "dev": "cross-env NODE_ENV=development babel-node src/cosmwasm-typescript-gen --extensions \".tsx,.ts,.js\"",
+    "watch": "cross-env NODE_ENV=development babel-watch src/cosmwasm-typescript-gen --extensions \".tsx,.ts,.js\"",
+    "file": "cross-env NODE_ENV=development babel-watch src/file --extensions \".tsx,.ts,.js\"",
+    "lint": "eslint .",
+    "format": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pyramation/cosmwasm-typescript-gen"
+  },
+  "keywords": [],
+  "bugs": {
+    "url": "https://github.com/pyramation/cosmwasm-typescript-gen/issues"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.17.10",
+    "@babel/eslint-parser": "^7.18.2",
+    "@babel/node": "^7.18.5",
+    "@types/jest": "^28.1.2",
+    "ast-stringify": "0.1.0",
+    "babel-core": "7.0.0-bridge.0",
+    "babel-jest": "28.1.1",
+    "babel-watch": "^7.0.0",
+    "cosmwasm": "1.1.1",
+    "cross-env": "^7.0.2",
+    "eslint": "8.17.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^28.1.1",
+    "jest-in-case": "^1.0.2",
+    "prettier": "^2.7.1",
+    "regenerator-runtime": "^0.13.7",
+    "ts-jest": "^28.0.5",
+    "typescript": "^4.7.4"
+  },
+  "dependencies": {
+    "@babel/core": "7.18.5",
+    "@babel/generator": "7.18.2",
+    "@babel/parser": "7.18.5",
+    "@babel/plugin-proposal-class-properties": "7.17.12",
+    "@babel/plugin-proposal-export-default-from": "7.17.12",
+    "@babel/plugin-proposal-object-rest-spread": "7.18.0",
+    "@babel/plugin-transform-runtime": "7.18.5",
+    "@babel/preset-env": "7.18.2",
+    "@babel/preset-typescript": "^7.17.12",
+    "@babel/runtime": "^7.18.3",
+    "@babel/traverse": "7.18.5",
+    "@babel/types": "7.18.4",
+    "case": "1.6.3",
+    "dargs": "7.0.0",
+    "fuzzy": "0.1.3",
+    "glob": "8.0.3",
+    "inquirerer": "0.1.3",
+    "json-schema-to-typescript": "10.1.5",
+    "long": "^5.2.0",
+    "minimist": "1.2.6",
+    "mkdirp": "1.0.4",
+    "shelljs": "0.8.5",
+    "wasm-ast-types": "^0.3.7"
+  }
+}

package/types/clean.d.ts

@@ -0,0 +1 @@
+export declare const clean: (obj: any) => any;

package/types/cli.d.ts

@@ -0,0 +1 @@
+export function cli(argv: any): Promise<void>;

package/types/cmds.d.ts

@@ -0,0 +1 @@
+export const Commands: typeof Commands;

package/types/commands/boilerplate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (argv: any) => Promise<any>;
+export default _default;

package/types/commands/from-partial.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (argv: any) => Promise<void>;
+export default _default;

package/types/commands/generate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (argv: any) => Promise<void>;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: (argv: any) => Promise<void>;
+export default _default;

package/types/commands/recoil.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (argv: any) => Promise<void>;
+export default _default;

package/types/cosmwasm-typescript-gen.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/file.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/from-partial.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (name: string, schemas: any[], outPath: string) => Promise<void>;
+export default _default;

package/types/generate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (name: string, schemas: any[], outPath: string) => Promise<void>;
+export default _default;

package/types/header.d.ts

@@ -0,0 +1 @@
+export declare const header: string;

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export { default as generate } from './generate';
+export { default as fromPartial } from './from-partial';
+export { default as reactQuery } from './react-query';
+export { default as recoil } from './recoil';
+export * from './utils';

package/types/parse.d.ts

@@ -0,0 +1 @@
+export declare const parser: (codes: any) => {};

package/types/prompt.d.ts

@@ -0,0 +1,3 @@
+export function getFuzzySearch(list: any): (answers: any, input: any) => Promise<any>;
+export function getFuzzySearchNames(nameValueItemList: any): (answers: any, input: any) => Promise<any>;
+export function prompt(questions?: any[], argv?: {}): Promise<any>;

package/types/react-query.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (name: string, schemas: any[], outPath: string) => Promise<void>;
+export default _default;

package/types/recoil.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (name: string, schemas: any[], outPath: string) => Promise<void>;
+export default _default;

package/types/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const readSchemas: ({ schemaDir, argv }: {
+    schemaDir: any;
+    argv: any;
+}) => any[];