wasm-ast-types 0.11.3 → 0.13.0

package/src/recoil/__snapshots__/recoil.spec.ts.snap

@@ -0,0 +1,203 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`client 1`] = `
+"export const queryClient = selectorFamily<SG721QueryClient, QueryClientParams>({
+  key: \\"sG721QueryClient\\",
+  get: ({
+    contractAddress
+  }) => ({
+    get
+  }) => {
+    const client = get(cosmWasmClient);
+    return new SG721QueryClient(client, contractAddress);
+  }
+});"
+`;
+
+exports[`selector 1`] = `
+"export const governanceModulesSelector = selectorFamily<GovernanceModulesResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"governanceModules\\"]>;
+}>({
+  key: \\"sG721GovernanceModules\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.governanceModules(...params);
+  }
+});"
+`;
+
+exports[`selectors 1`] = `
+"export const ownerOfSelector = selectorFamily<OwnerOfResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"ownerOf\\"]>;
+}>({
+  key: \\"sG721OwnerOf\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.ownerOf(...params);
+  }
+});
+export const approvalSelector = selectorFamily<ApprovalResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"approval\\"]>;
+}>({
+  key: \\"sG721Approval\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.approval(...params);
+  }
+});
+export const approvalsSelector = selectorFamily<ApprovalsResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"approvals\\"]>;
+}>({
+  key: \\"sG721Approvals\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.approvals(...params);
+  }
+});
+export const allOperatorsSelector = selectorFamily<AllOperatorsResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"allOperators\\"]>;
+}>({
+  key: \\"sG721AllOperators\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.allOperators(...params);
+  }
+});
+export const numTokensSelector = selectorFamily<NumTokensResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"numTokens\\"]>;
+}>({
+  key: \\"sG721NumTokens\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.numTokens(...params);
+  }
+});
+export const contractInfoSelector = selectorFamily<ContractInfoResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"contractInfo\\"]>;
+}>({
+  key: \\"sG721ContractInfo\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.contractInfo(...params);
+  }
+});
+export const nftInfoSelector = selectorFamily<NftInfoResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"nftInfo\\"]>;
+}>({
+  key: \\"sG721NftInfo\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.nftInfo(...params);
+  }
+});
+export const allNftInfoSelector = selectorFamily<AllNftInfoResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"allNftInfo\\"]>;
+}>({
+  key: \\"sG721AllNftInfo\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.allNftInfo(...params);
+  }
+});
+export const tokensSelector = selectorFamily<TokensResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"tokens\\"]>;
+}>({
+  key: \\"sG721Tokens\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.tokens(...params);
+  }
+});
+export const allTokensSelector = selectorFamily<AllTokensResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"allTokens\\"]>;
+}>({
+  key: \\"sG721AllTokens\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.allTokens(...params);
+  }
+});
+export const minterSelector = selectorFamily<MinterResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"minter\\"]>;
+}>({
+  key: \\"sG721Minter\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.minter(...params);
+  }
+});
+export const collectionInfoSelector = selectorFamily<CollectionInfoResponse, QueryClientParams & {
+  params: Parameters<SG721QueryClient[\\"collectionInfo\\"]>;
+}>({
+  key: \\"sG721CollectionInfo\\",
+  get: ({
+    params,
+    ...queryClientParams
+  }) => async ({
+    get
+  }) => {
+    const client = get(queryClient(queryClientParams));
+    return await client.collectionInfo(...params);
+  }
+});"
+`;

package/src/recoil/index.ts

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

package/src/recoil/recoil.spec.ts

