gomtm 0.0.280 → 0.0.282

package/dist/esm/gomtmQuery.d.ts

@@ -0,0 +1,14 @@
+interface goMtmQueryFnProps {
+    svc: string;
+    method: string;
+    input?: any;
+    options?: {
+        url: string;
+    };
+}
+export declare const goMtmQueryFn: (props: goMtmQueryFnProps) => Promise<any>;
+export declare const useGomtmQuery: (svc: string, method: string, input?: any) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+export declare const useGomtmSuspenseQuery: (svc: string, method: string, input?: any) => import("@tanstack/react-query").UseSuspenseQueryResult<any, Error>;
+export declare const useGomtmSuspenseInfiniteQuery: (svc: string, method: string, input?: any) => import("@tanstack/react-query").UseSuspenseInfiniteQueryResult<import("@tanstack/react-query").InfiniteData<any, unknown>, Error>;
+export declare const useGomtmMutation: (svc: string, method: string) => import("@tanstack/react-query").UseMutationResult<any, Error, any, unknown>;
+export {};

package/dist/esm/gomtmQuery.js

@@ -0,0 +1,102 @@
+"use client";
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { useMutation, useQuery, useSuspenseInfiniteQuery, useSuspenseQuery } from "@tanstack/react-query";
+import { camelCase } from "lodash";
+import { MTM_API_PREFIX } from "./consts";
+import { createMtmServiceClientByName, createQueryKey } from "./mtmFetcher";
+import { useMtmApp } from "./providers/GomtmProvider";
+const goMtmQueryFn = (props) => __async(void 0, null, function* () {
+  var _a;
+  const client = createMtmServiceClientByName(props.svc, (_a = props.options) == null ? void 0 : _a.url);
+  if (!client) {
+    throw new Error(`missing mtmclient:"${props.svc}"`);
+  }
+  const methodName = camelCase(props.method);
+  const methodFn = client[methodName];
+  if (!methodFn) {
+    throw new Error(`missing mtmclient method:"${props.svc}.${methodName}"`);
+  }
+  const data = yield methodFn(props.input);
+  console.log(`goMtmQueryFn ${props.svc}.${props.method}.${props.input}`, data);
+  return data;
+});
+const useGomtmQuery = (svc, method, input) => {
+  const query = useQuery({
+    queryKey: createQueryKey(svc, method, input),
+    queryFn: (k) => goMtmQueryFn({ svc, method, input })
+  });
+  return query;
+};
+const useGomtmSuspenseQuery = (svc, method, input) => {
+  const mtapp = useMtmApp();
+  const query = useSuspenseQuery({
+    queryKey: createQueryKey(svc, method, input),
+    queryFn: (k) => goMtmQueryFn({
+      svc,
+      method,
+      input,
+      options: {
+        url: new URL(MTM_API_PREFIX, mtapp.backendUrl || "").toString()
+      }
+    })
+  });
+  return query;
+};
+const useGomtmSuspenseInfiniteQuery = (svc, method, input) => {
+  const mtapp = useMtmApp();
+  const query = useSuspenseInfiniteQuery({
+    queryKey: createQueryKey(svc, method, input),
+    queryFn: (k) => goMtmQueryFn({
+      svc,
+      method,
+      input,
+      options: {
+        url: new URL(MTM_API_PREFIX, mtapp.backendUrl || "").toString()
+      }
+    }),
+    initialPageParam: input,
+    getNextPageParam: (lastPage, allPages, lastPageParam, allPageParams) => {
+      return lastPage;
+    }
+  });
+  return query;
+};
+const useGomtmMutation = (svc, method) => {
+  const mtapp = useMtmApp();
+  return useMutation({
+    mutationFn: (input) => goMtmQueryFn({
+      svc,
+      method,
+      input,
+      options: {
+        url: new URL(MTM_API_PREFIX, mtapp.backendUrl || "").toString()
+      }
+    })
+  });
+};
+export {
+  goMtmQueryFn,
+  useGomtmMutation,
+  useGomtmQuery,
+  useGomtmSuspenseInfiniteQuery,
+  useGomtmSuspenseQuery
+};

package/dist/esm/mtmFetcher.d.ts

@@ -1,4 +1,6 @@
 import { ServiceType } from "@bufbuild/protobuf";
+export declare const createQueryKey: (svc: string, method: string, input: any) => any[];
+export declare const createInfiniteQueryKey: (svc: string, method: string, input: any) => any[];
 export declare const ssrGetBackendUrl: () => string;
 export declare const gomtmApiUrl: () => string;
 export declare function createMtmServiceClient<T extends ServiceType>(service: T, url?: string): import("@connectrpc/connect").PromiseClient<T>;

package/dist/esm/mtmFetcher.js

@@ -40,6 +40,13 @@ import { merge } from "lodash";
 import { fetchMiddleWithCache } from "mtxlib/http/fetchMiddleWithCache";
 import { MTM_API_PREFIX } from "./consts";
 import { MtmService } from "./gomtmpb/mtm/sppb/mtm_connect";
+const allServices = [MtmService];
+const createQueryKey = (svc, method, input) => {
+  return [svc, method, input || {}];
+};
+const createInfiniteQueryKey = (svc, method, input) => {
+  return [svc, method, input || {}, "infinite"];
+};
 const ssrGetBackendUrl = () => {
   var _a;
   if (typeof window == "undefined") {
@@ -81,15 +88,15 @@ function createMtmServiceClientByName(svcName, url) {
   if (!svcType) {
     throw new Error(`unknown svcType ${svcName}`);
   }
+  const baseUrl = url || gomtmApiUrl();
   return createPromiseClient(
     svcType,
     createConnectTransport({
-      baseUrl: gomtmApiUrl(),
+      baseUrl,
       fetch: gomtmFetcher()
     })
   );
 }
-const allServices = [MtmService];
 const gomtmFetcher = (initGlobal) => {
   return (input, init) => __async(void 0, null, function* () {
     if (init) {
@@ -145,8 +152,10 @@ const gomtmFetcher = (initGlobal) => {
   });
 };
 export {
+  createInfiniteQueryKey,
   createMtmServiceClient,
   createMtmServiceClientByName,
+  createQueryKey,
   createTransport,
   gomtmApiUrl,
   gomtmFetcher,