@ram_28/kf-ai-sdk 1.0.7 → 1.0.9

package/sdk/components/hooks/useKanban/useKanban.ts

@@ -34,12 +34,11 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
     onCardUpdate,
     onCardDelete,
     onError,
-    onFilterError,
   } = options;
 
   // Use source or cardSource (backwards compatibility)
   const dataSource = source || cardSource;
-  
+
   if (!dataSource) {
     throw new Error('useKanban requires either "source" or "cardSource" parameter');
   }
@@ -89,11 +88,9 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
   // FILTER INTEGRATION
   // ============================================================
 
-  const filterHook = useFilter<T>({
+  const filter = useFilter({
     initialConditions: initialState?.filters,
-    initialLogicalOperator: initialState?.filterOperator || "And",
-    validateOnChange: true,
-    onValidationError: onFilterError,
+    initialOperator: initialState?.filterOperator || "And",
   });
 
   // Helper to generate API options for a specific column
@@ -107,7 +104,7 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
         RHSType: "Constant"
       };
 
-      const basePayload = filterHook.filterPayload;
+      const basePayload = filter.payload;
       let combinedPayload: any;
 
       if (!basePayload) {
@@ -154,9 +151,9 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
       if (search.query) {
         opts.Search = search.query;
       }
-      
+
       return opts;
-  }, [filterHook.filterPayload, columnPagination, sorting, search.query]);
+  }, [filter.payload, columnPagination, sorting, search.query]);
 
   // ============================================================
   // COLUMN QUERY GENERATION
@@ -188,21 +185,13 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
     await Promise.all(columnQueries.map(q => q.refetch()));
   };
 
