@yimingliao/cms 0.0.76 → 0.0.77

package/dist/client/index.d.ts

@@ -1,6 +1,8 @@
-import { R as Result, S as SuccessResult, a as ErrorResult, E as ErrorDetail } from '../types-DHlRoJwv.js';
+import { R as Result, S as SuccessResult, a as ErrorResult } from '../types-DHlRoJwv.js';
 import { Logger } from 'logry';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+import * as _tanstack_query_core from '@tanstack/query-core';
 
 interface FetchContext {
     input: string;
@@ -34,8 +36,262 @@ type ShowToastOption = boolean | {
 };
 declare const handleToast: (result: SuccessResult | ErrorResult, showToast?: ShowToastOption) => void;
 
-declare const shouldShowToast: (type: "success" | "error", showToast?: ShowToastOption) => boolean;
+declare function createUseCommand(queryClient: QueryClient): <P = void, R = unknown>(fn: (params: P) => Promise<Result<R | undefined>>, mutationOptions?: UseMutationOptions<R | undefined, unknown, P> & {
+    showToast?: ShowToastOption;
+    shouldTrigger?: (payload: P) => (boolean | undefined) | Promise<boolean | undefined>;
+    clearAll?: boolean;
+}) => {
+    execute: (params: P extends void ? void : P) => Promise<R | undefined>;
+    isRedirecting: boolean;
+    errors: string[];
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    mutate: _tanstack_react_query.UseMutateFunction<R | undefined, Error, P, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<R | undefined, Error, P, unknown>;
+} | {
+    execute: (params: P extends void ? void : P) => Promise<R | undefined>;
+    isRedirecting: boolean;
+    errors: string[];
+    data: undefined;
+    variables: P;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    mutate: _tanstack_react_query.UseMutateFunction<R | undefined, Error, P, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<R | undefined, Error, P, unknown>;
+} | {
+    execute: (params: P extends void ? void : P) => Promise<R | undefined>;
+    isRedirecting: boolean;
+    errors: string[];
+    data: undefined;
+    error: Error;
+    variables: P;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    mutate: _tanstack_react_query.UseMutateFunction<R | undefined, Error, P, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<R | undefined, Error, P, unknown>;
+} | {
+    execute: (params: P extends void ? void : P) => Promise<R | undefined>;
+    isRedirecting: boolean;
+    errors: string[];
+    data: R | undefined;
+    error: null;
+    variables: P;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    mutate: _tanstack_react_query.UseMutateFunction<R | undefined, Error, P, unknown>;
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+    mutateAsync: _tanstack_react_query.UseMutateAsyncFunction<R | undefined, Error, P, unknown>;
+};
 
-declare const createErrorDisplay: (errors: ErrorDetail[]) => react_jsx_runtime.JSX.Element;
+declare function createUseQuery(): <P = void, R = unknown, TData = R>(fn: (params?: P) => Promise<Result<R>>, queryKey: readonly unknown[], queryOptions?: Omit<UseQueryOptions<R | undefined, Error, TData, readonly unknown[]>, "queryKey"> & {
+    params?: P;
+}) => {
+    isNotFound: boolean;
+    data: _tanstack_query_core.NoInfer<TData>;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_query_core.FetchStatus;
+    promise: Promise<_tanstack_query_core.NoInfer<TData>>;
+} | {
+    isNotFound: boolean;
+    data: _tanstack_query_core.NoInfer<TData>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_query_core.FetchStatus;
+    promise: Promise<_tanstack_query_core.NoInfer<TData>>;
+} | {
+    isNotFound: boolean;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_query_core.FetchStatus;
+    promise: Promise<_tanstack_query_core.NoInfer<TData>>;
+} | {
+    isNotFound: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_query_core.FetchStatus;
+    promise: Promise<_tanstack_query_core.NoInfer<TData>>;
+} | {
+    isNotFound: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_query_core.FetchStatus;
+    promise: Promise<_tanstack_query_core.NoInfer<TData>>;
+} | {
+    isNotFound: boolean;
+    data: _tanstack_query_core.NoInfer<TData>;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_tanstack_query_core.NoInfer<TData>, Error>>;
+    fetchStatus: _tanstack_query_core.FetchStatus;
+    promise: Promise<_tanstack_query_core.NoInfer<TData>>;
+};
 
-export { type ShowToastOption, createErrorDisplay, createRequestInterceptor, createResponseInterceptor, createSmartFetch, handleToast, shouldShowToast };
+export { type ShowToastOption, createRequestInterceptor, createResponseInterceptor, createSmartFetch, createUseCommand, createUseQuery, handleToast };

package/dist/client/index.js

@@ -1,5 +1,8 @@
+import { ensureArray } from '../chunk-OAENV763.js';
 import { toast } from 'sonner';
 import { jsx, jsxs } from 'react/jsx-runtime';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { useState } from 'react';
 
 // src/client/infrastructure/fetch/smart-fetch.ts
 function createSmartFetch({
@@ -121,5 +124,65 @@ var handleToast = (result, showToast) => {
     }
   }
 };
+function createUseCommand(queryClient) {
+  return function useCommand(fn, mutationOptions) {
+    const [isRedirecting, setIsRedirecting] = useState(false);
+    const [errors, setErrors] = useState([]);
+    const { showToast, shouldTrigger, clearAll = true } = mutationOptions || {};
+    const mutation = useMutation({
+      ...mutationOptions,
+      mutationFn: async (params) => {
+        const response = await fn(params);
+        handleToast(response, showToast);
+        if (response.success) {
+          setErrors([]);
+          if (clearAll) {
+            await queryClient.invalidateQueries({
+              predicate: (query) => !query.queryKey[0].startsWith("auth")
+            });
+          }
+          return response.data;
+        }
+        setErrors(
+          ensureArray(response.errors).map((e) => e.field).filter((f) => typeof f === "string")
+        );
+        throw new Error(response.message);
+      }
+    });
+    const execute = (async (params) => {
+      try {
+        if (shouldTrigger) {
+          const shouldProceed = await shouldTrigger(params);
+          if (!shouldProceed) {
+            setIsRedirecting(false);
+            return void 0;
+          }
+        }
+        setIsRedirecting(true);
+        return await mutation.mutateAsync(params);
+      } catch {
+        setIsRedirecting(false);
+        return void 0;
+      }
+    });
+    return { ...mutation, execute, isRedirecting, errors };
+  };
+}
+function createUseQuery() {
+  return function useQuery$1(fn, queryKey, queryOptions) {
+    const { params, ...rest } = queryOptions || {};
+    const query = useQuery({
+      queryKey: params ? [...queryKey, params] : queryKey,
+      queryFn: async () => {
+        const response = await fn(params);
+        if (response.success) return response.data;
+        throw new Error(response.message);
+      },
+      ...rest
+    });
+    const isNotFound = !query.isPending && !query.data;
+    return { ...query, isNotFound };
+  };
+}
 
-export { createErrorDisplay, createRequestInterceptor, createResponseInterceptor, createSmartFetch, handleToast, shouldShowToast };
+export { createRequestInterceptor, createResponseInterceptor, createSmartFetch, createUseCommand, createUseQuery, handleToast };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yimingliao/cms",
-  "version": "0.0.76",
+  "version": "0.0.77",
   "author": "Yiming Liao",
   "license": "MIT",
   "type": "module",
@@ -58,6 +58,7 @@
     "@aws-sdk/client-s3": "^3.1004.0",
     "@eslint/js": "^10.0.1",
     "@prisma/client": "6.5.0",
+    "@tanstack/react-query": "^5.90.21",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/mime-types": "^3.0.1",
     "@types/nodemailer": "^7.0.11",