Feat/react query

__fixtures__/output1/akash/audit/v1beta2/query.rpc.query.ts → __fixtures__/output1/akash/audit/v1beta2/query.rpc.Query.ts

@@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr
 import { Provider, ProviderSDKType } from "./audit";
 import { Rpc } from "../../../helpers";
 import * as _m0 from "protobufjs/minimal";
-import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate";
+import { ReactQueryParams } from "../../../react-query";
+import { useQuery } from "@tanstack/react-query";
 import { QueryAllProvidersAttributesRequest, QueryAllProvidersAttributesRequestSDKType, QueryProvidersResponse, QueryProvidersResponseSDKType, QueryProviderAttributesRequest, QueryProviderAttributesRequestSDKType, QueryProviderAuditorRequest, QueryProviderAuditorRequestSDKType, QueryAuditorAttributesRequest, QueryAuditorAttributesRequestSDKType } from "./query";
 
 /** Query defines the gRPC querier service */
@@ -101,4 +103,106 @@ export const createRpcQueryExtension = (base: QueryClient) => {
     }
 
   };
+};
+export interface UseAllProvidersAttributesQuery<TData> extends ReactQueryParams<QueryProvidersResponse, TData> {
+  request?: QueryAllProvidersAttributesRequest;
+}
+export interface UseProviderAttributesQuery<TData> extends ReactQueryParams<QueryProvidersResponse, TData> {
+  request: QueryProviderAttributesRequest;
+}
+export interface UseProviderAuditorAttributesQuery<TData> extends ReactQueryParams<QueryProvidersResponse, TData> {
+  request: QueryProviderAuditorRequest;
+}
+export interface UseAuditorAttributesQuery<TData> extends ReactQueryParams<QueryProvidersResponse, TData> {
+  request: QueryAuditorAttributesRequest;
+}
+
+const _queryClients: WeakMap<ProtobufRpcClient, QueryClientImpl> = new WeakMap();
+
+const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => {
+  if (!rpc) return;
+
+  if (_queryClients.has(rpc)) {
+    return _queryClients.get(rpc);
+  }
+
+  const queryService = new QueryClientImpl(rpc);
+
+  _queryClients.set(rpc, queryService);
+
+  return queryService;
+};
+
+export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => {
+  const queryService = getQueryService(rpc);
+
+  const useAllProvidersAttributes = <TData = QueryProvidersResponse,>({
+    request,
+    options
+  }: UseAllProvidersAttributesQuery<TData>) => {
+    return useQuery<QueryProvidersResponse, Error, TData>(["allProvidersAttributesQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.allProvidersAttributes(request);
+    }, options);
+  };
+
+  const useProviderAttributes = <TData = QueryProvidersResponse,>({
+    request,
+    options
+  }: UseProviderAttributesQuery<TData>) => {
+    return useQuery<QueryProvidersResponse, Error, TData>(["providerAttributesQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.providerAttributes(request);
+    }, options);
+  };
+
+  const useProviderAuditorAttributes = <TData = QueryProvidersResponse,>({
+    request,
+    options
+  }: UseProviderAuditorAttributesQuery<TData>) => {
+    return useQuery<QueryProvidersResponse, Error, TData>(["providerAuditorAttributesQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.providerAuditorAttributes(request);
+    }, options);
+  };
+
+  const useAuditorAttributes = <TData = QueryProvidersResponse,>({
+    request,
+    options
+  }: UseAuditorAttributesQuery<TData>) => {
+    return useQuery<QueryProvidersResponse, Error, TData>(["auditorAttributesQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.auditorAttributes(request);
+    }, options);
+  };
+
+  return {
+    /**
+     * AllProvidersAttributes queries all providers
+     * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+     */
+    useAllProvidersAttributes,
+
+    /**
+     * ProviderAttributes queries all provider signed attributes
+     * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+     */
+    useProviderAttributes,
+
+    /**
+     * ProviderAuditorAttributes queries provider signed attributes by specific auditor
+     * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+     */
+    useProviderAuditorAttributes,
+
+    /**
+     * AuditorAttributes queries all providers signed by this auditor
+     * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+     */
+    useAuditorAttributes
+  };
 };