@@ -0,0 +1,38 @@
+import * as t from '@babel/types';
+import query_msg from '../../../../__fixtures__/basic/query_msg.json';
+import {
+    createRecoilSelector,
+    createRecoilSelectors,
+    createRecoilQueryClient,
+} from './recoil';
+import { RenderContext } from '../context';
+import { expectCode, makeContext } from '../../test-utils';
+
+const ctx = makeContext(query_msg);
+
+it('selector', () => {
+    expectCode(createRecoilSelector(
+        ctx,
+        'SG721',
+        'SG721QueryClient',
+        'governanceModules',
+        'GovernanceModulesResponse'
+    ))
+});
+
+it('selectors', () => {
+    expectCode(t.program(createRecoilSelectors(
+        ctx,
+        'SG721',
+        'SG721QueryClient',
+        query_msg
+    )))
+});
+
+it('client', () => {
+    expectCode(createRecoilQueryClient(
+        ctx,
+        'SG721',
+        'SG721QueryClient'
+    ))
+});

package/src/recoil/recoil.ts

@@ -0,0 +1,307 @@
+import * as t from '@babel/types';
+import { camel, pascal } from 'case';
+import {
+  callExpression,
+  getMessageProperties,
+  getResponseType
+} from '../utils';
+import { QueryMsg } from '../types';
+import { RenderContext } from '../context';
+
+export const createRecoilSelector = (
+  context: RenderContext,
+  keyPrefix: string,
+  QueryClient: string,
+  methodName: string,
+  responseType: string
+) => {
+
+  context.addUtil('selectorFamily');
+
+  const selectorName = camel(`${methodName}Selector`);
+  const getterKey = camel(`${keyPrefix}${pascal(methodName)}`);
+
+  return t.exportNamedDeclaration(
+    t.variableDeclaration(
+      'const',
+      [t.variableDeclarator(
+        t.identifier(selectorName),
+        callExpression(
+          t.identifier('selectorFamily'),
+          [
+            t.objectExpression(
+              [
+                t.objectProperty(
+                  t.identifier('key'),
+                  t.stringLiteral(getterKey)
+                ),
+                t.objectProperty(
+                  t.identifier('get'),
+                  t.arrowFunctionExpression(
+                    [
+                      t.objectPattern(
+                        [
+                          t.objectProperty(
+                            t.identifier('params'),
+                            t.identifier('params'),
+                            false,
+                            true
+                          ),
+                          t.restElement(
+                            t.identifier('queryClientParams')
+                          )
+                        ]
+                      )
+                    ],
+                    t.arrowFunctionExpression(
+                      [
+                        t.objectPattern(
+                          [
+                            t.objectProperty(
+                              t.identifier('get'),
+                              t.identifier('get'),
+                              false,
+                              true
+                            )
+                          ]
+                        )
+                      ],
+                      t.blockStatement(
+                        [
+                          t.variableDeclaration('const',
+                            [
+                              t.variableDeclarator(
+                                t.identifier('client'),
+                                t.callExpression(
+                                  t.identifier('get'),
+                                  [
+                                    t.callExpression(
+                                      t.identifier('queryClient'),
+                                      [
+                                        t.identifier('queryClientParams')
+                                      ]
+                                    )
+                                  ]
+                                )
+                              )
+                            ]),
+                          t.returnStatement(
+                            t.awaitExpression(
+                              t.callExpression(
+                                t.memberExpression(
+                                  t.identifier('client'),
+                                  t.identifier(methodName)
+                                ),
+                                [
+                                  t.spreadElement(
+                                    t.identifier('params')
+                                  )
+                                ]
+                              )
+                            )
+                          )
+                        ]
+                      ),
+                      true
+                    )
+                  )
+                )
+              ]
+            )
+          ],
+          t.tsTypeParameterInstantiation(
+            [
+              t.tsTypeReference(
+                t.identifier(responseType)
+              ),
+              t.tsIntersectionType(
+                [
+                  t.tsTypeReference(
+                    t.identifier('QueryClientParams')
+                  ),
+                  t.tsTypeLiteral(
+                    [
+                      t.tsPropertySignature(
+                        t.identifier('params'),
+                        t.tsTypeAnnotation(
+                          t.tsTypeReference(
+                            t.identifier('Parameters'),
+                            t.tsTypeParameterInstantiation(
+                              [
+                                t.tsIndexedAccessType(
+                                  t.tsTypeReference(
+                                    t.identifier(QueryClient)
+                                  ),
+                                  t.tsLiteralType(
+                                    t.stringLiteral(methodName)
+                                  )
+                                )
+                              ]
+                            )
+                          )
+                        )
+                      )
+                    ]
+                  )
+                ]
+              )
+            ]
+          )
+        )
+      )]
+    )
+  )
+
+};
+
+export const createRecoilSelectors = (
+  context: RenderContext,
+  keyPrefix: string,
+  QueryClient: string,
+  queryMsg: QueryMsg
+) => {
+  return getMessageProperties(queryMsg)
+    .map(schema => {
+
+      const underscoreName = Object.keys(schema.properties)[0];
+      const methodName = camel(underscoreName);
+      const responseType = getResponseType(context, underscoreName);
+
+      return createRecoilSelector(
+        context,
+        keyPrefix,
+        QueryClient,
+        methodName,
+        responseType
+      );
+
+    });
+};
+
+export const createRecoilQueryClientType = () => ({
+  "type": "TSTypeAliasDeclaration",
+  "id": {
+    "type": "Identifier",
+    "name": "QueryClientParams"
+  },
+  "typeAnnotation": {
+    "type": "TSTypeLiteral",
+    "members": [
+      {
+        "type": "TSPropertySignature",
+        "key": {
+          "type": "Identifier",
+          "name": "contractAddress"
+        },
+        "computed": false,
+        "typeAnnotation": {
+          "type": "TSTypeAnnotation",
+          "typeAnnotation": {
+            "type": "TSStringKeyword"
+          }
+        }
+      }
+    ]
+  }
+});
+
+export const createRecoilQueryClient = (
+  context: RenderContext,
+  keyPrefix: string,
+  QueryClient: string
+) => {
+
+  context.addUtil('selectorFamily');
+
+  const getterKey = camel(`${keyPrefix}${'QueryClient'}`);
+
+  return t.exportNamedDeclaration(
+    t.variableDeclaration(
+      'const',
+      [t.variableDeclarator(
+        t.identifier('queryClient'),
+        callExpression(
+          t.identifier('selectorFamily'),
+          [
+            t.objectExpression(
+              [
+                t.objectProperty(
+                  t.identifier('key'),
+                  t.stringLiteral(getterKey)
+                ),
+                t.objectProperty(
+                  t.identifier('get'),
+                  t.arrowFunctionExpression(
+                    [
+                      t.objectPattern(
+                        [
+                          t.objectProperty(
+                            t.identifier('contractAddress'),
+                            t.identifier('contractAddress'),
+                            false,
+                            true
+                          )
+                        ]
+                      )
+                    ],
+                    t.arrowFunctionExpression(
+                      [
+                        t.objectPattern(
+                          [
+                            t.objectProperty(
+                              t.identifier('get'),
+                              t.identifier('get'),
+                              false,
+                              true
+                            )
+                          ]
+                        )
+                      ],
+                      t.blockStatement(
+                        [
+                          t.variableDeclaration('const',
+                            [
+                              t.variableDeclarator(
+                                t.identifier('client'),
+                                t.callExpression(
+                                  t.identifier('get'),
+                                  [
+                                    t.identifier('cosmWasmClient')
+                                  ]
+                                )
+                              )
+                            ]),
+                          t.returnStatement(
+                            t.newExpression(
+                              t.identifier(QueryClient),
+                              [
+                                t.identifier('client'),
+                                t.identifier('contractAddress')
+                              ]
+                            )
+                          )
+                        ]
+                      ),
+                      false
+                    )
+                  )
+                )
+              ]
+            )
+          ],
+          t.tsTypeParameterInstantiation(
+            [
+              t.tsTypeReference(
+                t.identifier(QueryClient)
+              ),
+              t.tsTypeReference(
+                t.identifier('QueryClientParams')
+              )
+            ]
+          )
+        )
+      )]
+    )
+  )
+
+};

