wasm-ast-types 0.11.3 → 0.12.0

package/src/client/test/ts-client.issues.test.ts

@@ -0,0 +1,52 @@
+import { globContracts, makeContext } from '../../../test-utils'
+import {
+    createQueryClass,
+    createExecuteClass,
+    createExecuteInterface,
+    createTypeInterface
+} from '../client'
+import { expectCode } from '../../../test-utils';
+import cases from 'jest-in-case';
+
+const contracts = globContracts('issues/55');
+
+
+cases('execute_msg_for__empty', async opts => {
+    const ctx = makeContext(opts.content);
+    expectCode(createTypeInterface(
+        ctx,
+        opts.content
+    ));
+}, contracts);
+
+cases('query classes', async opts => {
+    const ctx = makeContext(opts.content);
+    expectCode(createQueryClass(
+        ctx,
+        'SG721QueryClient',
+        'SG721ReadOnlyInstance',
+        opts.content
+    ))
+}, contracts);
+
+cases('execute class', async opts => {
+    const ctx = makeContext(opts.content);
+    expectCode(createExecuteClass(
+        ctx,
+        'SG721Client',
+        'SG721Instance',
+        null,
+        opts.content
+    ))
+}, contracts);
+
+cases('execute interface', async opts => {
+    const ctx = makeContext(opts.content);
+    expectCode(createExecuteInterface(
+        ctx,
+        'SG721Instance',
+        null,
+        opts.content
+    ))
+}, contracts);
+

package/src/client/test/ts-client.sg721.spec.ts

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

package/src/client/test/ts-client.spec.ts

@@ -0,0 +1,166 @@
+import execute_msg_named_groups from '../../../../../__fixtures__/daodao/cw-named-groups/execute_msg.json';
+
+import query_msg from '../../../../../__fixtures__/basic/query_msg.json';
+import execute_msg from '../../../../../__fixtures__/basic/execute_msg_for__empty.json';
+import approval_response from '../../../../../__fixtures__/basic/approval_response.json';
+import all_nft_info_response from '../../../../../__fixtures__/basic/all_nft_info_response.json';
+import approvals_response from '../../../../../__fixtures__/basic/approvals_response.json';
+import collection_info_response from '../../../../../__fixtures__/basic/collection_info_response.json';
+import contract_info_response from '../../../../../__fixtures__/basic/contract_info_response.json';
+import instantiate_msg from '../../../../../__fixtures__/basic/instantiate_msg.json';
+import nft_info_response from '../../../../../__fixtures__/basic/nft_info_response.json';
+import num_tokens_response from '../../../../../__fixtures__/basic/num_tokens_response.json';
+import operators_response from '../../../../../__fixtures__/basic/operators_response.json';
+import owner_of_response from '../../../../../__fixtures__/basic/owner_of_response.json';
+import tokens_response from '../../../../../__fixtures__/basic/tokens_response.json';
+
+import {
+  createQueryClass,
+  createQueryInterface,
+  createExecuteClass,
+  createExecuteInterface,
+  createTypeInterface
+} from '../client';
+
+import { expectCode, makeContext } from '../../../test-utils';
+
+it('approval_response', () => {
+  const ctx = makeContext(approval_response);
+  expectCode(createTypeInterface(
+    ctx,
+    approval_response
+  ))
+});
+
+it('all_nft_info_response', () => {
+  const ctx = makeContext(all_nft_info_response);
+  expectCode(createTypeInterface(
+    ctx,
+    all_nft_info_response
+  ))
+})
+it('approvals_response', () => {
+  const ctx = makeContext(approvals_response);
+  expectCode(createTypeInterface(
+    ctx,
+    approvals_response
+  ))
+})
+it('collection_info_response', () => {
+  const ctx = makeContext(collection_info_response);
+  expectCode(createTypeInterface(
+    ctx,
+    collection_info_response
+  ))
+})
+it('contract_info_response', () => {
+  const ctx = makeContext(contract_info_response);
+  expectCode(createTypeInterface(
+    ctx,
+    contract_info_response
+  ))
+})
+it('instantiate_msg', () => {
+  const ctx = makeContext(instantiate_msg);
+  expectCode(createTypeInterface(
+    ctx,
+    instantiate_msg
+  ))
+})
+it('nft_info_response', () => {
+  const ctx = makeContext(nft_info_response);
+  expectCode(createTypeInterface(
+    ctx,
+    nft_info_response
+  ))
+})
+it('num_tokens_response', () => {
+  const ctx = makeContext(num_tokens_response);
+  expectCode(createTypeInterface(
+    ctx,
+    num_tokens_response
+  ))
+})
+it('operators_response', () => {
+  const ctx = makeContext(operators_response);
+  expectCode(createTypeInterface(
+    ctx,
+    operators_response
+  ))
+})
+it('owner_of_response', () => {
+  const ctx = makeContext(owner_of_response);
+  expectCode(createTypeInterface(
+    ctx,
+    owner_of_response
+  ))
+})
+it('tokens_response', () => {
+  const ctx = makeContext(tokens_response);
+  expectCode(createTypeInterface(
+    ctx,
+    tokens_response
+  ))
+})
+
+it('query classes', () => {
+  const ctx = makeContext(query_msg);
+  expectCode(createQueryClass(
+    ctx,
+    'SG721QueryClient',
+    'SG721ReadOnlyInstance',
+    query_msg
+  ))
+});
+
+it('execute classes', () => {
+  const ctx = makeContext(execute_msg);
+  expectCode(createExecuteClass(
+    ctx,
+    'SG721Client',
+    'SG721Instance',
+    'SG721QueryClient',
+    execute_msg
+  ))
+});
+
+it('execute classes no extends', () => {
+  const ctx = makeContext(execute_msg);
+  expectCode(createExecuteClass(
+    ctx,
+    'SG721Client',
+    'SG721Instance',
+    null,
+    execute_msg
+  ))
+});
+
+it('execute classes array types', () => {
+  const ctx = makeContext(execute_msg_named_groups);
+  expectCode(createExecuteClass(
+    ctx,
+    'SG721Client',
+    'SG721Instance',
+    null,
+    execute_msg_named_groups
+  ))
+});
+
+it('execute interfaces no extends', () => {
+  const ctx = makeContext(execute_msg);
+  expectCode(createExecuteInterface(
+    ctx,
+    'SG721Instance',
+    null,
+    execute_msg
+  ))
+});
+
+it('query interfaces', () => {
+  const ctx = makeContext(query_msg);
+  expectCode(createQueryInterface(
+    ctx,
+    'SG721ReadOnlyInstance',
+    query_msg
+  ))
+});

