@rozenite/tanstack-query-plugin 2.1.0 → 2.3.0

package/dist/react-native/src/react-native/agent/tanstack-query-agent.js

@@ -0,0 +1,370 @@
+import { onlineManager } from '@tanstack/react-query';
+import { applyTanStackQueryDevtoolsAction } from '../devtools-actions';
+import { tanstackQueryToolDefinitions, } from '../../shared/agent-tools';
+const DEFAULT_PAGE_LIMIT = 20;
+const MAX_PAGE_LIMIT = 100;
+const isPlainObject = (value) => {
+    return !!value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype;
+};
+export const serializeForAgent = (value, seen = new WeakSet()) => {
+    if (value == null) {
+        return null;
+    }
+    if (typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : String(value);
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (typeof value === 'function' || typeof value === 'symbol') {
+        return `[non-serializable:${typeof value}]`;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack ?? null,
+            cause: serializeForAgent(value.cause, seen),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => serializeForAgent(item, seen));
+    }
+    if (ArrayBuffer.isView(value)) {
+        return Array.from(value).map((item) => typeof item === 'number' ? item : Number(item));
+    }
+    if (value instanceof ArrayBuffer) {
+        return Array.from(new Uint8Array(value));
+    }
+    if (typeof value === 'object') {
+        if (seen.has(value)) {
+            return '[circular]';
+        }
+        seen.add(value);
+        if (!isPlainObject(value)) {
+            return `[non-serializable:${value.constructor?.name ?? 'Object'}]`;
+        }
+        const entries = Object.entries(value).map(([key, nestedValue]) => [
+            key,
+            serializeForAgent(nestedValue, seen),
+        ]);
+        return Object.fromEntries(entries);
+    }
+    return String(value);
+};
+const sanitizeLimit = (limit) => {
+    if (typeof limit !== 'number' ||
+        !Number.isFinite(limit) ||
+        !Number.isInteger(limit) ||
+        limit < 1) {
+        return DEFAULT_PAGE_LIMIT;
+    }
+    return Math.min(limit, MAX_PAGE_LIMIT);
+};
+const encodeCursor = (kind, generation, offset) => {
+    return `${kind}:${generation}:${offset}`;
+};
+const decodeCursor = (cursor, kind, generation) => {
+    const [cursorKind, rawGeneration, rawOffset] = cursor.split(':', 3);
+    if (cursorKind !== kind || !rawGeneration || !rawOffset) {
+        throw new Error('Cursor does not match the requested listing. Run the command again.');
+    }
+    const cursorGeneration = Number(rawGeneration);
+    const offset = Number(rawOffset);
+    if (!Number.isInteger(cursorGeneration) || cursorGeneration !== generation) {
+        throw new Error('Cursor does not match the requested listing. Run the command again.');
+    }
+    if (!Number.isInteger(offset) || offset < 0) {
+        throw new Error('Cursor is invalid. Run the command again.');
+    }
+    return offset;
+};
+const paginate = (rows, kind, generation, input) => {
+    const limit = sanitizeLimit(input.limit);
+    const startIndex = input.cursor ? decodeCursor(input.cursor, kind, generation) : 0;
+    const endIndex = Math.min(startIndex + limit, rows.length);
+    const hasMore = endIndex < rows.length;
+    return {
+        items: rows.slice(startIndex, endIndex),
+        page: {
+            limit,
+            hasMore,
+            ...(hasMore ? { nextCursor: encodeCursor(kind, generation, endIndex) } : {}),
+        },
+    };
+};
+export const getCacheSummaryTool = tanstackQueryToolDefinitions.getCacheSummary;
+export const getOnlineStatusTool = tanstackQueryToolDefinitions.getOnlineStatus;
+export const setOnlineStatusTool = tanstackQueryToolDefinitions.setOnlineStatus;
+export const listQueriesTool = tanstackQueryToolDefinitions.listQueries;
+export const getQueryDetailsTool = tanstackQueryToolDefinitions.getQueryDetails;
+export const refetchQueryTool = tanstackQueryToolDefinitions.refetchQuery;
+export const setQueryLoadingTool = tanstackQueryToolDefinitions.setQueryLoading;
+export const setQueryErrorTool = tanstackQueryToolDefinitions.setQueryError;
+export const invalidateQueryTool = tanstackQueryToolDefinitions.invalidateQuery;
+export const resetQueryTool = tanstackQueryToolDefinitions.resetQuery;
+export const removeQueryTool = tanstackQueryToolDefinitions.removeQuery;
+export const clearQueryCacheTool = tanstackQueryToolDefinitions.clearQueryCache;
+export const listMutationsTool = tanstackQueryToolDefinitions.listMutations;
+export const getMutationDetailsTool = tanstackQueryToolDefinitions.getMutationDetails;
+export const clearMutationCacheTool = tanstackQueryToolDefinitions.clearMutationCache;
+export const TANSTACK_QUERY_AGENT_TOOLS = Object.values(tanstackQueryToolDefinitions);
+const pickObserverOptionsSummary = (options) => {
+    if (!options) {
+        return null;
+    }
+    return {
+        enabled: serializeForAgent(options.enabled),
+        networkMode: serializeForAgent(options.networkMode),
+        staleTime: serializeForAgent(options.staleTime),
+        gcTime: serializeForAgent(options.gcTime),
+        retry: serializeForAgent(options.retry),
+        retryDelay: serializeForAgent(options.retryDelay),
+        refetchInterval: serializeForAgent(options.refetchInterval),
+        refetchOnMount: serializeForAgent(options.refetchOnMount),
+        refetchOnReconnect: serializeForAgent(options.refetchOnReconnect),
+        refetchOnWindowFocus: serializeForAgent(options.refetchOnWindowFocus),
+        subscribed: serializeForAgent(options.subscribed),
+        meta: serializeForAgent(options.meta),
+        hasQueryFn: typeof options.queryFn === 'function',
+        hasSelect: typeof options.select === 'function',
+        hasPlaceholderData: 'placeholderData' in options,
+        hasInitialData: 'initialData' in options,
+    };
+};
+const pickMutationOptionsSummary = (options) => {
+    return {
+        mutationKey: serializeForAgent(options.mutationKey),
+        networkMode: serializeForAgent(options.networkMode),
+        gcTime: serializeForAgent(options.gcTime),
+        retry: serializeForAgent(options.retry),
+        retryDelay: serializeForAgent(options.retryDelay),
+        meta: serializeForAgent(options.meta),
+        scope: serializeForAgent(options.scope),
+        hasMutationFn: typeof options.mutationFn === 'function',
+        hasOnMutate: typeof options.onMutate === 'function',
+        hasOnSuccess: typeof options.onSuccess === 'function',
+        hasOnError: typeof options.onError === 'function',
+        hasOnSettled: typeof options.onSettled === 'function',
+    };
+};
+const getQuerySortTimestamp = (query) => {
+    return Math.max(query.state.dataUpdatedAt, query.state.errorUpdatedAt);
+};
+const compareQueries = (a, b) => {
+    return (getQuerySortTimestamp(b) - getQuerySortTimestamp(a) ||
+        b.getObserversCount() - a.getObserversCount() ||
+        String(b.queryHash).localeCompare(String(a.queryHash)));
+};
+const compareMutations = (a, b) => {
+    return b.state.submittedAt - a.state.submittedAt || b.mutationId - a.mutationId;
+};
+const getQuerySummary = (query) => {
+    return {
+        queryHash: query.queryHash,
+        queryKey: serializeForAgent(query.queryKey),
+        status: query.state.status,
+        fetchStatus: query.state.fetchStatus,
+        observersCount: query.getObserversCount(),
+        isInvalidated: query.state.isInvalidated,
+        dataUpdatedAt: query.state.dataUpdatedAt,
+        errorUpdatedAt: query.state.errorUpdatedAt,
+        hasData: query.state.data !== undefined,
+        hasError: query.state.error != null,
+    };
+};
+const getMutationStatus = (state) => {
+    return state.status;
+};
+const getMutationSummary = (mutation) => {
+    return {
+        mutationId: mutation.mutationId,
+        mutationKey: serializeForAgent(mutation.options.mutationKey),
+        status: getMutationStatus(mutation.state),
+        isPaused: mutation.state.isPaused,
+        submittedAt: mutation.state.submittedAt,
+        failureCount: mutation.state.failureCount,
+        hasData: mutation.state.data !== undefined,
+        hasError: mutation.state.error != null,
+    };
+};
+const resolveQuery = (queryClient, queryHash) => {
+    const query = queryClient.getQueryCache().get(queryHash);
+    if (!query) {
+        const available = queryClient
+            .getQueryCache()
+            .getAll()
+            .map((entry) => entry.queryHash)
+            .join(', ');
+        throw new Error(`Unknown queryHash "${queryHash}". Available: ${available || '(none)'}`);
+    }
+    return query;
+};
+const resolveMutation = (queryClient, mutationId) => {
+    const mutation = queryClient
+        .getMutationCache()
+        .getAll()
+        .find((entry) => entry.mutationId === mutationId);
+    if (!mutation) {
+        const available = queryClient
+            .getMutationCache()
+            .getAll()
+            .map((entry) => entry.mutationId)
+            .join(', ');
+        throw new Error(`Unknown mutationId "${mutationId}". Available: ${available || '(none)'}`);
+    }
+    return mutation;
+};
+export const buildTanStackQueryCacheSummary = (queryClient) => {
+    const queries = queryClient.getQueryCache().getAll();
+    const mutations = queryClient.getMutationCache().getAll();
+    return {
+        online: onlineManager.isOnline(),
+        queries: {
+            total: queries.length,
+            active: queries.filter((query) => query.getObserversCount() > 0).length,
+            fetching: queries.filter((query) => query.state.fetchStatus === 'fetching').length,
+            pending: queries.filter((query) => query.state.status === 'pending').length,
+            success: queries.filter((query) => query.state.status === 'success').length,
+            error: queries.filter((query) => query.state.status === 'error').length,
+            invalidated: queries.filter((query) => query.state.isInvalidated).length,
+        },
+        mutations: {
+            total: mutations.length,
+            pending: mutations.filter((mutation) => mutation.state.status === 'pending').length,
+            success: mutations.filter((mutation) => mutation.state.status === 'success').length,
+            error: mutations.filter((mutation) => mutation.state.status === 'error').length,
+            paused: mutations.filter((mutation) => mutation.state.isPaused).length,
+        },
+    };
+};
+export const createTanStackQueryAgentController = (queryClient) => {
+    const cursorState = {
+        queriesGeneration: 0,
+        mutationsGeneration: 0,
+    };
+    return {
+        handleQueryCacheEvent(event) {
+            if (event.type === 'added' || event.type === 'removed') {
+                cursorState.queriesGeneration += 1;
+            }
+        },
+        handleMutationCacheEvent(event) {
+            if (event.type === 'added' || event.type === 'removed') {
+                cursorState.mutationsGeneration += 1;
+            }
+        },
+        getCacheSummary() {
+            return buildTanStackQueryCacheSummary(queryClient);
+        },
+        getOnlineStatus() {
+            return {
+                online: onlineManager.isOnline(),
+            };
+        },
+        setOnlineStatus({ online }) {
+            onlineManager.setOnline(online);
+            return {
+                online: onlineManager.isOnline(),
+            };
+        },
+        listQueries(input = {}) {
+            const queries = [...queryClient.getQueryCache().getAll()].sort(compareQueries);
+            return {
+                ...buildTanStackQueryCacheSummary(queryClient),
+                total: queries.length,
+                ...paginate(queries.map(getQuerySummary), 'queries', cursorState.queriesGeneration, input),
+            };
+        },
+        getQueryDetails({ queryHash }) {
+            const query = resolveQuery(queryClient, queryHash);
+            return {
+                summary: buildTanStackQueryCacheSummary(queryClient),
+                query: {
+                    ...getQuerySummary(query),
+                    data: serializeForAgent(query.state.data),
+                    error: serializeForAgent(query.state.error),
+                    observers: query.observers.map((observer) => ({
+                        queryHash: query.queryHash,
+                        options: pickObserverOptionsSummary(observer.options),
+                    })),
+                },
+            };
+        },
+        async refetchQuery({ queryHash }) {
+            return applyTanStackQueryDevtoolsAction(queryClient, {
+                type: 'REFETCH',
+                queryHash,
+            });
+        },
+        async setQueryLoading({ queryHash, enabled }) {
+            return applyTanStackQueryDevtoolsAction(queryClient, {
+                type: enabled ? 'TRIGGER_LOADING' : 'RESTORE_LOADING',
+                queryHash,
+            });
+        },
+        async setQueryError({ queryHash, enabled }) {
+            return applyTanStackQueryDevtoolsAction(queryClient, {
+                type: enabled ? 'TRIGGER_ERROR' : 'RESTORE_ERROR',
+                queryHash,
+            });
+        },
+        async invalidateQuery({ queryHash }) {
+            return applyTanStackQueryDevtoolsAction(queryClient, {
+                type: 'INVALIDATE',
+                queryHash,
+            });
+        },
+        async resetQuery({ queryHash }) {
+            return applyTanStackQueryDevtoolsAction(queryClient, {
+                type: 'RESET',
+                queryHash,
+            });
+        },
+        async removeQuery({ queryHash }) {
+            return applyTanStackQueryDevtoolsAction(queryClient, {
+                type: 'REMOVE',
+                queryHash,
+            });
+        },
+        async clearQueryCache() {
+            return applyTanStackQueryDevtoolsAction(queryClient, {
+                type: 'CLEAR_QUERY_CACHE',
+            });
+        },
+        listMutations(input = {}) {
+            const mutations = [...queryClient.getMutationCache().getAll()].sort(compareMutations);
+            return {
+                ...buildTanStackQueryCacheSummary(queryClient),
+                total: mutations.length,
+                ...paginate(mutations.map(getMutationSummary), 'mutations', cursorState.mutationsGeneration, input),
+            };
+        },
+        getMutationDetails({ mutationId }) {
+            const mutation = resolveMutation(queryClient, mutationId);
+            return {
+                summary: buildTanStackQueryCacheSummary(queryClient),
+                mutation: {
+                    ...getMutationSummary(mutation),
+                    variables: serializeForAgent(mutation.state.variables),
+                    data: serializeForAgent(mutation.state.data),
+                    error: serializeForAgent(mutation.state.error),
+                    context: serializeForAgent(mutation.state.context),
+                    failureReason: serializeForAgent(mutation.state.failureReason),
+                    options: pickMutationOptionsSummary(mutation.options),
+                },
+            };
+        },
+        async clearMutationCache() {
+            return applyTanStackQueryDevtoolsAction(queryClient, {
+                type: 'CLEAR_MUTATION_CACHE',
+            });
+        },
+    };
+};

