@mastra/react 1.7.3-alpha.3 → 1.8.0-alpha.5

package/dist/hooks/datasets/index.js

@@ -0,0 +1,600 @@
+import { n as useMastraClient } from "../../mastra-client-context-Bx_g84YB.js";
+import { t as useInView } from "../../use-in-view-C9sYPGRm.js";
+import { useEffect } from "react";
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+//#region src/hooks/datasets/use-dataset-items.ts
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useDatasetItem = ({ datasetId, itemId, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"dataset-item",
+			datasetId,
+			itemId
+		],
+		queryFn: () => client.getDatasetItem(datasetId, itemId),
+		retry: false,
+		...queryOptions
+	});
+};
+const PER_PAGE$1 = 10;
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useDatasetItems = ({ datasetId, search, version, orderBy, queryOptions }) => {
+	const client = useMastraClient();
+	const { inView: isEndOfListInView, setRef: setEndOfListElement } = useInView();
+	const query = useInfiniteQuery({
+		queryKey: [
+			"dataset-items",
+			datasetId,
+			search,
+			version,
+			orderBy
+		],
+		queryFn: async ({ pageParam }) => {
+			return await client.listDatasetItems(datasetId, {
+				page: pageParam,
+				perPage: PER_PAGE$1,
+				search: search || void 0,
+				version: version || void 0,
+				orderBy
+			});
+		},
+		initialPageParam: 0,
+		getNextPageParam: (lastPage, _, lastPageParam) => {
+			if (!lastPage?.items?.length) return;
+			if ((lastPageParam + 1) * PER_PAGE$1 >= (lastPage?.pagination?.total ?? 0)) return;
+			return lastPageParam + 1;
+		},
+		retry: false,
+		...queryOptions
+	});
+	const items = query.data?.pages.flatMap((page) => page?.items ?? []) ?? [];
+	const total = query.data?.pages[0]?.pagination?.total;
+	useEffect(() => {
+		if (isEndOfListInView && query.hasNextPage && !query.isFetchingNextPage) query.fetchNextPage();
+	}, [isEndOfListInView, query]);
+	return {
+		...query,
+		data: items,
+		total,
+		setEndOfListElement
+	};
+};
+//#endregion
+//#region src/hooks/datasets/use-dataset-mutations.ts
+/**
+* Hook providing mutation functions for datasets, items, and runs
+* All mutations invalidate relevant query caches on success.
+* `queryOptions` is keyed by returned mutation name and spread last; a user `onSuccess` replaces the internal invalidation.
+*/
+const useDatasetMutations = ({ queryOptions } = {}) => {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	const createDataset = useMutation({
+		mutationFn: (params) => client.createDataset(params),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["datasets"] });
+		},
+		...queryOptions?.createDataset
+	});
+	const updateDataset = useMutation({
+		mutationFn: (params) => client.updateDataset(params),
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: ["datasets"] });
+			queryClient.invalidateQueries({ queryKey: ["dataset", variables.datasetId] });
+		},
+		...queryOptions?.updateDataset
+	});
+	const deleteDataset = useMutation({
+		mutationFn: (datasetId) => client.deleteDataset(datasetId),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: ["datasets"] });
+		},
+		...queryOptions?.deleteDataset
+	});
+	const addItem = useMutation({
+		mutationFn: (params) => client.addDatasetItem(params),
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: ["dataset-items", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: ["dataset", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: ["dataset-versions", variables.datasetId] });
+		},
+		...queryOptions?.addItem
+	});
+	const updateItem = useMutation({
+		mutationFn: (params) => client.updateDatasetItem(params),
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: ["dataset-items", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: [
+				"dataset-item",
+				variables.datasetId,
+				variables.itemId
+			] });
+			queryClient.invalidateQueries({ queryKey: [
+				"dataset-item-versions",
+				variables.datasetId,
+				variables.itemId
+			] });
+			queryClient.invalidateQueries({ queryKey: ["dataset-versions", variables.datasetId] });
+		},
+		...queryOptions?.updateItem
+	});
+	const deleteItem = useMutation({
+		mutationFn: ({ datasetId, itemId }) => client.deleteDatasetItem(datasetId, itemId),
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: ["dataset-items", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: ["dataset", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: ["dataset-versions", variables.datasetId] });
+		},
+		...queryOptions?.deleteItem
+	});
+	const purgeItem = useMutation({
+		mutationFn: ({ datasetId, itemId }) => client.purgeDatasetItem(datasetId, itemId),
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: ["dataset-items", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: [
+				"dataset-item",
+				variables.datasetId,
+				variables.itemId
+			] });
+			queryClient.invalidateQueries({ queryKey: [
+				"dataset-item-versions",
+				variables.datasetId,
+				variables.itemId
+			] });
+			queryClient.invalidateQueries({ queryKey: ["dataset-experiment-results"] });
+			queryClient.invalidateQueries({ queryKey: ["experiment-results"] });
+			queryClient.invalidateQueries({ queryKey: ["review-items"] });
+			queryClient.invalidateQueries({ queryKey: ["dataset-review-items"] });
+			queryClient.invalidateQueries({ queryKey: ["dataset-completed-items"] });
+			queryClient.invalidateQueries({ queryKey: ["experiment-review-summary"] });
+		},
+		...queryOptions?.purgeItem
+	});
+	const batchInsertItems = useMutation({
+		mutationFn: (params) => client.batchInsertDatasetItems(params),
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: ["dataset-items", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: ["dataset", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: ["dataset-versions", variables.datasetId] });
+		},
+		...queryOptions?.batchInsertItems
+	});
+	const batchDeleteItems = useMutation({
+		mutationFn: (params) => client.batchDeleteDatasetItems(params),
+		onSuccess: (_, variables) => {
+			queryClient.invalidateQueries({ queryKey: ["dataset-items", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: ["dataset", variables.datasetId] });
+			queryClient.invalidateQueries({ queryKey: ["dataset-versions", variables.datasetId] });
+		},
+		...queryOptions?.batchDeleteItems
+	});
+	return {
+		createDataset,
+		updateDataset,
+		deleteDataset,
+		addItem,
+		updateItem,
+		deleteItem,
+		purgeItem,
+		deleteItems: useMutation({
+			mutationFn: async ({ datasetId, itemIds }) => {
+				return client.batchDeleteDatasetItems({
+					datasetId,
+					itemIds
+				});
+			},
+			onSuccess: (_, variables) => {
+				queryClient.invalidateQueries({ queryKey: ["dataset-items", variables.datasetId] });
+				queryClient.invalidateQueries({ queryKey: ["dataset", variables.datasetId] });
+				queryClient.invalidateQueries({ queryKey: ["dataset-versions", variables.datasetId] });
+			},
+			...queryOptions?.deleteItems
+		}),
+		batchInsertItems,
+		batchDeleteItems,
+		triggerExperiment: useMutation({
+			mutationFn: (params) => client.triggerDatasetExperiment(params),
+			onSuccess: (_, variables) => {
+				queryClient.invalidateQueries({ queryKey: ["dataset-experiments", variables.datasetId] });
+			},
+			...queryOptions?.triggerExperiment
+		}),
+		deleteExperiment: useMutation({
+			mutationFn: (experimentId) => client.deleteExperiment(experimentId),
+			onSuccess: () => {
+				queryClient.invalidateQueries({ queryKey: ["experiments"] });
+				queryClient.invalidateQueries({ queryKey: ["dataset-experiments"] });
+				queryClient.invalidateQueries({ queryKey: ["dataset-experiment"] });
+				queryClient.invalidateQueries({ queryKey: ["dataset-experiment-results"] });
+				queryClient.invalidateQueries({ queryKey: ["review-items"] });
+				queryClient.invalidateQueries({ queryKey: ["completed-items"] });
+				queryClient.invalidateQueries({ queryKey: ["experiment-review-summary"] });
+			},
+			...queryOptions?.deleteExperiment
+		}),
+		updateExperiment: useMutation({
+			mutationFn: (params) => client.updateDatasetExperiment(params),
+			onSuccess: (_, variables) => {
+				queryClient.invalidateQueries({ queryKey: ["experiments"] });
+				queryClient.invalidateQueries({ queryKey: ["dataset-experiments", variables.datasetId] });
+				queryClient.invalidateQueries({ queryKey: [
+					"dataset-experiment",
+					variables.datasetId,
+					variables.experimentId
+				] });
+			},
+			...queryOptions?.updateExperiment
+		}),
+		updateExperimentResult: useMutation({
+			mutationFn: (params) => client.updateDatasetExperimentResult(params),
+			onSuccess: (_, variables) => {
+				queryClient.invalidateQueries({ queryKey: ["experiment-results", variables.experimentId] });
+				queryClient.invalidateQueries({ queryKey: ["dataset-experiment-results"] });
+				queryClient.invalidateQueries({ queryKey: ["review-items"] });
+				queryClient.invalidateQueries({ queryKey: ["dataset-review-items"] });
+				queryClient.invalidateQueries({ queryKey: ["dataset-completed-items"] });
+				queryClient.invalidateQueries({ queryKey: ["experiment-review-summary"] });
+			},
+			...queryOptions?.updateExperimentResult
+		})
+	};
+};
+//#endregion
+//#region src/hooks/datasets/use-datasets.ts
+/**
+* Hook to list all datasets with optional pagination
+*/
+const useDatasets = ({ pagination, queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["datasets", pagination],
+		queryFn: () => client.listDatasets(pagination),
+		placeholderData: (previousData) => previousData,
+		...queryOptions
+	});
+};
+const DATASETS_PER_PAGE = 20;
+/**
+* Hook to list datasets with infinite scroll pagination, optionally scoped server-side to a target.
+* `data` defaults to the flattened dataset list; a user `select` replaces that flattening.
+*/
+const useInfiniteDatasets = ({ filter, orderBy, queryOptions } = {}) => {
+	const client = useMastraClient();
+	const { inView: isEndOfListInView, setRef: setEndOfListElement } = useInView();
+	const targetType = filter?.targetType || void 0;
+	const targetIds = filter?.targetId ? [filter.targetId] : void 0;
+	const query = useInfiniteQuery({
+		queryKey: [
+			"datasets",
+			"infinite",
+			{
+				targetType,
+				targetIds,
+				orderBy
+			}
+		],
+		queryFn: ({ pageParam }) => client.listDatasets({
+			page: pageParam,
+			perPage: DATASETS_PER_PAGE,
+			targetType,
+			targetIds,
+			orderBy
+		}),
+		initialPageParam: 0,
+		getNextPageParam: (lastPage, _, lastPageParam) => {
+			if (!lastPage?.datasets?.length || !lastPage.pagination?.hasMore) return;
+			return lastPageParam + 1;
+		},
+		select: (data) => data.pages.flatMap((page) => page?.datasets ?? []),
+		...queryOptions
+	});
+	useEffect(() => {
+		if (isEndOfListInView && query.hasNextPage && !query.isFetchingNextPage) query.fetchNextPage();
+	}, [isEndOfListInView, query]);
+	return {
+		...query,
+		setEndOfListElement
+	};
+};
+/**
+* Hook to fetch a single dataset by ID
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useDataset = ({ datasetId, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["dataset", datasetId],
+		queryFn: () => client.getDataset(datasetId),
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/datasets/use-compare-experiments.ts
+/**
+* Hook to compare two dataset experiments for regression detection
+* @param datasetId - ID of the dataset
+* @param experimentIdA - ID of the first experiment (baseline)
+* @param experimentIdB - ID of the second experiment (comparison)
+* @param options - Optional thresholds for regression detection
+* @param queryOptions - TanStack Query options, spread last to override defaults
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useCompareExperiments = ({ datasetId, experimentIdA, experimentIdB, options, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"compare-experiments",
+			datasetId,
+			experimentIdA,
+			experimentIdB,
+			options
+		],
+		queryFn: () => client.compareExperiments({
+			datasetId,
+			experimentIdA,
+			experimentIdB,
+			...options
+		}),
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/datasets/use-dataset-experiments.ts
+/**
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useDatasetExperiment = ({ datasetId, experimentId, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"dataset-experiment",
+			datasetId,
+			experimentId
+		],
+		queryFn: () => client.getDatasetExperiment(datasetId, experimentId),
+		gcTime: 0,
+		staleTime: 0,
+		refetchInterval: (query) => {
+			const status = query.state.data?.status;
+			return status === "running" || status === "pending" ? 2e3 : false;
+		},
+		...queryOptions
+	});
+};
+const RESULTS_PER_PAGE = 100;
+/**
+* Hook to list results for a dataset experiment with infinite scroll pagination.
+* Polls every 2 seconds while experiment status is 'pending' or 'running'.
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useDatasetExperimentResults = ({ datasetId, experimentId, experimentStatus, orderBy, queryOptions }) => {
+	const client = useMastraClient();
+	const { inView: isEndOfListInView, setRef: setEndOfListElement } = useInView();
+	const query = useInfiniteQuery({
+		queryKey: [
+			"dataset-experiment-results",
+			datasetId,
+			experimentId,
+			experimentStatus,
+			orderBy
+		],
+		queryFn: async ({ pageParam }) => {
+			return client.listDatasetExperimentResults(datasetId, experimentId, {
+				page: pageParam,
+				perPage: RESULTS_PER_PAGE,
+				orderBy
+			});
+		},
+		initialPageParam: 0,
+		getNextPageParam: (lastPage, _, lastPageParam) => {
+			if (!lastPage?.results?.length) return;
+			if ((lastPageParam + 1) * RESULTS_PER_PAGE >= (lastPage?.pagination?.total ?? 0)) return;
+			return lastPageParam + 1;
+		},
+		refetchInterval: experimentStatus === "running" || experimentStatus === "pending" ? 2e3 : false,
+		select: (data) => {
+			return data.pages.flatMap((page) => page?.results ?? []);
+		},
+		...queryOptions
+	});
+	useEffect(() => {
+		if (isEndOfListInView && query.hasNextPage && !query.isFetchingNextPage) query.fetchNextPage();
+	}, [isEndOfListInView, query]);
+	return {
+		...query,
+		setEndOfListElement
+	};
+};
+/**
+* Hook to fetch all scores for an experiment, transformed to Record<entityId, ClientScoreRowData[]>
+* Paginates through all pages to ensure no scores are silently dropped.
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useScoresByExperimentId = ({ experimentId, experimentStatus, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"dataset-experiment-scores",
+			experimentId,
+			experimentStatus
+		],
+		queryFn: async () => {
+			const allScores = [];
+			let page = 0;
+			const perPage = 100;
+			while (true) {
+				const response = await client.listScoresByRunId({
+					runId: experimentId,
+					page,
+					perPage
+				});
+				allScores.push(...response.scores);
+				if (!response.pagination.hasMore) break;
+				page++;
+			}
+			const grouped = {};
+			for (const row of allScores) {
+				if (!grouped[row.entityId]) grouped[row.entityId] = [];
+				grouped[row.entityId].push(row);
+			}
+			return grouped;
+		},
+		refetchInterval: experimentStatus === "running" || experimentStatus === "pending" ? 2e3 : false,
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/datasets/use-dataset-item-versions.ts
+/**
+* Hook to fetch full item history (SCD-2 rows).
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useDatasetItemVersions = ({ datasetId, itemId, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"dataset-item-versions",
+			datasetId,
+			itemId
+		],
+		queryFn: async () => {
+			return ((await client.getItemHistory(datasetId, itemId))?.history ?? []).map((version, index) => ({
+				id: version.id,
+				datasetId: version.datasetId,
+				datasetVersion: version.datasetVersion,
+				input: version.input,
+				groundTruth: version.groundTruth,
+				expectedTrajectory: version.expectedTrajectory,
+				toolMocks: version.toolMocks ?? void 0,
+				scorerIds: version.scorerIds ?? void 0,
+				requestContext: version.requestContext ?? void 0,
+				metadata: version.metadata ?? void 0,
+				validTo: version.validTo,
+				isDeleted: version.isDeleted,
+				createdAt: version.createdAt,
+				updatedAt: version.updatedAt,
+				isLatest: index === 0
+			}));
+		},
+		...queryOptions
+	});
+};
+/**
+* Hook to fetch a specific version of a dataset item.
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useDatasetItemVersion = ({ datasetId, itemId, datasetVersion, latestVersion, queryOptions }) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: [
+			"dataset-item-version",
+			datasetId,
+			itemId,
+			datasetVersion
+		],
+		queryFn: async () => {
+			const v = await client.getDatasetItemVersion(datasetId, itemId, datasetVersion);
+			return {
+				id: v.id,
+				datasetId: v.datasetId,
+				datasetVersion: v.datasetVersion,
+				input: v.input,
+				groundTruth: v.groundTruth,
+				expectedTrajectory: v.expectedTrajectory,
+				toolMocks: v.toolMocks ?? void 0,
+				scorerIds: v.scorerIds ?? void 0,
+				requestContext: v.requestContext ?? void 0,
+				metadata: v.metadata ?? void 0,
+				validTo: null,
+				isDeleted: false,
+				createdAt: v.createdAt,
+				updatedAt: v.updatedAt,
+				isLatest: latestVersion != null ? datasetVersion === latestVersion : false
+			};
+		},
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/datasets/use-dataset-versions.ts
+const PER_PAGE = 10;
+/**
+* Hook to fetch dataset versions from the API with infinite pagination.
+* `data` defaults to the flattened `DatasetVersion[]`; a user `select` replaces that.
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+const useDatasetVersions = ({ datasetId, queryOptions }) => {
+	const client = useMastraClient();
+	return useInfiniteQuery({
+		queryKey: ["dataset-versions", datasetId],
+		queryFn: async ({ pageParam }) => {
+			return client.listDatasetVersions(datasetId, {
+				page: pageParam,
+				perPage: PER_PAGE
+			});
+		},
+		initialPageParam: 0,
+		getNextPageParam: (lastPage, _, lastPageParam) => {
+			if (lastPage?.pagination?.hasMore) return lastPageParam + 1;
+		},
+		select: (data) => {
+			return data.pages.flatMap((page) => page?.versions ?? []).map((v, index) => ({
+				id: v.id,
+				datasetId: v.datasetId,
+				version: v.version,
+				createdAt: v.createdAt,
+				isCurrent: index === 0
+			}));
+		},
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/datasets/use-experiments.ts
+/**
+* Hook to list all experiments across all datasets with optional pagination
+*/
+const useExperiments = ({ pagination, queryOptions } = {}) => {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["experiments", pagination],
+		queryFn: () => client.listExperiments(pagination),
+		...queryOptions
+	});
+};
+//#endregion
+//#region src/hooks/datasets/use-workflow-schema.ts
+/**
+* Hook to fetch workflow input/output schema by workflow ID.
+* Returns { inputSchema, outputSchema } where each is Record<string, unknown> | null.
+*
+* Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
+*/
+function useWorkflowSchema({ workflowId, queryOptions }) {
+	const client = useMastraClient();
+	return useQuery({
+		queryKey: ["workflow-schema", workflowId],
+		queryFn: async () => {
+			if (!workflowId) throw new Error("No workflow selected");
+			return client.getWorkflow(workflowId).getSchema();
+		},
+		staleTime: 300 * 1e3,
+		...queryOptions
+	});
+}
+//#endregion
+export { useCompareExperiments, useDataset, useDatasetExperiment, useDatasetExperimentResults, useDatasetItem, useDatasetItemVersion, useDatasetItemVersions, useDatasetItems, useDatasetMutations, useDatasetVersions, useDatasets, useExperiments, useInfiniteDatasets, useScoresByExperimentId, useWorkflowSchema };
+
+//# sourceMappingURL=index.js.map