package/src/client/test/ts-client.vectis.spec.ts

@@ -0,0 +1,97 @@
+import cosmos_msg_for__empty from '../../../../../__fixtures__/vectis/govec/cosmos_msg_for__empty.json';
+import execute_msg_for__empty from '../../../../../__fixtures__/vectis/govec/execute_msg_for__empty.json';
+import can_execute_relay_response from '../../../../../__fixtures__/vectis/govec/can_execute_relay_response.json';
+import info_response from '../../../../../__fixtures__/vectis/govec/info_response.json';
+import relay_transaction from '../../../../../__fixtures__/vectis/govec/relay_transaction.json';
+
+import {
+    createQueryClass,
+    createExecuteClass,
+    createExecuteInterface,
+    createTypeInterface
+} from '../client';
+
+import { RenderContext } from '../../context';
+import { expectCode, makeContext } from '../../../test-utils';
+
+it('cosmos_msg_for__empty', () => {
+    const ctx = makeContext(cosmos_msg_for__empty);
+    expectCode(createTypeInterface(
+        ctx,
+        cosmos_msg_for__empty
+    ))
+});
+
+it('execute_msg_for__empty', () => {
+    const ctx = makeContext(execute_msg_for__empty);
+    expectCode(createTypeInterface(
+        ctx,
+        execute_msg_for__empty
+    ))
+})
+
+it('can_execute_relay_response', () => {
+    const ctx = makeContext(can_execute_relay_response);
+    expectCode(createTypeInterface(
+        ctx,
+        can_execute_relay_response
+    ))
+})
+
+it('info_response', () => {
+    const ctx = makeContext(info_response);
+    expectCode(createTypeInterface(
+        ctx,
+        info_response
+    ))
+})
+
+it('relay_transaction', () => {
+    const ctx = makeContext(relay_transaction);
+    expectCode(createTypeInterface(
+        ctx,
+        relay_transaction
+    ))
+})
+
+
+it('query classes', () => {
+    const ctx = makeContext(cosmos_msg_for__empty);
+    expectCode(createQueryClass(
+        ctx,
+        'SG721QueryClient',
+        'SG721ReadOnlyInstance',
+        cosmos_msg_for__empty
+    ))
+});
+
+it('query classes', () => {
+    const ctx = makeContext(execute_msg_for__empty);
+    expectCode(createQueryClass(
+        ctx,
+        'SG721QueryClient',
+        'SG721ReadOnlyInstance',
+        execute_msg_for__empty
+    ))
+});
+
+it('execute classes array types', () => {
+    const ctx = makeContext(execute_msg_for__empty);
+    expectCode(createExecuteClass(
+        ctx,
+        'SG721Client',
+        'SG721Instance',
+        null,
+        execute_msg_for__empty
+    ))
+});
+
+it('execute interfaces no extends', () => {
+    const ctx = makeContext(execute_msg_for__empty);
+    expectCode(createExecuteInterface(
+        ctx,
+        'SG721Instance',
+        null,
+        execute_msg_for__empty
+    ))
+});