package/src/types.ts

@@ -0,0 +1,44 @@
+export declare type fieldType = 'Long' | 'Coin' | 'Duration' | 'Height' | string;
+export interface Field {
+    name: string;
+    type: fieldType;
+    node: any;
+};
+export interface Interface {
+    name: string;
+    fields: Field[]
+};
+
+export interface QueryMsg {
+    $schema: string;
+    title: "QueryMsg";
+    oneOf?: any;
+    allOf?: any;
+    anyOf?: any;
+}
+
+export interface ExecuteMsg {
+    $schema: string;
+    title: "ExecuteMsg" | "ExecuteMsg_for_Empty";
+    oneOf?: any;
+    allOf?: any;
+    anyOf?: any;
+}
+
+export interface JSONSchema {
+    $ref?: string;
+    $schema?: string;
+    additionalProperties?: boolean;
+    allOf?: JSONSchema[];
+    anyOf?: JSONSchema[];
+    definitions?: Record<string, JSONSchema>;
+    description?: string;
+    oneOf?: JSONSchema[];
+    properties?: Record<string, JSONSchema>;
+    patternProperties?: Record<string, JSONSchema>;
+    items?: JSONSchema | JSONSchema[];
+    additionalItems?: JSONSchema;
+    required?: string[];
+    title?: string;
+    type?: string;
+}