__fixtures__/output1/akash/cert/v1beta2/query.rpc.query.ts → __fixtures__/output1/akash/cert/v1beta2/query.rpc.Query.ts

@@ -2,7 +2,9 @@ import { CertificateFilter, CertificateFilterSDKType, Certificate, CertificateSD
 import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } from "../../../cosmos/base/query/v1beta1/pagination";
 import { Rpc } from "../../../helpers";
 import * as _m0 from "protobufjs/minimal";
-import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate";
+import { ReactQueryParams } from "../../../react-query";
+import { useQuery } from "@tanstack/react-query";
 import { QueryCertificatesRequest, QueryCertificatesRequestSDKType, QueryCertificatesResponse, QueryCertificatesResponseSDKType } from "./query";
 
 /** Query defines the gRPC querier service */
@@ -33,4 +35,42 @@ export const createRpcQueryExtension = (base: QueryClient) => {
     }
 
   };
+};
+export interface UseCertificatesQuery<TData> extends ReactQueryParams<QueryCertificatesResponse, TData> {
+  request: QueryCertificatesRequest;
+}
+
+const _queryClients: WeakMap<ProtobufRpcClient, QueryClientImpl> = new WeakMap();
+
+const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => {
+  if (!rpc) return;
+
+  if (_queryClients.has(rpc)) {
+    return _queryClients.get(rpc);
+  }
+
+  const queryService = new QueryClientImpl(rpc);
+
+  _queryClients.set(rpc, queryService);
+
+  return queryService;
+};
+
+export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => {
+  const queryService = getQueryService(rpc);
+
+  const useCertificates = <TData = QueryCertificatesResponse,>({
+    request,
+    options
+  }: UseCertificatesQuery<TData>) => {
+    return useQuery<QueryCertificatesResponse, Error, TData>(["certificatesQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.certificates(request);
+    }, options);
+  };
+
+  return {
+    /** Certificates queries certificates */
+    useCertificates
+  };
 };

__fixtures__/output1/akash/deployment/v1beta2/query.rpc.query.ts → __fixtures__/output1/akash/deployment/v1beta2/query.rpc.Query.ts

@@ -5,7 +5,9 @@ import { Group, GroupSDKType } from "./group";
 import { Account, AccountSDKType } from "../../escrow/v1beta2/types";
 import { Rpc } from "../../../helpers";
 import * as _m0 from "protobufjs/minimal";
-import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate";
+import { ReactQueryParams } from "../../../react-query";
+import { useQuery } from "@tanstack/react-query";
 import { QueryDeploymentsRequest, QueryDeploymentsRequestSDKType, QueryDeploymentsResponse, QueryDeploymentsResponseSDKType, QueryDeploymentRequest, QueryDeploymentRequestSDKType, QueryDeploymentResponse, QueryDeploymentResponseSDKType, QueryGroupRequest, QueryGroupRequestSDKType, QueryGroupResponse, QueryGroupResponseSDKType } from "./query";
 
 /** Query defines the gRPC querier service */
@@ -64,4 +66,74 @@ export const createRpcQueryExtension = (base: QueryClient) => {
     }
 
   };
+};
+export interface UseDeploymentsQuery<TData> extends ReactQueryParams<QueryDeploymentsResponse, TData> {
+  request: QueryDeploymentsRequest;
+}
+export interface UseDeploymentQuery<TData> extends ReactQueryParams<QueryDeploymentResponse, TData> {
+  request: QueryDeploymentRequest;
+}
+export interface UseGroupQuery<TData> extends ReactQueryParams<QueryGroupResponse, TData> {
+  request: QueryGroupRequest;
+}
+
+const _queryClients: WeakMap<ProtobufRpcClient, QueryClientImpl> = new WeakMap();
+
+const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => {
+  if (!rpc) return;
+
+  if (_queryClients.has(rpc)) {
+    return _queryClients.get(rpc);
+  }
+
+  const queryService = new QueryClientImpl(rpc);
+
+  _queryClients.set(rpc, queryService);
+
+  return queryService;
+};
+
+export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => {
+  const queryService = getQueryService(rpc);
+
+  const useDeployments = <TData = QueryDeploymentsResponse,>({
+    request,
+    options
+  }: UseDeploymentsQuery<TData>) => {
+    return useQuery<QueryDeploymentsResponse, Error, TData>(["deploymentsQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.deployments(request);
+    }, options);
+  };
+
+  const useDeployment = <TData = QueryDeploymentResponse,>({
+    request,
+    options
+  }: UseDeploymentQuery<TData>) => {
+    return useQuery<QueryDeploymentResponse, Error, TData>(["deploymentQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.deployment(request);
+    }, options);
+  };
+
+  const useGroup = <TData = QueryGroupResponse,>({
+    request,
+    options
+  }: UseGroupQuery<TData>) => {
+    return useQuery<QueryGroupResponse, Error, TData>(["groupQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.group(request);
+    }, options);
+  };
+
+  return {
+    /** Deployments queries deployments */
+    useDeployments,
+
+    /** Deployment queries deployment details */
+    useDeployment,
+
+    /** Group queries group details */
+    useGroup
+  };
 };

