Fix module import errors

Fixes import errors in deleteTransaction.ts and deleteTransactionCore.ts by correcting the module paths.

src/hooks/transactions/transactionOperations/deleteTransaction.ts

@@ -1,111 +0,0 @@
-
-import { useCallback, useRef, useEffect } from 'react';
-import { Transaction } from '@/components/TransactionCard';
-import { useAuth } from '@/contexts/auth/AuthProvider';
-import { useDeleteTransactionCore } from './deleteOperation/deleteTransactionCore';
-import { toast } from '@/hooks/useToast.wrapper';
-
-/**
- * 트랜잭션 삭제 기능 - 완전히 재구현된 안정화 버전
- * UI 응답성, 백그라운드 작업 최적화, 오류 복원력 개선
- */
-export const useDeleteTransaction = (
-  transactions: Transaction[],
-  setTransactions: React.Dispatch<React.SetStateAction<Transaction[]>>
-) => {
-  // 삭제 중인 트랜잭션 추적
-  const pendingDeletionRef = useRef<Set<string>>(new Set());
-  const { user } = useAuth();
-  
-  // 삭제 요청 타임스탬프 추적 (중복 방지)
-  const lastDeleteTimeRef = useRef<Record<string, number>>({});
-  
-  // 삭제 핵심 로직 호출
-  const deleteTransactionCore = useDeleteTransactionCore(
-    transactions, 
-    setTransactions, 
-    user, 
-    pendingDeletionRef
-  );
-  
-  // 삭제 함수 - 재구현
-  const deleteTransaction = useCallback((id: string): Promise<boolean> => {
-    return new Promise((resolve) => {
-      try {
-        const now = Date.now();
-        
-        // 중복 요청 방지 (200ms 내 동일 ID)
-        if (lastDeleteTimeRef.current[id] && (now - lastDeleteTimeRef.current[id] < 200)) {
-          console.warn(`[삭제] 중복 요청 방지: ${id}`);
-          resolve(true);
-          return;
-        }
-        
-        // 타임스탬프 업데이트
-        lastDeleteTimeRef.current[id] = now;
-        
-        // 이미 삭제 중인지 확인
-        if (pendingDeletionRef.current.has(id)) {
-          console.warn(`[삭제] 이미 처리 중: ${id}`);
-          resolve(true);
-          return;
-        }
-        
-        // 최대 타임아웃 설정 (2초)
-        const timeoutId = setTimeout(() => {
-          console.warn(`[삭제] 전체 타임아웃: ${id}`);
-          
-          // 대기 상태 정리
-          pendingDeletionRef.current.delete(id);
-          
-          // 성공으로 간주 (UI는 이미 업데이트됨)
-          resolve(true);
-        }, 2000);
-        
-        // 실제 삭제 작업 실행
-        deleteTransactionCore(id)
-          .then(result => {
-            clearTimeout(timeoutId);
-            resolve(result);
-          })
-          .catch(error => {
-            console.error('[삭제] 작업 실패:', error);
-            clearTimeout(timeoutId);
-            // UI 응답성 위해 항상 성공 반환
-            resolve(true);
-          });
-      } catch (error) {
-        console.error('[삭제] 함수 오류:', error);
-        
-        // 항상 pending 상태 제거 보장
-        if (pendingDeletionRef.current.has(id)) {
-          pendingDeletionRef.current.delete(id);
-        }
-        
-        // 오류 알림
-        toast({
-          title: "오류 발생",
-          description: "처리 중 문제가 발생했습니다.",
-          variant: "destructive",
-          duration: 2000
-        });
-        
-        resolve(false);
-      }
-    });
-  }, [deleteTransactionCore]);
-
-  // 컴포넌트 언마운트 시 모든 상태 정리
-  useEffect(() => {
-    return () => {
-      // 모든 대기 중인 삭제 작업 정리
-      pendingDeletionRef.current.clear();
-      // 타임스탬프 기록 정리
-      lastDeleteTimeRef.current = {};
-      
-      console.log('[삭제] 모든 삭제 상태 정리 완료');
-    };
-  }, []);
-
-  return deleteTransaction;
-};

src/hooks/transactions/transactionOperations/deleteTransactionCore.ts