-  // Get total card count (Global count, or sum of columns? Usually global might differ if filters applied)
-  // For simplicity, we can fetch global count but restricted by filters?
-  // Actually, standard Kanban usually doesn't show "Total Cards" unless it's per column.
-  // We will keep the global count query for now but it might be slightly inaccurate if we want "Total Visible".
-  // Let's rely on summing up column counts for "Total Visible" and keep this for "Total Database"?
-  // Or just query with base filters?
-  // Let's keep existing logic but apply ONLY base filters + search.
-  
   const cardApiOptions = useMemo((): ListOptions => {
       // This is for the GLOBAL count (ignoring column split)
       const opts: ListOptions = {};
       if (search.query) opts.Search = search.query;
-      if (filterHook.filterPayload) opts.Filter = filterHook.filterPayload;
+      if (filter.payload) opts.Filter = filter.payload;
       return opts;
-  }, [search.query, filterHook.filterPayload]);
+  }, [search.query, filter.payload]);
 
   const {
     data: countData,
@@ -230,11 +219,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
 
   const createCardMutation = useMutation({
     mutationFn: async (card: Partial<KanbanCard<T>> & { columnId: string }) => {
-      // We need to fetch the current count or max position to append correclty if not provided
-      // Simplification: just send position=999999 or let backend handle it?
-      // Since we want optimistic UI, we should calculate it.
-      // But calculating it from partial data (paginated) is risky.
-      // Let's rely on backend or default to top/bottom logic.
       const position = card.position ?? 999999;
       const response = await api<KanbanCard<T>>(dataSource).create({ ...card, position });
       return response._id;
@@ -249,7 +233,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
       const previousCards = queryClient.getQueryData<ListResponse<KanbanCard<T>>>(queryKey);
 
       if (previousCards) {
-         // Determine position
          const currentCards = previousCards.Data;
          const position = newCardVariables.position ?? currentCards.length;
 
@@ -271,7 +254,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
       return { previousCards, queryKey };
     },
     onSuccess: async (cardId, _variables, context) => {
-       // Refetch the specific column
        if (context?.queryKey) {
            await queryClient.invalidateQueries({ queryKey: context.queryKey });
        }
@@ -299,22 +281,10 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
       return { id, updates };
     },
     onMutate: async () => {
-      // We don't know the columnId easily without passing it.
-      // We can try to finding it in all column queries
-      // For now, simpler to just invalidate everything on success/error
-      // OR pass columnId in updates if available.
-      // If we want optimistic updates, we need to iterate all queries.
-      
-      // Strategy: Invalidate all columns. Optimistic update is hard without knowing columnId.
-      // If the user passes columnId in updates, we can optimize.
-      
       await queryClient.cancelQueries({ queryKey: ["kanban-cards", dataSource] });
       return {};
     },
     onSuccess: async (result) => {
-      // Find the card to trigger callback
-      // Since we don't have a single list, this is harder.
-      // We can skip finding it for now or iterate queries.
       onCardUpdateRef.current?.({ _id: result.id, ...result.updates } as any);
     },
     onError: (error, _variables, _context) => {
@@ -332,8 +302,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
     },
     onMutate: async () => {
       await queryClient.cancelQueries({ queryKey: ["kanban-cards", dataSource] });
-      // Optimistic delete: Iterate all column queries and remove?
-      // For now, simple invalidation
       return {};
     },
     onSuccess: async (id) => {
@@ -354,7 +322,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
       return { cardId, fromColumnId, toColumnId, position };
     },
     onMutate: async ({ cardId, fromColumnId, toColumnId, position }) => {
-       // Cancel queries for only the affected columns
        const fromOpts = getColumnApiOptions(fromColumnId);
        const toOpts = getColumnApiOptions(toColumnId);
        const fromQueryKey = ["kanban-cards", dataSource, fromColumnId, fromOpts];
@@ -363,23 +330,18 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
        await queryClient.cancelQueries({ queryKey: fromQueryKey });
        await queryClient.cancelQueries({ queryKey: toQueryKey });
 
-       // Get current data for both columns
        const previousFromData = queryClient.getQueryData<ListResponse<KanbanCard<T>>>(fromQueryKey);
        const previousToData = queryClient.getQueryData<ListResponse<KanbanCard<T>>>(toQueryKey);
 
-       // Optimistic update: move card between columns
        if (previousFromData && previousToData) {
-         // Find the card in the source column
          const cardToMove = previousFromData.Data.find(c => c._id === cardId);
 
          if (cardToMove) {
-           // Remove card from source column
            const newFromData = {
              ...previousFromData,
              Data: previousFromData.Data.filter(c => c._id !== cardId)
            };
 
-           // Add card to target column with updated columnId
            const movedCard = {
              ...cardToMove,
              columnId: toColumnId,
@@ -392,7 +354,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
              Data: [...previousToData.Data, movedCard].sort((a, b) => a.position - b.position)
            };
 
-           // Update cache optimistically
            queryClient.setQueryData(fromQueryKey, newFromData);
            queryClient.setQueryData(toQueryKey, newToData);
          }
@@ -415,7 +376,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
        );
     },
     onError: (error, _variables, context) => {
-      // Rollback optimistic update on error
       if (context?.previousFromData && context?.fromQueryKey) {
         queryClient.setQueryData(context.fromQueryKey, context.previousFromData);
       }
@@ -425,7 +385,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
       onErrorRef.current?.(error as Error);
     },
     onSettled: (_data, _error, variables) => {
-       // Invalidate queries to ensure sync with server
        const fromOpts = getColumnApiOptions(variables.fromColumnId);
        const toOpts = getColumnApiOptions(variables.toColumnId);
        queryClient.invalidateQueries({ queryKey: ["kanban-cards", dataSource, variables.fromColumnId, fromOpts] });
@@ -443,15 +402,12 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
       );
     },
     onMutate: async ({ columnId }) => {
-       // Optimistic reorder restricted to single column
        const opts = getColumnApiOptions(columnId);
        const queryKey = ["kanban-cards", dataSource, columnId, opts];
        await queryClient.cancelQueries({ queryKey });
-       // Can implement optimistic reorder here if we want to parse cardIds
-       // But simpler to just invalidate.
        return {};
     },
-    onSuccess: () => {}, 
+    onSuccess: () => {},
     onError: (error, _variables, _context) => {
       onErrorRef.current?.(error as Error);
     },
@@ -472,7 +428,7 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
           cardId: card._id,
           fromColumnId,
           toColumnId,
-          position: undefined, // Let the backend calculate optimal position
+          position: undefined,
         });
       } catch (error) {
         // Error already handled in mutation onError
@@ -482,11 +438,10 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
   );
 
   // ============================================================
