@cosmwasm/ts-codegen 0.7.1 → 0.7.4

package/README.md

@@ -21,36 +21,168 @@ npm install -g @cosmwasm/ts-codegen
 
 The quickest and easiest way to interact with CosmWasm Contracts. `@cosmwasm/ts-codegen` converts your CosmWasm smart contracts into dev-friendly TypeScript classes so you can focus on shipping code.
 
+## Table of contents
+
+- [@cosmwasm/ts-codegen](#cosmwasmts-codegen)
+  - [Table of contents](#table-of-contents)
+- [QuickStart](#quickstart)
+- [Usage](#usage)
+    - [Generate TS Clients](#generate)
+    - [React Query](#react-query)
+    - [Recoil](#recoil)
+    - [Message Composer](#message-composer)
+- [Example Output](#example-output)
+- [JSON Schema](#json-schema)
+    - [JSON Schema Generation](#json-schema-generation)
+    - [Exporting Schemas](#exporting-schemas)
+- [Developing](#developing)
+- [Related](#related)
+### Quickstart 
+
+Clone your project and `cd` into your contracts folder
+
+```sh
+git clone git@github.com:public-awesome/stargaze-contracts.git
+cd stargaze-contracts/contracts/sg721/
+```
+
+Run `cosmwasm-ts-codegen` to generate your code.
+
+```sh
+cosmwasm-ts-codegen generate --schema ./schema --out ./ts --name SG721
+```
+
+The output will be in the folder specified by `--out`, enjoy!
+
 ## usage
 
+Get started quickly using our `cli` by globally installing via npm:
+
+```
+npm install -g @cosmwasm/ts-codegen
 ```
- cosmwasm-ts-codegen generate \
+### generate
+
+Generate a basic TS client for your contracts. The `generate` command will make types which will be essential for your bindings.
+
+This command also generates a `QueryClient` for queries as well as a `Client` for queries and mutations. 
+
+[see example output code](https://gist.github.com/pyramation/ba67ec56e4e2a39cadea55430f9993e5)
+
+
+```sh
+cosmwasm-ts-codegen generate \
     --schema ./schema \
-    --out ./src \
+    --out ./ts \
     --name MyContractName
  ```
 
-### example 
+for programmatic usage, you can use the `tsClient` function:
 
+```ts
+import { tsClient } from '@cosmwasm/ts-codegen';
+declare const tsClient = (name: string, schemas: any[], outPath: string, tsClientOptions: TSClientOptions) => Promise<void>;
 ```
-git clone git@github.com:public-awesome/stargaze-contracts.git
-cd stargaze-contracts/contracts/sg721/
-cosmwasm-ts-codegen generate --schema ./schema --out ./ts --name SG721
+#### TS Client Options
+
+  | option                        | description                                          |
+  | ----------------------------- | ---------------------------------------------------  |
+  | `tsClient.aliasExecuteMsg`    | generate a type alias based on the contract name     |
+
+### react query
+
+Generate [react-query v3](https://react-query-v3.tanstack.com/) or [react-query v4](https://tanstack.com/query/v4/) bindings for your contracts with the `react-query` command.
+
+[see example output code](https://gist.github.com/pyramation/a3bf4aa7b60a31287d0720ca1bb5473b)
+
+
+Example without optional client, using v3, without mutations:
+
+```sh
+cosmwasm-ts-codegen react-query \
+    --schema ./schema \
+    --out ./ts \
+    --name MyContractName \
+    --no-optionalClient \
+    --no-v4 \
+    --no-mutations
 ```
 
-### JSON Schema Generation
+Example with optional client, using v4, with mutations:
+
+```sh
+cosmwasm-ts-codegen react-query \
+    --schema ./schema \
+    --out ./ts \
+    --name MyContractName \
+    --optionalClient \
+    --v4 \
+    --mutations
+```
+
+For programmatic usage, you can use the `reactQuery` function:
+
+```ts
+import { reactQuery } from '@cosmwasm/ts-codegen';
+declare const reactQuery = (
+  contractName: string,
+  schemas: any[],
+  outPath: string,
+  reactQueryOptions?: ReactQueryOptions
+) => Promise<void>;
+```
+
+#### React Query Options
+
+  | option                         | description                                                         |
+  | ------------------------------ | ------------------------------------------------------------------- |
+  | `reactQuery.optionalClient`    | allows contract client to be undefined as the component renders     |
+  | `reactQuery.v4`                | uses `@tanstack/react-query` and syntax instead of v3 `react-query` |
+  | `reactQuery.mutations`         | also generate mutations                                             |
+  | `reactQuery.camelize`          | use camelCase style for property names                            |
+
+### recoil
+
+Generate [recoil](https://recoiljs.org/) bindings for your contracts with the `recoil` command.
+
+[see example output code](https://gist.github.com/pyramation/48b28a75def1a16b233b369297f05f0e)
 
-Currently you have to have the JSON Schema output. Here is an example to start:
 
 ```sh
-## get the Rust contracts
-git clone git@github.com:public-awesome/stargaze-contracts.git
-cd stargaze-contracts
-cargo build
+cosmwasm-ts-codegen recoil \
+    --schema ./schema \
+    --out ./ts \
+    --name MyContractName 
+```
 
-## now build the schema
-cd contracts/sg721/
-cargo schema
+for programmatic usage, you can use the `recoil` function:
+
+```ts
+import { recoil } from '@cosmwasm/ts-codegen';
+declare const recoil = (
+  name: string,
+  schemas: any[],
+  outPath: string
+) => Promise<void>;
+```
+### Message Composer
+
+Generate pure message objects with the proper `utf8` encoding and `typeUrl` configured that you can broadcast yourself via `cosmjs` with the `from-partial` command.
+
+[see example output code](https://gist.github.com/pyramation/f50869d1ecdb6d6ced2bc0a44c6ff492)
+
+```sh
+cosmwasm-ts-codegen from-partial \
+    --schema ./schema \
+    --out ./ts \
+    --name MyContractName 
+```
+
+for programmatic usage, you can use the `fromPartial` function:
+
+```ts
+import { fromPartial } from '@cosmwasm/ts-codegen';
+declare const fromPartial = (name: string, schemas: any[], outPath: string) => Promise<void>;
 ```
 
 ### Example Output
@@ -72,8 +204,28 @@ https://gist.github.com/pyramation/a3bf4aa7b60a31287d0720ca1bb5473b
 https://gist.github.com/pyramation/48b28a75def1a16b233b369297f05f0e
 
 
-### Exporting Schemas
+### JSON Schema
+
+We generate code from the [JSON Schema](https://json-schema.org/) exported from CosmWasm smart contracts.
+### JSON Schema Generation
+
+Currently you have to have the JSON Schema output. Here is an example to start.
+
+First, get the Rust contracts and run `cargo build`:
+
+```sh
+git clone git@github.com:public-awesome/stargaze-contracts.git
+cd stargaze-contracts
+cargo build
+```
+
+now build the schema with `cargo schema`
 
+```sh
+cd contracts/sg721/
+cargo schema
+```
+### Exporting Schemas
 #### `cosmwasm_std` Examples
 
 ```rs
@@ -87,4 +239,38 @@ export_schema_with_title(
       &out_dir,
       "CosmosMsg_for_Empty",
 );
-```
+```
+
+## Developing
+
+### Initial setup
+
+```
+yarn 
+yarn bootstrap
+```
+
+### Building
+
+```
+yarn build
+```
+
+### Tests
+
+Then `cd` into a package and run the tests
+
+```
+cd ./packages/wasm-ast-types
+yarn test:watch
+```
+
+### Working with ASTs
+
+See the [docs](https://github.com/CosmWasm/ts-codegen/blob/main/packages/wasm-ast-types/README.md) in the `wasm-ast-types` package.
+
+## Related
+
+Checkout these related projects:
+
+* [@osmonauts/telescope](https://github.com/osmosis-labs/telescope) a "babel for the Cosmos", Telescope is a TypeScript Transpiler for Cosmos Protobufs.

package/main/generators/ts-client.js

@@ -40,19 +40,23 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 var _default = /*#__PURE__*/function () {
-  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(name, schemas, outPath) {
-    var Contract, QueryMsg, ExecuteMsg, typeHash, Client, Instance, QueryClient, ReadOnlyInstance, body, context, children, code;
+  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(name, schemas, outPath, tsClientOptions) {
+    var context, options, Contract, QueryMsg, ExecuteMsg, typeHash, Client, Instance, QueryClient, ReadOnlyInstance, body, children, code;
     return _regenerator["default"].wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
+            context = new w.RenderContext((0, _utils.getDefinitionSchema)(schemas), {
+              tsClient: tsClientOptions !== null && tsClientOptions !== void 0 ? tsClientOptions : {}
+            });
+            options = context.options.reactQuery;
             Contract = (0, _case.pascal)("".concat(name, "Contract")) + '.ts';
             QueryMsg = (0, _utils.findQueryMsg)(schemas);
             ExecuteMsg = (0, _utils.findExecuteMsg)(schemas);
-            _context.next = 5;
+            _context.next = 7;
             return (0, _utils.findAndParseTypes)(schemas);
 
-          case 5:
+          case 7:
             typeHash = _context.sent;
             Client = null;
             Instance = null;
@@ -66,8 +70,10 @@ var _default = /*#__PURE__*/function () {
               body.push((0, _clean.clean)(type));
             }); // alias the ExecuteMsg
 
-            ExecuteMsg && body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier("".concat(name, "ExecuteMsg")), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
-            context = new w.RenderContext((0, _utils.getDefinitionSchema)(schemas)); // query messages
+            if (options.aliasExecuteMsg && ExecuteMsg) {
+              body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier("".concat(name, "ExecuteMsg")), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+            } // query messages
+
 
             if (QueryMsg) {
               QueryClient = (0, _case.pascal)("".concat(name, "QueryClient"));
@@ -92,7 +98,7 @@ var _default = /*#__PURE__*/function () {
             (0, _mkdirp.sync)(outPath);
             (0, _fs.writeFileSync)((0, _path.join)(outPath, Contract), code);
 
-          case 21:
+          case 22:
           case "end":
             return _context.stop();
         }
@@ -100,7 +106,7 @@ var _default = /*#__PURE__*/function () {
     }, _callee);
   }));
 
-  return function (_x, _x2, _x3) {
+  return function (_x, _x2, _x3, _x4) {
     return _ref.apply(this, arguments);
   };
 }();

package/module/generators/ts-client.js

@@ -11,7 +11,11 @@ import { getMessageProperties } from "wasm-ast-types";
 import { findAndParseTypes, findExecuteMsg, findQueryMsg, getDefinitionSchema } from '../utils';
 import { cosmjsAminoImportStatements } from '../utils/imports';
 import { RenderContext } from "wasm-ast-types";
-export default (async (name, schemas, outPath) => {
+export default (async (name, schemas, outPath, tsClientOptions) => {
+  const context = new RenderContext(getDefinitionSchema(schemas), {
+    tsClient: tsClientOptions ?? {}
+  });
+  const options = context.options.reactQuery;
   const Contract = pascal(`${name}Contract`) + '.ts';
   const QueryMsg = findQueryMsg(schemas);
   const ExecuteMsg = findExecuteMsg(schemas);
@@ -28,8 +32,10 @@ export default (async (name, schemas, outPath) => {
     body.push(clean(type));
   }); // alias the ExecuteMsg
 
-  ExecuteMsg && body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
-  const context = new RenderContext(getDefinitionSchema(schemas)); // query messages
+  if (options.aliasExecuteMsg && ExecuteMsg) {
+    body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+  } // query messages
+
 
   if (QueryMsg) {
     QueryClient = pascal(`${name}QueryClient`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmwasm/ts-codegen",
-  "version": "0.7.1",
+  "version": "0.7.4",
   "description": "@cosmwasm/ts-codegen converts your CosmWasm smart contracts into dev-friendly TypeScript classes so you can focus on shipping code.",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "homepage": "https://github.com/cosmwasm/ts-codegen",
@@ -90,7 +90,7 @@
     "minimist": "1.2.6",
     "mkdirp": "1.0.4",
     "shelljs": "0.8.5",
-    "wasm-ast-types": "^0.6.0"
+    "wasm-ast-types": "^0.6.2"
   },
-  "gitHead": "103ec48e18ab5bd88329ec36b558e5caeb79f4b9"
+  "gitHead": "a737503b0e3a69a25cb8f6e9c1950c92de9b1c74"
 }

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

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

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

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

package/types/generators/recoil.d.ts

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

package/types/generators/ts-client.d.ts

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

package/types/index.d.ts

@@ -1,6 +1,6 @@
-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 { default as tsClient } from './generators/ts-client';
+export { default as fromPartial } from './generators/from-partial';
+export { default as reactQuery } from './generators/react-query';
+export { default as recoil } from './generators/recoil';
 export * from './utils';
-export * from './imports';
+export * from './utils/imports';

package/types/utils/clean.d.ts

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

package/types/utils/cleanse.d.ts

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

package/types/utils/header.d.ts

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

package/types/utils/imports.d.ts

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

package/types/utils/index.d.ts

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

package/types/utils/parse.d.ts

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

package/types/utils/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/utils/schemas.d.ts

@@ -0,0 +1,10 @@
+import { JSONSchema } from 'wasm-ast-types';
+export declare const readSchemas: ({ schemaDir, argv, clean }: {
+    schemaDir: any;
+    argv: any;
+    clean?: boolean;
+}) => Promise<any>;
+export declare const findQueryMsg: (schemas: any) => any;
+export declare const findExecuteMsg: (schemas: any) => any;
+export declare const findAndParseTypes: (schemas: any) => Promise<{}>;
+export declare const getDefinitionSchema: (schemas: JSONSchema[]) => JSONSchema;