__fixtures__/output1/akash/escrow/v1beta1/query.rpc.query.ts → __fixtures__/output1/akash/escrow/v1beta1/query.rpc.Query.ts

@@ -2,7 +2,9 @@ import { PageRequest, PageRequestSDKType, PageResponse, PageResponseSDKType } fr
 import { Account, AccountSDKType, Payment, PaymentSDKType } from "./types";
 import { Rpc } from "../../../helpers";
 import * as _m0 from "protobufjs/minimal";
-import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate";
+import { QueryClient, createProtobufRpcClient, ProtobufRpcClient } from "@cosmjs/stargate";
+import { ReactQueryParams } from "../../../react-query";
+import { useQuery } from "@tanstack/react-query";
 import { QueryAccountsRequest, QueryAccountsRequestSDKType, QueryAccountsResponse, QueryAccountsResponseSDKType, QueryPaymentsRequest, QueryPaymentsRequestSDKType, QueryPaymentsResponse, QueryPaymentsResponseSDKType } from "./query";
 
 /** Query defines the gRPC querier service */
@@ -59,4 +61,66 @@ export const createRpcQueryExtension = (base: QueryClient) => {
     }
 
   };
+};
+export interface UseAccountsQuery<TData> extends ReactQueryParams<QueryAccountsResponse, TData> {
+  request: QueryAccountsRequest;
+}
+export interface UsePaymentsQuery<TData> extends ReactQueryParams<QueryPaymentsResponse, TData> {
+  request: QueryPaymentsRequest;
+}
+
+const _queryClients: WeakMap<ProtobufRpcClient, QueryClientImpl> = new WeakMap();
+
+const getQueryService = (rpc: ProtobufRpcClient | undefined): QueryClientImpl | undefined => {
+  if (!rpc) return;
+
+  if (_queryClients.has(rpc)) {
+    return _queryClients.get(rpc);
+  }
+
+  const queryService = new QueryClientImpl(rpc);
+
+  _queryClients.set(rpc, queryService);
+
+  return queryService;
+};
+
+export const createRpcQueryHooks = (rpc: ProtobufRpcClient | undefined) => {
+  const queryService = getQueryService(rpc);
+
+  const useAccounts = <TData = QueryAccountsResponse,>({
+    request,
+    options
+  }: UseAccountsQuery<TData>) => {
+    return useQuery<QueryAccountsResponse, Error, TData>(["accountsQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.accounts(request);
+    }, options);
+  };
+
+  const usePayments = <TData = QueryPaymentsResponse,>({
+    request,
+    options
+  }: UsePaymentsQuery<TData>) => {
+    return useQuery<QueryPaymentsResponse, Error, TData>(["paymentsQuery", request], () => {
+      if (!queryService) throw new Error("Query Service not initialized");
+      return queryService.payments(request);
+    }, options);
+  };
+
+  return {
+    /**
+     * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+     * Accounts queries all accounts
+     */
+    useAccounts,
+
+    /**
+     * buf:lint:ignore RPC_REQUEST_RESPONSE_UNIQUE
+     * buf:lint:ignore RPC_RESPONSE_STANDARD_NAME
+     * Payments queries all payments
+     */
+    usePayments
+  };
 };