package/dist/react-native/src/react-native/agent/useTanStackQueryAgentTools.d.ts

@@ -0,0 +1,2 @@
+import { QueryClient } from '@tanstack/react-query';
+export declare const useTanStackQueryAgentTools: (queryClient: QueryClient) => void;

package/dist/react-native/src/react-native/agent/useTanStackQueryAgentTools.js

@@ -0,0 +1,94 @@
+import { useEffect, useMemo } from 'react';
+import { useRozenitePluginAgentTool } from '@rozenite/agent-bridge';
+import { createTanStackQueryAgentController } from './tanstack-query-agent';
+import { TANSTACK_QUERY_AGENT_PLUGIN_ID, tanstackQueryToolDefinitions, } from '../../shared/agent-tools';
+export const useTanStackQueryAgentTools = (queryClient) => {
+    const controller = useMemo(() => createTanStackQueryAgentController(queryClient), [queryClient]);
+    useEffect(() => {
+        const unsubscribeQueryCache = queryClient
+            .getQueryCache()
+            .subscribe((event) => controller.handleQueryCacheEvent(event));
+        const unsubscribeMutationCache = queryClient
+            .getMutationCache()
+            .subscribe((event) => controller.handleMutationCacheEvent(event));
+        return () => {
+            unsubscribeQueryCache();
+            unsubscribeMutationCache();
+        };
+    }, [controller, queryClient]);
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.getCacheSummary,
+        handler: () => controller.getCacheSummary(),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.getOnlineStatus,
+        handler: () => controller.getOnlineStatus(),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.setOnlineStatus,
+        handler: (input) => controller.setOnlineStatus(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.listQueries,
+        handler: (input = {}) => controller.listQueries(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.getQueryDetails,
+        handler: (input) => controller.getQueryDetails(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.refetchQuery,
+        handler: (input) => controller.refetchQuery(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.setQueryLoading,
+        handler: (input) => controller.setQueryLoading(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.setQueryError,
+        handler: (input) => controller.setQueryError(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.invalidateQuery,
+        handler: (input) => controller.invalidateQuery(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.resetQuery,
+        handler: (input) => controller.resetQuery(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.removeQuery,
+        handler: (input) => controller.removeQuery(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.clearQueryCache,
+        handler: () => controller.clearQueryCache(),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.listMutations,
+        handler: (input = {}) => controller.listMutations(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.getMutationDetails,
+        handler: (input) => controller.getMutationDetails(input),
+    });
+    useRozenitePluginAgentTool({
+        pluginId: TANSTACK_QUERY_AGENT_PLUGIN_ID,
+        tool: tanstackQueryToolDefinitions.clearMutationCache,
+        handler: () => controller.clearMutationCache(),
+    });
+};

package/dist/react-native/src/react-native/devtools-actions.d.ts

@@ -0,0 +1,115 @@
+import { QueryClient } from '@tanstack/react-query';
+import { DevToolsActionType } from '../shared/types';
+type QueryScopedActionInput = {
+    type: Exclude<DevToolsActionType, 'CLEAR_MUTATION_CACHE' | 'CLEAR_QUERY_CACHE'>;
+    queryHash: string;
+    metadata?: {
+        data?: unknown;
+    };
+};
+type CacheScopedActionInput = {
+    type: 'CLEAR_MUTATION_CACHE' | 'CLEAR_QUERY_CACHE';
+    queryHash?: string;
+};
+export type TanStackQueryDevtoolsActionInput = QueryScopedActionInput | CacheScopedActionInput;
+export declare const applyTanStackQueryDevtoolsAction: (queryClient: QueryClient, input: TanStackQueryDevtoolsActionInput) => Promise<{
+    applied: boolean;
+    action: "CLEAR_QUERY_CACHE";
+    cleared: boolean;
+    queryCountBefore: number;
+    queryCountAfter: number;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+    queryHash?: undefined;
+} | {
+    applied: boolean;
+    action: "CLEAR_MUTATION_CACHE";
+    cleared: boolean;
+    mutationCountBefore: number;
+    mutationCountAfter: number;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    queryHash?: undefined;
+} | {
+    applied: boolean;
+    action: "SET_QUERY_DATA";
+    queryHash: string;
+    cleared?: undefined;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+} | {
+    applied: boolean;
+    action: "TRIGGER_ERROR";
+    queryHash: string;
+    cleared?: undefined;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+} | {
+    applied: boolean;
+    action: "RESTORE_ERROR";
+    queryHash: string;
+    cleared?: undefined;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+} | {
+    applied: boolean;
+    action: "TRIGGER_LOADING";
+    queryHash: string;
+    cleared?: undefined;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+} | {
+    applied: boolean;
+    action: "RESTORE_LOADING";
+    queryHash: string;
+    cleared?: undefined;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+} | {
+    applied: boolean;
+    action: "RESET";
+    queryHash: string;
+    cleared?: undefined;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+} | {
+    applied: boolean;
+    action: "REMOVE";
+    queryHash: string;
+    cleared?: undefined;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+} | {
+    applied: boolean;
+    action: "REFETCH";
+    queryHash: string;
+    cleared?: undefined;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+} | {
+    applied: boolean;
+    action: "INVALIDATE";
+    queryHash: string;
+    cleared?: undefined;
+    queryCountBefore?: undefined;
+    queryCountAfter?: undefined;
+    mutationCountBefore?: undefined;
+    mutationCountAfter?: undefined;
+}>;
+export {};