wasm-ast-types 0.13.0 → 0.15.0

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

@@ -0,0 +1,74 @@
+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);
+
+describe('exec', () => {
+
+})
+
+it('Impl, execExtends, noExtendsClass', () => {
+    ctx.options.client.noImplicitOverride = false;
+    ctx.options.client.execExtendsQuery = true;
+    expectCode(createExecuteClass(
+        ctx,
+        'SG721Client',
+        'SG721Instance',
+        null,
+        execute_msg_for__empty
+    ))
+});
+
+it('Impl, execExtends, ExtendsClass', () => {
+    ctx.options.client.noImplicitOverride = false;
+    ctx.options.client.execExtendsQuery = true;
+    expectCode(createExecuteClass(
+        ctx,
+        'SG721Client',
+        'SG721Instance',
+        'ExtendsClassName',
+        execute_msg_for__empty
+    ))
+});
+
+it('noImpl, execExtends, ExtendsClass', () => {
+    ctx.options.client.noImplicitOverride = true;
+    ctx.options.client.execExtendsQuery = true;
+    expectCode(createExecuteClass(
+        ctx,
+        'SG721Client',
+        'SG721Instance',
+        'ExtendsClassName',
+        execute_msg_for__empty
+    ))
+});
+
+it('noImpl, noExecExtends, ExtendsClass', () => {
+    ctx.options.client.noImplicitOverride = true;
+    ctx.options.client.execExtendsQuery = false;
+    expectCode(createExecuteClass(
+        ctx,
+        'SG721Client',
+        'SG721Instance',
+        'ExtendsClassName',
+        execute_msg_for__empty
+    ))
+});
+
+it('noImpl, noExecExtends, noExtendsClass', () => {
+    ctx.options.client.noImplicitOverride = true;
+    ctx.options.client.execExtendsQuery = false;
+    expectCode(createExecuteClass(
+        ctx,
+        'SG721Client',
+        'SG721Instance',
+        null,
+        execute_msg_for__empty
+    ))
+});

package/src/context/context.ts