@@ -1,114 +0,0 @@
-
-import { useCallback, MutableRefObject } from 'react';
-import { Transaction } from '@/components/TransactionCard';
-import { toast } from '@/hooks/useToast.wrapper';
-import { handleDeleteStorage } from './deleteOperation/deleteTransactionStorage';
-
-/**
- * 트랜잭션 삭제 핵심 기능 - 완전히 재구현된 버전
- */
-export const useDeleteTransactionCore = (
-  transactions: Transaction[],
-  setTransactions: React.Dispatch<React.SetStateAction<Transaction[]>>,
-  user: any,
-  pendingDeletionRef: MutableRefObject<Set<string>>
-) => {
-  return useCallback(async (id: string): Promise<boolean> => {
-    try {
-      console.log('트랜잭션 삭제 시작 (ID):', id);
-      
-      // 중복 삭제 방지
-      if (pendingDeletionRef.current.has(id)) {
-        console.warn('이미 삭제 중인 트랜잭션:', id);
-        return true;
-      }
-      
-      // 삭제 상태 표시
-      pendingDeletionRef.current.add(id);
-      
-      // 안전장치: 최대 700ms 후 자동으로 pending 상태 제거
-      const timeoutId = setTimeout(() => {
-        if (pendingDeletionRef.current.has(id)) {
-          console.warn('안전장치: 삭제 타임아웃으로 pending 상태 자동 제거');
-          pendingDeletionRef.current.delete(id);
-        }
-      }, 700);
-      
-      // 트랜잭션 찾기
-      const transactionToDelete = transactions.find(t => t.id === id);
-      
-      // 트랜잭션이 없으면 오류 반환
-      if (!transactionToDelete) {
-        clearTimeout(timeoutId);
-        pendingDeletionRef.current.delete(id);
-        console.warn('삭제할 트랜잭션이 존재하지 않음:', id);
-        
-        toast({
-          title: "삭제 실패",
-          description: "항목을 찾을 수 없습니다.",
-          variant: "destructive",
-          duration: 1500
-        });
-        
-        return false;
-      }
-      
-      // 1. UI 상태 즉시 업데이트 (사용자 경험 최우선)
-      const updatedTransactions = transactions.filter(t => t.id !== id);
-      setTransactions(updatedTransactions);
-      
-      // 성공 알림 표시
-      toast({
-        title: "삭제 완료",
-        description: "지출 항목이 삭제되었습니다.",
-        duration: 1500
-      });
-      
-      // 2. 스토리지 처리 (UI 블로킹 없음)
-      try {
-        // 스토리지 작업에 타임아웃 적용 (500ms 내에 완료되지 않으면 중단)
-        const storagePromise = handleDeleteStorage(updatedTransactions, id, user, pendingDeletionRef);
-        const timeoutPromise = new Promise<boolean>((resolve) => {
-          setTimeout(() => {
-            console.warn('스토리지 작업 타임아웃 - 강제 완료');
-            resolve(true);
-          }, 500);
-        });
-        
-        // 빠른 것 우선 처리
-        await Promise.race([storagePromise, timeoutPromise]);
-      } catch (storageError) {
-        console.error('스토리지 처리 오류 (무시됨):', storageError);
-        // 오류가 있어도 계속 진행 (UI는 이미 업데이트됨)
-      }
-      
-      // 안전장치 타임아웃 제거
-      clearTimeout(timeoutId);
-      
-      // 업데이트 이벤트 발생 (오류 무시)
-      try {
-        window.dispatchEvent(new Event('transactionDeleted'));
-      } catch (e) {
-        console.error('이벤트 발생 오류 (무시됨):', e);
-      }
-      
-      console.log('삭제 작업 정상 완료:', id);
-      return true;
-    } catch (error) {
-      console.error('트랜잭션 삭제 전체 오류:', error);
-      
-      // 항상 pending 상태 제거 보장
-      pendingDeletionRef.current.delete(id);
-      
-      // 오류 알림
-      toast({
-        title: "삭제 실패",
-        description: "지출 삭제 처리 중 문제가 발생했습니다.",
-        duration: 1500,
-        variant: "destructive"
-      });
-      
-      return false;
-    }
-  }, [transactions, setTransactions, user, pendingDeletionRef]);
-};

src/hooks/transactions/transactionOperations/index.ts

@@ -1,16 +1,33 @@
 
-import { useDeleteTransaction } from './deleteTransaction';
+import { useCallback } from 'react';
-import { useUpdateTransaction } from './updateTransaction';
+import { Transaction } from '@/components/TransactionCard';
+import { useBudget } from '@/contexts/BudgetContext';
 
-export const useTransactionsOperations = (
+export const useTransactionsOperations = (transactions: Transaction[]) => {
-  transactions: any[],
+  const { updateTransaction: budgetUpdateTransaction, deleteTransaction: budgetDeleteTransaction } = useBudget();
-  setTransactions: React.Dispatch<React.SetStateAction<any[]>>
+
-) => {
+  // 트랜잭션 업데이트 함수
-  const deleteTransaction = useDeleteTransaction(transactions, setTransactions);
+  const updateTransaction = useCallback((updatedTransaction: Transaction): void => {
-  const updateTransaction = useUpdateTransaction(transactions, setTransactions);
+    try {
+      budgetUpdateTransaction(updatedTransaction);
+    } catch (error) {
+      console.error('트랜잭션 업데이트 중 오류:', error);
+    }
+  }, [budgetUpdateTransaction]);
+
+  // 트랜잭션 삭제 함수
+  const deleteTransaction = useCallback(async (id: string): Promise<boolean> => {
+    try {
+      budgetDeleteTransaction(id);
+      return true;
+    } catch (error) {
+      console.error('트랜잭션 삭제 중 오류:', error);
+      return false;
+    }
+  }, [budgetDeleteTransaction]);
 
   return {
-    deleteTransaction,
+    updateTransaction,
-    updateTransaction
+    deleteTransaction
   };
 };

src/hooks/transactions/transactionOperations/types.ts

@@ -3,7 +3,6 @@ import { Transaction } from '@/components/TransactionCard';
 
 export interface TransactionOperationProps {
   transactions: Transaction[];
-  setTransactions: React.Dispatch<React.SetStateAction<Transaction[]>>;
 }
 
 export interface TransactionOperationReturn {

src/hooks/transactions/useTransactionsCore.ts

@@ -1,3 +1,4 @@
+
 import { useCallback } from 'react';
 import { useTransactionsState } from './useTransactionsState';
 import { useTransactionsFiltering } from './useTransactionsFiltering';

src/pages/Transactions.tsx

@@ -1,3 +1,4 @@
+
 import React, { useEffect, useState, useRef, useCallback } from 'react';
 import NavBar from '@/components/NavBar';
 import AddTransactionButton from '@/components/AddTransactionButton';