formatting09-18-formatting

1 files changed, 47 insertions, 47 deletions

diff --git a/packages/lib/queries.ts b/packages/lib/queries.ts
index 3e9e1ab9..d0f93915 100644
--- a/packages/lib/queries.ts
+++ b/packages/lib/queries.ts
@@ -1,12 +1,12 @@
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
-import type { useCustomer } from "autumn-js/react"
-import { toast } from "sonner"
-import type { z } from "zod"
-import type { DocumentsWithMemoriesResponseSchema } from "../validation/api"
-import { $fetch } from "./api"
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import type { useCustomer } from "autumn-js/react";
+import { toast } from "sonner";
+import type { z } from "zod";
+import type { DocumentsWithMemoriesResponseSchema } from "../validation/api";
+import { $fetch } from "./api";
 
-type DocumentsResponse = z.infer<typeof DocumentsWithMemoriesResponseSchema>
-type DocumentWithMemories = DocumentsResponse["documents"][0]
+type DocumentsResponse = z.infer<typeof DocumentsWithMemoriesResponseSchema>;
+type DocumentWithMemories = DocumentsResponse["documents"][0];
 
 export const fetchSubscriptionStatus = (
 	autumn: ReturnType<typeof useCustomer>,
@@ -18,54 +18,54 @@ export const fetchSubscriptionStatus = (
 				"memory_starter",
 				"memory_growth",
 				"consumer_pro",
-			]
-			const statusMap: Record<string, boolean | null> = {}
+			];
+			const statusMap: Record<string, boolean | null> = {};
 
 			await Promise.all(
 				allPlans.map(async (plan) => {
 					try {
 						const res = await autumn.check({
 							productId: plan,
-						})
-						statusMap[plan] = res.data?.allowed ?? false
+						});
+						statusMap[plan] = res.data?.allowed ?? false;
 					} catch (error) {
-						console.error(`Error checking status for ${plan}:`, error)
-						statusMap[plan] = false
+						console.error(`Error checking status for ${plan}:`, error);
+						statusMap[plan] = false;
 					}
 				}),
-			)
+			);
 
-			return statusMap
+			return statusMap;
 		},
 		queryKey: ["subscription-status"],
 		refetchInterval: 5000, // Refetch every 5 seconds
 		staleTime: 4000, // Consider data stale after 4 seconds
-	})
+	});
 
 // Feature checks
 export const fetchMemoriesFeature = (autumn: ReturnType<typeof useCustomer>) =>
 	useQuery({
 		queryFn: async () => {
-			const res = await autumn.check({ featureId: "memories" })
-			return res.data
+			const res = await autumn.check({ featureId: "memories" });
+			return res.data;
 		},
 		queryKey: ["autumn-feature", "memories"],
 		staleTime: 30 * 1000, // 30 seconds
 		gcTime: 5 * 60 * 1000, // 5 minutes
-	})
+	});
 
 export const fetchConnectionsFeature = (
 	autumn: ReturnType<typeof useCustomer>,
 ) =>
 	useQuery({
 		queryFn: async () => {
-			const res = await autumn.check({ featureId: "connections" })
-			return res.data
+			const res = await autumn.check({ featureId: "connections" });
+			return res.data;
 		},
 		queryKey: ["autumn-feature", "connections"],
 		staleTime: 30 * 1000, // 30 seconds
 		gcTime: 5 * 60 * 1000, // 5 minutes
-	})
+	});
 
 // Product checks
 export const fetchConsumerProProduct = (
@@ -73,54 +73,54 @@ export const fetchConsumerProProduct = (
 ) =>
 	useQuery({
 		queryFn: async () => {
-			const res = await autumn.check({ productId: "consumer_pro" })
-			return res.data
+			const res = await autumn.check({ productId: "consumer_pro" });
+			return res.data;
 		},
 		queryKey: ["autumn-product", "consumer_pro"],
 		staleTime: 30 * 1000, // 30 seconds
 		gcTime: 5 * 60 * 1000, // 5 minutes
-	})
+	});
 
 export const fetchProProduct = (autumn: ReturnType<typeof useCustomer>) =>
 	useQuery({
 		queryFn: async () => {
-			const res = await autumn.check({ productId: "pro" })
-			return res.data
+			const res = await autumn.check({ productId: "pro" });
+			return res.data;
 		},
 		queryKey: ["autumn-product", "pro"],
 		staleTime: 30 * 1000, // 30 seconds
 		gcTime: 5 * 60 * 1000, // 5 minutes
-	})
+	});
 
 export const useDeleteDocument = (selectedProject: string) => {
-	const queryClient = useQueryClient()
+	const queryClient = useQueryClient();
 
 	return useMutation({
 		mutationFn: async (documentId: string) => {
 			// context for LLM: delete/memories/:documentId is documents delete endpoint not memories delete endpoint
-			const response = await $fetch(`@delete/documents/${documentId}`)
+			const response = await $fetch(`@delete/documents/${documentId}`);
 			if (response.error) {
-				throw new Error(response.error?.message || "Failed to delete document")
+				throw new Error(response.error?.message || "Failed to delete document");
 			}
-			return response.data
+			return response.data;
 		},
 		onMutate: async (documentId: string) => {
 			await queryClient.cancelQueries({
 				queryKey: ["documents-with-memories", selectedProject],
-			})
+			});
 
 			const previousData = queryClient.getQueryData([
 				"documents-with-memories",
 				selectedProject,
-			])
+			]);
 
 			queryClient.setQueryData(
 				["documents-with-memories", selectedProject],
 				(old: unknown) => {
-					if (!old || typeof old !== "object") return old
+					if (!old || typeof old !== "object") return old;
 					const typedOld = old as {
-						pages?: Array<{ documents?: DocumentWithMemories[] }>
-					}
+						pages?: Array<{ documents?: DocumentWithMemories[] }>;
+					};
 					return {
 						...typedOld,
 						pages: typedOld.pages?.map((page) => ({
@@ -129,30 +129,30 @@ export const useDeleteDocument = (selectedProject: string) => {
 								(doc: DocumentWithMemories) => doc.id !== documentId,
 							),
 						})),
-					}
+					};
 				},
-			)
+			);
 
-			return { previousData }
+			return { previousData };
 		},
 		onSuccess: () => {
-			toast.success("Memory deleted successfully")
+			toast.success("Memory deleted successfully");
 		},
 		onError: (error, _documentId, context) => {
 			if (context?.previousData) {
 				queryClient.setQueryData(
 					["documents-with-memories", selectedProject],
 					context.previousData,
-				)
+				);
 			}
 			toast.error("Failed to delete memory", {
 				description: error instanceof Error ? error.message : "Unknown error",
-			})
+			});
 		},
 		onSettled: () => {
 			queryClient.invalidateQueries({
 				queryKey: ["documents-with-memories", selectedProject],
-			})
+			});
 		},
-	})
-}
+	});
+};