@@ -10,11 +10,13 @@ export interface ReactQueryOptions {
     mutations?: boolean;
     camelize?: boolean;
     queryKeys?: boolean
+    queryFactory?: boolean
 }
 
 export interface TSClientOptions {
     enabled?: boolean;
     execExtendsQuery?: boolean;
+    noImplicitOverride?: boolean;
 }
 export interface MessageComposerOptions {
     enabled?: boolean;
@@ -69,7 +71,8 @@ export const defaultOptions: RenderOptions = {
     },
     client: {
         enabled: true,
-        execExtendsQuery: true
+        execExtendsQuery: true,
+        noImplicitOverride: false,
     },
     recoil: {
         enabled: false

package/src/react-query/__snapshots__/react-query.spec.ts.snap

@@ -729,6 +729,402 @@ export function useSg721OwnerOfQuery<TData = OwnerOfResponse>({
 `;
 
 exports[`createReactQueryHooks 5`] = `
+"export const sg721QueryKeys = {
+  contract: ([{
+    contract: \\"sg721\\"
+  }] as const),
+  address: (contractAddress: string | undefined) => ([{ ...sg721QueryKeys.contract[0],
+    address: contractAddress
+  }] as const),
+  ownerOf: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"owner_of\\",
+    args
+  }] as const),
+  approval: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"approval\\",
+    args
+  }] as const),
+  approvals: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"approvals\\",
+    args
+  }] as const),
+  allOperators: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"all_operators\\",
+    args
+  }] as const),
+  numTokens: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"num_tokens\\",
+    args
+  }] as const),
+  contractInfo: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"contract_info\\",
+    args
+  }] as const),
+  nftInfo: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"nft_info\\",
+    args
+  }] as const),
+  allNftInfo: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"all_nft_info\\",
+    args
+  }] as const),
+  tokens: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"tokens\\",
+    args
+  }] as const),
+  allTokens: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"all_tokens\\",
+    args
+  }] as const),
+  minter: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"minter\\",
+    args
+  }] as const),
+  collectionInfo: (contractAddress: string | undefined, args?: Record<string, unknown>) => ([{ ...sg721QueryKeys.address(contractAddress)[0],
+    method: \\"collection_info\\",
+    args
+  }] as const)
+};
+export const sg721Queries = {
+  ownerOf: <TData = OwnerOfResponse,>({
+    client,
+    args,
+    options
+  }: Sg721OwnerOfQuery<TData>): UseQueryOptions<OwnerOfResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.ownerOf(client?.contractAddress, args),
+    queryFn: () => client ? client.ownerOf({
+      includeExpired: args.includeExpired,
+      tokenId: args.tokenId
+    }) : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  approval: <TData = ApprovalResponse,>({
+    client,
+    args,
+    options
+  }: Sg721ApprovalQuery<TData>): UseQueryOptions<ApprovalResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.approval(client?.contractAddress, args),
+    queryFn: () => client ? client.approval({
+      includeExpired: args.includeExpired,
+      spender: args.spender,
+      tokenId: args.tokenId
+    }) : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  approvals: <TData = ApprovalsResponse,>({
+    client,
+    args,
+    options
+  }: Sg721ApprovalsQuery<TData>): UseQueryOptions<ApprovalsResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.approvals(client?.contractAddress, args),
+    queryFn: () => client ? client.approvals({
+      includeExpired: args.includeExpired,
+      tokenId: args.tokenId
+    }) : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  allOperators: <TData = AllOperatorsResponse,>({
+    client,
+    args,
+    options
+  }: Sg721AllOperatorsQuery<TData>): UseQueryOptions<AllOperatorsResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.allOperators(client?.contractAddress, args),
+    queryFn: () => client ? client.allOperators({
+      includeExpired: args.includeExpired,
+      limit: args.limit,
+      owner: args.owner,
+      startAfter: args.startAfter
+    }) : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  numTokens: <TData = NumTokensResponse,>({
+    client,
+    options
+  }: Sg721NumTokensQuery<TData>): UseQueryOptions<NumTokensResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.numTokens(client?.contractAddress),
+    queryFn: () => client ? client.numTokens() : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  contractInfo: <TData = ContractInfoResponse,>({
+    client,
+    options
+  }: Sg721ContractInfoQuery<TData>): UseQueryOptions<ContractInfoResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.contractInfo(client?.contractAddress),
+    queryFn: () => client ? client.contractInfo() : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  nftInfo: <TData = NftInfoResponse,>({
+    client,
+    args,
+    options
+  }: Sg721NftInfoQuery<TData>): UseQueryOptions<NftInfoResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.nftInfo(client?.contractAddress, args),
+    queryFn: () => client ? client.nftInfo({
+      tokenId: args.tokenId
+    }) : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  allNftInfo: <TData = AllNftInfoResponse,>({
+    client,
+    args,
+    options
+  }: Sg721AllNftInfoQuery<TData>): UseQueryOptions<AllNftInfoResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.allNftInfo(client?.contractAddress, args),
+    queryFn: () => client ? client.allNftInfo({
+      includeExpired: args.includeExpired,
+      tokenId: args.tokenId
+    }) : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  tokens: <TData = TokensResponse,>({
+    client,
+    args,
+    options
+  }: Sg721TokensQuery<TData>): UseQueryOptions<TokensResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.tokens(client?.contractAddress, args),
+    queryFn: () => client ? client.tokens({
+      limit: args.limit,
+      owner: args.owner,
+      startAfter: args.startAfter
+    }) : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  allTokens: <TData = AllTokensResponse,>({
+    client,
+    args,
+    options
+  }: Sg721AllTokensQuery<TData>): UseQueryOptions<AllTokensResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.allTokens(client?.contractAddress, args),
+    queryFn: () => client ? client.allTokens({
+      limit: args.limit,
+      startAfter: args.startAfter
+    }) : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  minter: <TData = MinterResponse,>({
+    client,
+    options
+  }: Sg721MinterQuery<TData>): UseQueryOptions<MinterResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.minter(client?.contractAddress),
+    queryFn: () => client ? client.minter() : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  }),
+  collectionInfo: <TData = CollectionInfoResponse,>({
+    client,
+    options
+  }: Sg721CollectionInfoQuery<TData>): UseQueryOptions<CollectionInfoResponse, Error, TData> => ({
+    queryKey: sg721QueryKeys.collectionInfo(client?.contractAddress),
+    queryFn: () => client ? client.collectionInfo() : Promise.reject(new Error(\\"Invalid client\\")),
+    ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  })
+};
+export interface Sg721ReactQuery<TResponse, TData = TResponse> {
+  client: Sg721QueryClient | undefined;
+  options?: Omit<UseQueryOptions<TResponse, Error, TData>, \\"'queryKey' | 'queryFn' | 'initialData'\\"> & {
+    initialData?: undefined;
+  };
+}
+export interface Sg721CollectionInfoQuery<TData> extends Sg721ReactQuery<CollectionInfoResponse, TData> {}
+export function useSg721CollectionInfoQuery<TData = CollectionInfoResponse>({
+  client,
+  options
+}: Sg721CollectionInfoQuery<TData>) {
+  return useQuery<CollectionInfoResponse, Error, TData>(sg721QueryKeys.collectionInfo(client?.contractAddress), () => client ? client.collectionInfo() : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721MinterQuery<TData> extends Sg721ReactQuery<MinterResponse, TData> {}
+export function useSg721MinterQuery<TData = MinterResponse>({
+  client,
+  options
+}: Sg721MinterQuery<TData>) {
+  return useQuery<MinterResponse, Error, TData>(sg721QueryKeys.minter(client?.contractAddress), () => client ? client.minter() : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721AllTokensQuery<TData> extends Sg721ReactQuery<AllTokensResponse, TData> {
+  args: {
+    limit?: number;
+    startAfter?: string;
+  };
+}
+export function useSg721AllTokensQuery<TData = AllTokensResponse>({
+  client,
+  args,
+  options
+}: Sg721AllTokensQuery<TData>) {
+  return useQuery<AllTokensResponse, Error, TData>(sg721QueryKeys.allTokens(client?.contractAddress, args), () => client ? client.allTokens({
+    limit: args.limit,
+    startAfter: args.startAfter
+  }) : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721TokensQuery<TData> extends Sg721ReactQuery<TokensResponse, TData> {
+  args: {
+    limit?: number;
+    owner: string;
+    startAfter?: string;
+  };
+}
+export function useSg721TokensQuery<TData = TokensResponse>({
+  client,
+  args,
+  options
+}: Sg721TokensQuery<TData>) {
+  return useQuery<TokensResponse, Error, TData>(sg721QueryKeys.tokens(client?.contractAddress, args), () => client ? client.tokens({
+    limit: args.limit,
+    owner: args.owner,
+    startAfter: args.startAfter
+  }) : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721AllNftInfoQuery<TData> extends Sg721ReactQuery<AllNftInfoResponse, TData> {
+  args: {
+    includeExpired?: boolean;
+    tokenId: string;
+  };
+}
+export function useSg721AllNftInfoQuery<TData = AllNftInfoResponse>({
+  client,
+  args,
+  options
+}: Sg721AllNftInfoQuery<TData>) {
+  return useQuery<AllNftInfoResponse, Error, TData>(sg721QueryKeys.allNftInfo(client?.contractAddress, args), () => client ? client.allNftInfo({
+    includeExpired: args.includeExpired,
+    tokenId: args.tokenId
+  }) : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721NftInfoQuery<TData> extends Sg721ReactQuery<NftInfoResponse, TData> {
+  args: {
+    tokenId: string;
+  };
+}
+export function useSg721NftInfoQuery<TData = NftInfoResponse>({
+  client,
+  args,
+  options
+}: Sg721NftInfoQuery<TData>) {
+  return useQuery<NftInfoResponse, Error, TData>(sg721QueryKeys.nftInfo(client?.contractAddress, args), () => client ? client.nftInfo({
+    tokenId: args.tokenId
+  }) : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721ContractInfoQuery<TData> extends Sg721ReactQuery<ContractInfoResponse, TData> {}
+export function useSg721ContractInfoQuery<TData = ContractInfoResponse>({
+  client,
+  options
+}: Sg721ContractInfoQuery<TData>) {
+  return useQuery<ContractInfoResponse, Error, TData>(sg721QueryKeys.contractInfo(client?.contractAddress), () => client ? client.contractInfo() : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721NumTokensQuery<TData> extends Sg721ReactQuery<NumTokensResponse, TData> {}
+export function useSg721NumTokensQuery<TData = NumTokensResponse>({
+  client,
+  options
+}: Sg721NumTokensQuery<TData>) {
+  return useQuery<NumTokensResponse, Error, TData>(sg721QueryKeys.numTokens(client?.contractAddress), () => client ? client.numTokens() : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721AllOperatorsQuery<TData> extends Sg721ReactQuery<AllOperatorsResponse, TData> {
+  args: {
+    includeExpired?: boolean;
+    limit?: number;
+    owner: string;
+    startAfter?: string;
+  };
+}
+export function useSg721AllOperatorsQuery<TData = AllOperatorsResponse>({
+  client,
+  args,
+  options
+}: Sg721AllOperatorsQuery<TData>) {
+  return useQuery<AllOperatorsResponse, Error, TData>(sg721QueryKeys.allOperators(client?.contractAddress, args), () => client ? client.allOperators({
+    includeExpired: args.includeExpired,
+    limit: args.limit,
+    owner: args.owner,
+    startAfter: args.startAfter
+  }) : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721ApprovalsQuery<TData> extends Sg721ReactQuery<ApprovalsResponse, TData> {
+  args: {
+    includeExpired?: boolean;
+    tokenId: string;
+  };
+}
+export function useSg721ApprovalsQuery<TData = ApprovalsResponse>({
+  client,
+  args,
+  options
+}: Sg721ApprovalsQuery<TData>) {
+  return useQuery<ApprovalsResponse, Error, TData>(sg721QueryKeys.approvals(client?.contractAddress, args), () => client ? client.approvals({
+    includeExpired: args.includeExpired,
+    tokenId: args.tokenId
+  }) : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721ApprovalQuery<TData> extends Sg721ReactQuery<ApprovalResponse, TData> {
+  args: {
+    includeExpired?: boolean;
+    spender: string;
+    tokenId: string;
+  };
+}
+export function useSg721ApprovalQuery<TData = ApprovalResponse>({
+  client,
+  args,
+  options
+}: Sg721ApprovalQuery<TData>) {
+  return useQuery<ApprovalResponse, Error, TData>(sg721QueryKeys.approval(client?.contractAddress, args), () => client ? client.approval({
+    includeExpired: args.includeExpired,
+    spender: args.spender,
+    tokenId: args.tokenId
+  }) : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}
+export interface Sg721OwnerOfQuery<TData> extends Sg721ReactQuery<OwnerOfResponse, TData> {
+  args: {
+    includeExpired?: boolean;
+    tokenId: string;
+  };
+}
+export function useSg721OwnerOfQuery<TData = OwnerOfResponse>({
+  client,
+  args,
+  options
+}: Sg721OwnerOfQuery<TData>) {
+  return useQuery<OwnerOfResponse, Error, TData>(sg721QueryKeys.ownerOf(client?.contractAddress, args), () => client ? client.ownerOf({
+    includeExpired: args.includeExpired,
+    tokenId: args.tokenId
+  }) : Promise.reject(new Error(\\"Invalid client\\")), { ...options,
+    enabled: !!client && (options?.enabled != undefined ? options.enabled : true)
+  });
+}"
+`;
+
+exports[`createReactQueryHooks 6`] = `
 "export interface Sg721BurnMutation {
   client: Sg721Client;
   msg: {

package/src/react-query/react-query.spec.ts

@@ -62,6 +62,23 @@ it('createReactQueryHooks', () => {
         QueryClient: 'Sg721QueryClient'
       }
     )))
+  expectCode(
+    t.program(
+      createReactQueryHooks({
+        context: makeContext(query_msg, {
+          reactQuery: {
+            optionalClient: true,
+            version: 'v4',
+            queryKeys: true,
+            queryFactory: true
+          }
+        }),
+        queryMsg: query_msg,
+        contractName: 'Sg721',
+        QueryClient: 'Sg721QueryClient'
+      })
+    )
+  );
   expectCode(t.program(
     createReactQueryMutationHooks(
       {