@dbs-portal/tool-mock/dist/integration/query.d.ts

API mocking toolkit using MSW for DBS Portal development workflows

/**
 * React Query integration for mock environments
 */
import type { QueryIntegrationConfig } from './types';
/**
 * Mock query client configuration
 */
export interface MockQueryClientConfig {
    /** Default options for queries */
    defaultOptions?: {
        queries?: {
            staleTime?: number;
            cacheTime?: number;
            retry?: number | boolean;
            refetchOnWindowFocus?: boolean;
            refetchOnMount?: boolean;
            refetchOnReconnect?: boolean;
        };
        mutations?: {
            retry?: number | boolean;
        };
    };
    /** Mock-specific options */
    mockOptions?: {
        /** Disable retries in mock mode */
        disableRetries?: boolean;
        /** Faster stale time for development */
        fastStaleTime?: boolean;
        /** Disable background refetching */
        disableBackgroundRefetch?: boolean;
    };
}
/**
 * Create mock-aware query client configuration
 */
export declare function createMockQueryClientConfig(config?: MockQueryClientConfig): any;
/**
 * Mock query key factory
 */
export declare class MockQueryKeyFactory {
    private config;
    constructor(config?: QueryIntegrationConfig);
    /**
     * Create query key for endpoint
     */
    createKey(endpoint: string, params?: any): any[];
    /**
     * Create list query key
     */
    createListKey(endpoint: string, filters?: any, pagination?: any): any[];
    /**
     * Create detail query key
     */
    createDetailKey(endpoint: string, id: string | number): any[];
    /**
     * Create mutation key
     */
    createMutationKey(endpoint: string, operation: 'create' | 'update' | 'delete'): any[];
}
/**
 * Mock query utilities
 */
export declare const mockQueryUtils: {
    /**
     * Create mock query function
     */
    createMockQuery: <T = any>(queryKey: any[], mockData: T, options?: {
        delay?: number;
        error?: Error;
    }) => {
        queryKey: any[];
        queryFn: () => Promise<T>;
    };
    /**
     * Create mock infinite query
     */
    createMockInfiniteQuery: <T = any>(queryKey: any[], mockDataPages: T[], options?: {
        delay?: number;
        error?: Error;
    }) => {
        queryKey: any[];
        queryFn: ({ pageParam }: {
            pageParam?: number | undefined;
        }) => Promise<{
            data: T;
            nextCursor?: number;
        }>;
        getNextPageParam: (lastPage: any) => any;
    };
    /**
     * Create mock mutation
     */
    createMockMutation: <TData = any, TVariables = any>(mutationFn: (variables: TVariables) => Promise<TData> | TData, options?: {
        delay?: number;
        error?: Error;
    }) => {
        mutationFn: (variables: TVariables) => Promise<TData>;
    };
};
/**
 * Mock data invalidation utilities
 */
export declare class MockQueryInvalidation {
    private queryClient;
    constructor(queryClient: any);
    /**
     * Invalidate queries by pattern
     */
    invalidateByPattern(pattern: string[]): void;
    /**
     * Invalidate all queries for an endpoint
     */
    invalidateEndpoint(endpoint: string): void;
    /**
     * Invalidate list queries
     */
    invalidateList(endpoint: string): void;
    /**
     * Invalidate detail queries
     */
    invalidateDetail(endpoint: string, id?: string | number): void;
    /**
     * Update query data directly
     */
    updateQueryData<T>(queryKey: any[], updater: (oldData: T) => T): void;
    /**
     * Set query data directly
     */
    setQueryData<T>(queryKey: any[], data: T): void;
}
/**
 * Create mock query hooks
 */
export declare function createMockQueryHooks(_queryKeyFactory: MockQueryKeyFactory): {
    /**
     * Create mock useQuery hook
     */
    useMockQuery: <T = any>(_endpoint: string, _params?: any, mockData?: T, options?: any) => any;
    /**
     * Create mock useMutation hook
     */
    useMockMutation: <TData = any, TVariables = any>(_endpoint: string, mockResponse?: TData, options?: any) => any;
};
/**
 * Integration with existing query patterns
 */
export declare function integrateMockQueries(queryClient: any, config?: QueryIntegrationConfig): {
    queryKeyFactory: MockQueryKeyFactory;
    invalidation: MockQueryInvalidation;
    hooks: ReturnType<typeof createMockQueryHooks>;
};
/**
 * Mock query devtools integration
 */
export declare function setupMockQueryDevtools(_queryClient: any): void;
//# sourceMappingURL=query.d.ts.map