package/src/context/context.ts

@@ -0,0 +1,132 @@
+import { JSONSchema } from "../types";
+import { convertUtilsToImportList, getImportStatements } from "./imports";
+import deepmerge from "deepmerge";
+
+/// Plugin Types
+export interface ReactQueryOptions {
+    enabled?: boolean;
+    optionalClient?: boolean;
+    version?: 'v3' | 'v4';
+    mutations?: boolean;
+    camelize?: boolean;
+    queryKeys?: boolean
+}
+
+export interface TSClientOptions {
+    enabled?: boolean;
+}
+export interface MessageComposerOptions {
+    enabled?: boolean;
+}
+export interface RecoilOptions {
+    enabled?: boolean;
+}
+export interface TSTypesOptions {
+    enabled?: boolean;
+    aliasExecuteMsg?: boolean;
+}
+
+/// END Plugin Types
+
+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;
+    messageComposer?: MessageComposerOptions;
+    client?: TSClientOptions;
+    reactQuery?: ReactQueryOptions;
+}
+
+export interface RenderContext {
+    contract: ContractInfo;
+    options: RenderOptions;
+}
+
+export const defaultOptions: RenderOptions = {
+    types: {
+        enabled: true,
+        aliasExecuteMsg: false
+    },
+    client: {
+        enabled: true
+    },
+    recoil: {
+        enabled: false
+    },
+    messageComposer: {
+        enabled: false
+    },
+    reactQuery: {
+        enabled: false,
+        optionalClient: false,
+        version: 'v3',
+        mutations: false,
+        camelize: true,
+        queryKeys: false
+    }
+};
+
+export const getDefinitionSchema = (schemas: JSONSchema[]): JSONSchema => {
+    const aggregateSchema = {
+        definitions: {
+            //
+        }
+    };
+
+    schemas.forEach(schema => {
+        schema.definitions = schema.definitions || {};
+        aggregateSchema.definitions = {
+            ...aggregateSchema.definitions,
+            ...schema.definitions
+        };
+    });
+
+    return aggregateSchema;
+};
+export class RenderContext implements RenderContext {
+    contract: ContractInfo;
+    utils: string[] = [];
+    schema: JSONSchema;
+    constructor(
+        contract: ContractInfo,
+        options?: RenderOptions
+    ) {
+        this.contract = contract;
+        this.schema = getDefinitionSchema(contract.schemas);
+        this.options = deepmerge(defaultOptions, options ?? {});
+    }
+    refLookup($ref: string) {
+        const refName = $ref.replace('#/definitions/', '')
+        return this.schema.definitions?.[refName];
+    }
+    addUtil(util: string) {
+        this.utils[util] = true;
+    }
+    getImports() {
+        return getImportStatements(
+            convertUtilsToImportList(
+                this,
+                Object.keys(this.utils)
+            )
+        );
+    }
+}

package/src/context/imports.ts

