@rozenite/tanstack-query-plugin 2.1.0 → 2.3.0

package/dist/sdk/sdk.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tanstackQueryTools = exports.tanstackQueryToolDefinitions = exports.TANSTACK_QUERY_AGENT_PLUGIN_ID = void 0;
+const agent_shared_1 = require("@rozenite/agent-shared");
+const agent_tools_js_1 = require("./src/shared/agent-tools.js");
+Object.defineProperty(exports, "TANSTACK_QUERY_AGENT_PLUGIN_ID", { enumerable: true, get: function () { return agent_tools_js_1.TANSTACK_QUERY_AGENT_PLUGIN_ID; } });
+Object.defineProperty(exports, "tanstackQueryToolDefinitions", { enumerable: true, get: function () { return agent_tools_js_1.tanstackQueryToolDefinitions; } });
+exports.tanstackQueryTools = (0, agent_shared_1.defineAgentToolDescriptors)(agent_tools_js_1.TANSTACK_QUERY_AGENT_PLUGIN_ID, agent_tools_js_1.tanstackQueryToolDefinitions);

package/dist/sdk/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 {};

package/dist/sdk/src/react-native/devtools-actions.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTanStackQueryDevtoolsAction = void 0;
+const getActiveQuery = (queryClient, queryHash) => {
+    if (!queryHash) {
+        throw new Error('queryHash is required for this TanStack Query action.');
+    }
+    const activeQuery = queryClient.getQueryCache().get(queryHash);
+    if (!activeQuery) {
+        throw new Error(`No active query found for hash: ${queryHash}`);
+    }
+    return activeQuery;
+};
+const applyTanStackQueryDevtoolsAction = async (queryClient, input) => {
+    switch (input.type) {
+        case 'CLEAR_QUERY_CACHE': {
+            const queryCountBefore = queryClient.getQueryCache().getAll().length;
+            queryClient.getQueryCache().clear();
+            return {
+                applied: true,
+                action: input.type,
+                cleared: true,
+                queryCountBefore,
+                queryCountAfter: queryClient.getQueryCache().getAll().length,
+            };
+        }
+        case 'CLEAR_MUTATION_CACHE': {
+            const mutationCountBefore = queryClient.getMutationCache().getAll().length;
+            queryClient.getMutationCache().clear();
+            return {
+                applied: true,
+                action: input.type,
+                cleared: true,
+                mutationCountBefore,
+                mutationCountAfter: queryClient.getMutationCache().getAll().length,
+            };
+        }
+        case 'SET_QUERY_DATA': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            queryClient.setQueryData(activeQuery.queryKey, input.metadata?.data);
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+        case 'TRIGGER_ERROR': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            const previousQueryOptions = activeQuery.options;
+            const error = new Error('Unknown error from devtools');
+            activeQuery.setState({
+                status: 'error',
+                error,
+                fetchMeta: {
+                    ...activeQuery.state.fetchMeta,
+                    // @ts-expect-error This does exist
+                    __previousQueryOptions: previousQueryOptions,
+                },
+            });
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+        case 'RESTORE_ERROR': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            await queryClient.resetQueries(activeQuery);
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+        case 'TRIGGER_LOADING': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            const previousQueryOptions = activeQuery.options;
+            void activeQuery.fetch({
+                ...previousQueryOptions,
+                queryFn: () => new Promise(() => {
+                    // Never resolve - simulates perpetual loading
+                }),
+                gcTime: -1,
+            });
+            activeQuery.setState({
+                data: undefined,
+                status: 'pending',
+                fetchMeta: {
+                    ...activeQuery.state.fetchMeta,
+                    // @ts-expect-error This does exist
+                    __previousQueryOptions: previousQueryOptions,
+                },
+            });
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+        case 'RESTORE_LOADING': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            const previousState = activeQuery.state;
+            const previousOptions = activeQuery.state.fetchMeta
+                ? activeQuery.state.fetchMeta.__previousQueryOptions
+                : null;
+            activeQuery.cancel({ silent: true });
+            activeQuery.setState({
+                ...previousState,
+                fetchStatus: 'idle',
+                fetchMeta: null,
+            });
+            if (previousOptions) {
+                void activeQuery.fetch(previousOptions);
+            }
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+        case 'RESET': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            await queryClient.resetQueries(activeQuery);
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+        case 'REMOVE': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            queryClient.removeQueries(activeQuery);
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+        case 'REFETCH': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            await activeQuery.fetch().catch(() => {
+                // Ignore errors from refetch in the agent/UI bridge.
+            });
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+        case 'INVALIDATE': {
+            const activeQuery = getActiveQuery(queryClient, input.queryHash);
+            await queryClient.invalidateQueries(activeQuery);
+            return {
+                applied: true,
+                action: input.type,
+                queryHash: activeQuery.queryHash,
+            };
+        }
+    }
+};
+exports.applyTanStackQueryDevtoolsAction = applyTanStackQueryDevtoolsAction;