package/src/utils/__snapshots__/babel.spec.ts.snap

@@ -0,0 +1,75 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`interfaces 1`] = `
+"export interface SG721ReadOnlyInstance {
+  contractAddress: string;
+  tokens: (owner: string, startAfter?: string, limit?: string) => Promise<TokensResponse>;
+}
+export interface SG721Instance extends SG721ReadOnlyInstance {
+  contractAddress: string;
+  mint: (sender: string, anotherProp: string, prop3: string) => Promise<ExecuteResult>;
+}"
+`;
+
+exports[`mutation classes 1`] = `
+"export class SG721Client extends SG721QueryClient implements SG721ReadOnlyInstance {
+  client: SigningCosmWasmClient;
+  contractAddress: string;
+
+  constructor(client: SigningCosmWasmClient, contractAddress: string) {
+    super(client, contractAddress);
+    this.client = client;
+    this.contractAddress = contractAddress;
+    this.approval = this.approval.bind(this);
+    this.otherProp = this.otherProp.bind(this);
+    this.hello = this.hello.bind(this);
+    this.mintme = this.mintme.bind(this);
+  }
+
+  mint = async (sender: string, tokenId: string, owner: string, token_uri: string): Promise<ExecuteResult> => {
+    return await this.client.execute(sender, this.contractAddress, {
+      mint: {
+        token_id: tokenId,
+        owner: owner,
+        token_uri: token_uri,
+        expression: {}
+      }
+    }, \\"auto\\");
+  };
+}"
+`;
+
+exports[`object parms 1`] = `
+"ownerOf = ({
+  includeExpired,
+  tokenId
+}: {
+  includeExpired: boolean;
+  tokenId: string;
+}): Promise<OwnerOfResponse> => {};"
+`;
+
+exports[`readonly classes 1`] = `
+"export class SG721QueryClient implements SG721ReadOnlyInstance {
+  client: CosmWasmClient;
+  contractAddress: string;
+
+  constructor(client: CosmWasmClient, contractAddress: string) {
+    this.client = client;
+    this.contractAddress = contractAddress;
+    this.approval = this.approval.bind(this);
+    this.otherProp = this.otherProp.bind(this);
+    this.hello = this.hello.bind(this);
+    this.mintme = this.mintme.bind(this);
+  }
+
+  approval = async (owner: string, spender: string): Promise<ApprovalResponse> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      owner,
+      spender
+    });
+  };
+}"
+`;
+
+exports[`top import 1`] = `"import { CosmWasmClient, ExecuteResult, SigningCosmWasmClient } from \\"@cosmjs/cosmwasm-stargate\\";"`;