-  // COMPUTED VALUES (Moved up for dependencies)
+  // COMPUTED VALUES
   // ============================================================
 
   const processedColumns = useMemo(() => {
-    // Map column configs to KanbanColumn structure using query results
     return columnConfigs
       .sort((a, b) => a.position - b.position)
       .map((config, index) => {
@@ -500,7 +455,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
           color: config.color,
           limit: config.limit,
           cards: cards.sort((a, b) => a.position - b.position),
-          // We can expose loading/error state per column here if needed in the future
            _created_at: new Date(),
            _modified_at: new Date(),
         };
@@ -530,9 +484,7 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
       "aria-grabbed": enableDragDrop && dragDropManager.draggedCard?._id === card._id,
       onDragStart: (e: any) => {
         if (!enableDragDrop) return;
-        // Abstracting the dataTransfer logic
         e.dataTransfer.setData("text/plain", JSON.stringify(card));
-        // Use native event if available (ShadCN/Radix sometimes wraps events) or fallback to e
         const nativeEvent = e.nativeEvent || e;
         dragDropManager.handleDragStart(nativeEvent, card);
       },
@@ -576,14 +528,6 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
     setSearch({ query: "" });
   }, []);
 
-
-
-  // ============================================================
-  // PROP GETTERS
-  // ============================================================
-
-
-
   const totalCards = countData?.Count || 0;
 
   const isLoading = isLoadingCards || isLoadingCount;
@@ -656,9 +600,7 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
     ),
     moveCard: useCallback(
       async (cardId: string, toColumnId: string, position?: number, fromColumnId?: string) => {
-        // If fromColumnId is not provided, we need to find it
         if (!fromColumnId) {
-          // Find the card in the columns to get its current columnId
           for (const column of processedColumns) {
             const card = column.cards.find(c => c._id === cardId);
             if (card) {
@@ -686,8 +628,8 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
     setSearchQuery,
     clearSearch,
 
-    // Filter (Nested - following useTable pattern)
-    filter: filterHook,
+    // Filter (Simplified chainable API)
+    filter,
 
     // Drag Drop (Flat Access)
     isDragging: enableDragDrop ? dragDropManager.isDragging : false,
@@ -700,13 +642,10 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
     handleDrop: enableDragDrop ? dragDropManager.handleDrop : () => {},
     handleDragEnd: enableDragDrop ? dragDropManager.handleDragEnd : () => {},
     handleKeyDown: enableDragDrop ? dragDropManager.handleKeyDown : () => {},
-    
-    // Prop Getters
+
     // Prop Getters
     getCardProps: enableDragDrop ? getCardProps : (_card: any) => ({} as any),
     getColumnProps: enableDragDrop ? getColumnProps : (_columnId: string) => ({} as any),
-    
-
 
     // Load More (Per Column)
     loadMore: useCallback((columnId: string) => {

package/sdk/components/hooks/useTable/types.ts

@@ -1,9 +1,5 @@
-import type { ListResponse, LogicalOperator } from "../../../types/common";
-import type {
-  FilterConditionWithId,
-  TypedFilterConditionInput,
-  ValidationError,
-} from "../useFilter";
+import type { ListResponse, ConditionGroupOperator } from "../../../types/common";
+import type { Condition, ConditionGroup, UseFilterReturn } from "../useFilter";
 
 // ============================================================
 // TYPE DEFINITIONS
@@ -36,23 +32,20 @@ export interface UseTableOptions<T> {
   /** Initial state */
   initialState?: {
     pagination?: {
-      pageNo: number; // 1-indexed page number
+      pageNo: number;
       pageSize: number;
     };
     sorting?: {
       field: keyof T;
       direction: "asc" | "desc";
     };
-    globalFilter?: string;
-    filters?: FilterConditionWithId[];
-    filterOperator?: LogicalOperator;
+    filters?: Array<Condition | ConditionGroup>;
+    filterOperator?: ConditionGroupOperator;
   };
   /** Error callback */
   onError?: (error: Error) => void;
   /** Success callback */
   onSuccess?: (data: T[]) => void;
-  /** Filter error callback */
-  onFilterError?: (errors: ValidationError[]) => void;
 }
 
 export interface UseTableReturn<T> {
@@ -83,54 +76,8 @@ export interface UseTableReturn<T> {
     set: (field: keyof T, direction: "asc" | "desc") => void;
   };
 
-  // Legacy Global Filtering (Flat Access)
-  globalFilter: {
-    value: string;
-    setValue: (value: string) => void;
-    clear: () => void;
-  };
-
-  // Advanced Filtering (Filter Conditions) - Type-safe: lhsField constrained to keyof T
-  filter: {
-    // State
-    conditions: FilterConditionWithId[];
-    logicalOperator: LogicalOperator;
-    isValid: boolean;
-    validationErrors: ValidationError[];
-    hasConditions: boolean;
-
-    // Condition Management (type-safe)
-    addCondition: (condition: TypedFilterConditionInput<T>) => string;
-    updateCondition: (
-      id: string,
-      updates: Partial<TypedFilterConditionInput<T>>
-    ) => boolean;
-    removeCondition: (id: string) => boolean;
-    clearConditions: () => void;
-    getCondition: (id: string) => FilterConditionWithId | undefined;
-
-    // Logical Operator
-    setLogicalOperator: (operator: LogicalOperator) => void;
-
-    // Bulk Operations
-    setConditions: (conditions: FilterConditionWithId[]) => void;
-    replaceCondition: (
-      id: string,
-      newCondition: TypedFilterConditionInput<T>
-    ) => boolean;
-
-    // Validation
-    validateCondition: (condition: Partial<FilterConditionWithId>) => any;
-    validateAllConditions: () => any;
-
-    // State Management
-    exportState: () => any;
-    importState: (state: any) => void;
-    resetToInitial: () => void;
-
-    // Utilities
-    getConditionCount: () => number;
-  };
+  // Filter (Simplified chainable API)
+  filter: UseFilterReturn;
 
   // Pagination (Flat Access)
   pagination: {

package/sdk/components/hooks/useTable/useTable.ts

@@ -18,44 +18,11 @@ interface SortingState<T> {
   direction: "asc" | "desc" | null;
 }
 
-interface FilteringState {
-  global: string;
-}
-
 interface PaginationState {
   pageNo: number; // 1-indexed page number
   pageSize: number;
 }
 
-// ============================================================
-// FIELD TYPE DETECTION
-// ============================================================
-
-/**
- * Detect field type for auto-formatting
- * This will be enhanced with actual type introspection in the future
- * Currently unused but kept for future auto-formatting implementation
- */
-// function _detectFieldType<T>(fieldId: keyof T): string {
-//   const fieldName = String(fieldId);
-//
-//   // Basic pattern matching - will be replaced with actual type introspection
-//   if (fieldName.includes('price') || fieldName.includes('cost') || fieldName.includes('amount')) {
-//     return 'currency';
-//   }
-//   if (fieldName.includes('date') || fieldName.includes('At') || fieldName === 'created' || fieldName === 'updated') {
-//     return 'datetime';
-//   }
-//   if (fieldName.includes('stock') || fieldName.includes('quantity') || fieldName.includes('count')) {
-//     return 'number';
-//   }
-//   if (fieldName.includes('status') || fieldName.includes('type') || fieldName.includes('category')) {
-//     return 'string';
-//   }
-//
-//   return 'string'; // default
-// }
-
 // ============================================================
 // MAIN HOOK
 // ============================================================
@@ -76,12 +43,8 @@ export function useTable<T = any>(
     direction: options.initialState?.sorting?.direction || null,
   });
 
-  const [filtering, setFiltering] = useState<FilteringState>({
-    global: options.initialState?.globalFilter || "",
-  });
-
   const [pagination, setPagination] = useState<PaginationState>({
-    pageNo: options.initialState?.pagination?.pageNo || 1, // Start at page 1
+    pageNo: options.initialState?.pagination?.pageNo || 1,
     pageSize: options.initialState?.pagination?.pageSize || 10,
   });
 
@@ -89,23 +52,9 @@ export function useTable<T = any>(
   // FILTER HOOK INTEGRATION
   // ============================================================
 
-  const filterHook = useFilter<T>({
+  const filter = useFilter({
     initialConditions: options.initialState?.filters,
-    initialLogicalOperator: options.initialState?.filterOperator || "And",
-    validateOnChange: true,
-    onValidationError: options.onFilterError,
-    onConditionAdd: () => {
-      // Reset to first page when adding filters
-      setPagination((prev) => ({ ...prev, pageNo: 1 }));
-    },
-    onConditionUpdate: () => {
-      // Reset to first page when updating filters
-      setPagination((prev) => ({ ...prev, pageNo: 1 }));
-    },
-    onConditionRemove: () => {
-      // Reset to first page when removing filters
-      setPagination((prev) => ({ ...prev, pageNo: 1 }));
-    },
+    initialOperator: options.initialState?.filterOperator || "And",
   });
 
   // ============================================================
@@ -122,12 +71,12 @@ export function useTable<T = any>(
     }
 
     // Add filter conditions (affects count)
-    if (filterHook.filterPayload) {
-      opts.Filter = filterHook.filterPayload;
+    if (filter.payload) {
+      opts.Filter = filter.payload;
     }
 
     return opts;
-  }, [search.query, filterHook.filterPayload]);
+  }, [search.query, filter.payload]);
 
   // Options for list query - includes all options
   const apiOptions = useMemo((): ListOptions => {
@@ -144,7 +93,7 @@ export function useTable<T = any>(
 
     // Add pagination
     if (options.enablePagination) {
-      opts.Page = pagination.pageNo; // Already 1-indexed
+      opts.Page = pagination.pageNo;
       opts.PageSize = pagination.pageSize;
     }
 
@@ -181,7 +130,7 @@ export function useTable<T = any>(
     gcTime: 0,
   });
 
-  // Count query for accurate total items (only depends on filters/search, not sorting/pagination)
+  // Count query for accurate total items
   const {
     data: countData,
     isLoading: isCountLoading,
@@ -222,14 +171,12 @@ export function useTable<T = any>(
   const toggleSort = useCallback((field: keyof T) => {
     setSorting((prev) => {
       if (prev.field === field) {
-        // Same field - toggle direction or clear
         if (prev.direction === "asc") {
           return { field, direction: "desc" };
         } else if (prev.direction === "desc") {
           return { field: null, direction: null };
         }
       }
-      // New field or no current sort
       return { field, direction: "asc" };
     });
   }, []);
@@ -251,7 +198,6 @@ export function useTable<T = any>(
 
   const setSearchQuery = useCallback((value: string) => {
     setSearch({ query: value });
-    // Reset to first page when searching
     setPagination((prev) => ({ ...prev, pageNo: 1 }));
   }, []);
 
@@ -259,20 +205,6 @@ export function useTable<T = any>(
     setSearch({ query: "" });
   }, []);
 
-  // ============================================================
-  // FILTERING OPERATIONS
-  // ============================================================
-
-  const setGlobalFilter = useCallback((value: string) => {
-    setFiltering((prev) => ({ ...prev, global: value }));
-    // Reset to first page when filtering
-    setPagination((prev) => ({ ...prev, pageNo: 1 }));
-  }, []);
-
-  const clearFilter = useCallback(() => {
-    setFiltering({ global: "" });
-  }, []);
-
   // ============================================================
   // PAGINATION OPERATIONS
   // ============================================================
@@ -294,7 +226,7 @@ export function useTable<T = any>(
 
   const goToPage = useCallback(
     (page: number) => {
-      const pageNo = Math.max(1, Math.min(page, totalPages)); // Clamp between 1 and totalPages
+      const pageNo = Math.max(1, Math.min(page, totalPages));
       setPagination((prev) => ({ ...prev, pageNo }));
     },
     [totalPages]
@@ -304,7 +236,7 @@ export function useTable<T = any>(
     setPagination((prev) => ({
       ...prev,
       pageSize: size,
-      pageNo: 1, // Reset to first page
+      pageNo: 1,
     }));
   }, []);
 
@@ -349,52 +281,12 @@ export function useTable<T = any>(
       set: setSort,
     },
 
-    // Legacy Global Filtering (Flat Access)
-    globalFilter: {
-      value: filtering.global,
-      setValue: setGlobalFilter,
-      clear: clearFilter,
-    },
-
-    // Advanced Filtering (Filter Conditions)
-    filter: {
-      // State
-      conditions: filterHook.conditions,
-      logicalOperator: filterHook.logicalOperator,
-      isValid: filterHook.isValid,
-      validationErrors: filterHook.validationErrors,
-      hasConditions: filterHook.hasConditions,
-
-      // Condition Management
-      addCondition: filterHook.addCondition,
-      updateCondition: filterHook.updateCondition,
-      removeCondition: filterHook.removeCondition,
-      clearConditions: filterHook.clearConditions,
-      getCondition: filterHook.getCondition,
-
-      // Logical Operator
-      setLogicalOperator: filterHook.setLogicalOperator,
-
-      // Bulk Operations
-      setConditions: filterHook.setConditions,
-      replaceCondition: filterHook.replaceCondition,
-
-      // Validation
-      validateCondition: filterHook.validateCondition,
-      validateAllConditions: filterHook.validateAllConditions,
-
-      // State Management
-      exportState: filterHook.exportState,
-      importState: filterHook.importState,
-      resetToInitial: filterHook.resetToInitial,
-
-      // Utilities
-      getConditionCount: filterHook.getConditionCount,
-    },
+    // Filter (Simplified chainable API)
+    filter,
 
     // Pagination (Flat Access)
     pagination: {
-      currentPage: pagination.pageNo, // Already 1-indexed
+      currentPage: pagination.pageNo,
       pageSize: pagination.pageSize,
       totalPages,
       totalItems,