@@ -0,0 +1,126 @@
+import * as t from '@babel/types';
+import { importAs, importStmt } from "../utils";
+import { RenderContext } from './context';
+
+export interface ImportObj {
+  type: 'import' | 'default' | 'namespace';
+  name: string;
+  path: string;
+  importAs?: string;
+}
+
+const makeReactQuerySwitch = (varName) => {
+  return (context: RenderContext) => {
+    switch (context.options.reactQuery.version) {
+      case 'v4':
+        return {
+          type: 'import',
+          path: '@tanstack/react-query',
+          name: varName
+        }
+      case 'v3':
+      default:
+        return {
+          type: 'import',
+          path: 'react-query',
+          name: varName
+        }
+    }
+  };
+}
+
+export const UTILS = {
+  MsgExecuteContract: 'cosmjs-types/cosmwasm/wasm/v1/tx',
+  MsgExecuteContractEncodeObject: 'cosmwasm',
+  Coin: '@cosmjs/amino',
+  toUtf8: '@cosmjs/encoding',
+  selectorFamily: 'recoil',
+  StdFee: '@cosmjs/amino',
+  CosmWasmClient: '@cosmjs/cosmwasm-stargate',
+  ExecuteResult: '@cosmjs/cosmwasm-stargate',
+  SigningCosmWasmClient: '@cosmjs/cosmwasm-stargate',
+
+  // react-query
+  useQuery: makeReactQuerySwitch('useQuery'),
+  UseQueryOptions: makeReactQuerySwitch('UseQueryOptions'),
+  useMutation: makeReactQuerySwitch('useMutation'),
+  UseMutationOptions: makeReactQuerySwitch('UseMutationOptions')
+
+};
+
+export const convertUtilsToImportList = (
+  context: RenderContext,
+  utils: string[]
+): ImportObj[] => {
+  return utils.map(util => {
+    if (!UTILS.hasOwnProperty(util)) throw new Error(`missing Util! ::[${util}]`);
+    if (typeof UTILS[util] === 'string') {
+      return {
+        type: 'import',
+        path: UTILS[util],
+        name: util
+      };
+    } else if (typeof UTILS[util] === 'function') {
+      return UTILS[util](context);
+    } else {
+      UTILS[util];
+    }
+  });
+}
+
+export const getImportStatements = (list: ImportObj[]) => {
+  const imports = list.reduce((m, obj) => {
+    m[obj.path] = m[obj.path] || [];
+    const exists = m[obj.path].find(el => el.type === obj.type && el.path === obj.path && el.name === obj.name);
+
+    // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
+    if (/\./.test(obj.name)) {
+      obj.name = obj.name.split('.')[obj.name.split('.').length - 1];
+    }
+
+    if (!exists) m[obj.path].push(obj);
+    return m;
+  }, {})
+
+  return Object.entries(imports)
+    .reduce((m, [importPath, imports]: [string, ImportObj[]]) => {
+      const defaultImports = imports.filter(a => a.type === 'default');
+      if (defaultImports.length) {
+        if (defaultImports.length > 1) throw new Error('more than one default name NOT allowed.')
+        m.push(
+          t.importDeclaration(
+            [
+              t.importDefaultSpecifier(
+                t.identifier(defaultImports[0].name)
+              )
+            ],
+            t.stringLiteral(defaultImports[0].path)
+          )
+        )
+      }
+      const namedImports = imports.filter(a => a.type === 'import' && (!a.importAs || (a.name === a.importAs)));
+      if (namedImports.length) {
+        m.push(importStmt(namedImports.map(i => i.name), namedImports[0].path));
+      }
+      const aliasNamedImports = imports.filter(a => a.type === 'import' && (a.importAs && (a.name !== a.importAs)));
+      aliasNamedImports.forEach(imp => {
+        m.push(importAs(imp.name, imp.importAs, imp.path));
+      });
+
+      const namespaced = imports.filter(a => a.type === 'namespace');
+      if (namespaced.length) {
+        if (namespaced.length > 1) throw new Error('more than one namespaced name NOT allowed.')
+        m.push(
+          t.importDeclaration(
+            [
+              t.importNamespaceSpecifier(
+                t.identifier(namespaced[0].name)
+              )
+            ],
+            t.stringLiteral(namespaced[0].path)
+          )
+        )
+      }
+      return m;
+    }, [])
+};

package/src/context/index.ts

@@ -0,0 +1,2 @@
+export * from './context';
+export * from './imports';

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './utils';
+export * from './client';
+export * from './context';
+export * from './recoil';
+export * from './message-composer';
+export * from './react-query';
+export * from './types';