@ram_28/kf-ai-sdk 1.0.5 → 1.0.8

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

@@ -17,7 +17,6 @@ export type {
   // Operations
   CardOperations,
   SearchOperations,
-  FilterOperations,
 
   // Drag & Drop
   DragDropState,

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

@@ -4,12 +4,8 @@
 // Core TypeScript interfaces for the kanban board functionality
 // Following patterns from useTable and useForm
 
-import type {
-  FilterConditionWithId,
-  ValidationError,
-  FieldDefinition,
-} from "../useFilter";
-import type { LogicalOperator } from "../../../types/common";
+import type { Condition, ConditionGroup, UseFilterReturn } from "../useFilter";
+import type { ConditionGroupOperator } from "../../../types/common";
 
 // ============================================================
 // CORE DATA STRUCTURES
@@ -199,15 +195,12 @@ export interface UseKanbanOptions<T> {
   /** Enable search functionality */
   enableSearch?: boolean;
 
-  /** Field definitions for card validation */
-  cardFieldDefinitions?: Record<keyof T, FieldDefinition>;
-
   /** Initial state */
   initialState?: {
     /** Initial filter conditions */
-    filters?: FilterConditionWithId[];
-    /** Initial filter operator */
-    filterOperator?: LogicalOperator;
+    filters?: Array<Condition | ConditionGroup>;
+    /** Initial filter operator for combining filter conditions */
+    filterOperator?: ConditionGroupOperator;
     /** Initial search query */
     search?: string;
     /** Initial column order */
@@ -230,7 +223,6 @@ export interface UseKanbanOptions<T> {
   onCardDelete?: (cardId: string) => void;
   onSuccess?: (data: any) => void;
   onError?: (error: Error) => void;
-  onFilterError?: (errors: ValidationError[]) => void;
 }
 
 // ============================================================
@@ -272,60 +264,6 @@ export interface SearchOperations {
   clear: () => void;
 }
 
-/**
- * Filter functionality interface (reusing from useFilter)
- */
-export interface FilterOperations {
-  /** Current filter conditions */
-  conditions: FilterConditionWithId[];
-  /** Logical operator for combining conditions */
-  logicalOperator: LogicalOperator;
-  /** Whether all conditions are valid */
-  isValid: boolean;
-  /** Current validation errors */
-  validationErrors: ValidationError[];
-  /** Whether there are any conditions */
-  hasConditions: boolean;
-
-  /** Add a new filter condition */
-  addCondition: (
-    condition: Omit<FilterConditionWithId, "id" | "isValid">
-  ) => string;
-  /** Update an existing condition */
-  updateCondition: (
-    id: string,
-    updates: Partial<FilterConditionWithId>
-  ) => boolean;
-  /** Remove a condition */
-  removeCondition: (id: string) => boolean;
-  /** Clear all conditions */
-  clearConditions: () => void;
-  /** Get a specific condition */
-  getCondition: (id: string) => FilterConditionWithId | undefined;
-
-  /** Set logical operator */
-  setLogicalOperator: (operator: LogicalOperator) => void;
-
-  /** Bulk operations */
-  setConditions: (conditions: FilterConditionWithId[]) => void;
-  replaceCondition: (
-    id: string,
-    newCondition: Omit<FilterConditionWithId, "id" | "isValid">
-  ) => boolean;
-
-  /** Validation */
-  validateCondition: (condition: Partial<FilterConditionWithId>) => any;
-  validateAllConditions: () => any;
-
-  /** State management */
-  exportState: () => any;
-  importState: (state: any) => void;
-  resetToInitial: () => void;
-
-  /** Utilities */
-  getConditionCount: () => number;
-}
-
 /**
  * Main return interface for useKanban hook
  * Follows useTable pattern with flat access
@@ -392,11 +330,11 @@ export interface UseKanbanReturn<T> {
   clearSearch: () => void;
 
   // ============================================================
-  // FILTER (Nested - following useTable pattern)
+  // FILTER (Simplified chainable API)
   // ============================================================
 
   /** Filter functionality */
-  filter: FilterOperations;
+  filter: UseFilterReturn;
 
   // ============================================================
   // DRAG DROP (Flat Access)
@@ -491,7 +429,7 @@ export interface MoveCardRequest {
  */
 export interface ReorderRequest {
   itemIds: string[];
-  containerId?: string; // for cards, this would be columnId
+  containerId?: string;
 }
 
 /**
@@ -537,7 +475,6 @@ export interface CardValidationContext<T> {
   card: Partial<KanbanCard<T>>;
   column?: KanbanColumn<T>;
   allColumns: KanbanColumn<T>[];
-  fieldDefinitions?: Record<keyof T, FieldDefinition>;
 }
 
 /**

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

@@ -28,19 +28,17 @@ export function useKanban<T extends Record<string, any> = Record<string, any>>(
     cardSource,
     source,
     enableDragDrop = true,
-    cardFieldDefinitions,
     initialState,
     onCardMove,
     onCardCreate,
     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');
   }
@@ -90,12 +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",
-    fieldDefinitions: cardFieldDefinitions,
-    validateOnChange: true,
-    onValidationError: onFilterError,
+    initialOperator: initialState?.filterOperator || "And",
   });
 
   // Helper to generate API options for a specific column
@@ -109,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) {
@@ -156,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
@@ -190,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,
@@ -232,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;
@@ -251,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;
 
@@ -273,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 });
        }
@@ -301,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) => {
@@ -334,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) => {
@@ -356,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];
@@ -365,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,
@@ -394,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);
          }
@@ -417,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);
       }
@@ -427,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] });
@@ -445,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);
     },
@@ -474,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
@@ -484,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) => {
@@ -502,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(),
         };
@@ -532,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);
       },
@@ -578,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;
@@ -658,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) {
@@ -688,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,
@@ -702,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,10 +1,5 @@
-import type { ListResponse, LogicalOperator } from "../../../types/common";
-import type {
-  FilterConditionWithId,
-  TypedFilterConditionInput,
-  ValidationError,
-  FieldDefinition,
-} from "../useFilter";
+import type { ListResponse, ConditionGroupOperator } from "../../../types/common";
+import type { Condition, ConditionGroup, UseFilterReturn } from "../useFilter";
 
 // ============================================================
 // TYPE DEFINITIONS
@@ -34,28 +29,23 @@ export interface UseTableOptions<T> {
   enableFiltering?: boolean;
   /** Enable pagination */
   enablePagination?: boolean;
-  /** Field definitions for filter validation */
-  fieldDefinitions?: Record<keyof T, FieldDefinition>;
   /** 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> {
@@ -86,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: {