suparisma 1.0.3 → 1.0.5

package/README.md

@@ -21,6 +21,8 @@ A powerful, typesafe React hook generator for Supabase, driven by your Prisma sc
   - [Basic CRUD Operations](#basic-crud-operations)
   - [Realtime Updates](#realtime-updates)
   - [Filtering Data](#filtering-data)
+  - [⚠️ IMPORTANT: Using Dynamic Filters with React](#️-important-using-dynamic-filters-with-react)
+  - [Array Filtering](#array-filtering)
   - [Sorting Data](#sorting-data)
   - [Pagination](#pagination)
   - [Search Functionality](#search-functionality)
@@ -58,7 +60,7 @@ Suparisma bridges this gap by:
 - 🚀 **Auto-generated React hooks** based on your Prisma schema
 - 🔄 **Real-time updates by default** for all tables (with opt-out capability)
 - 🔒 **Type-safe interfaces** for all database operations
-- 🔍 **Full-text search** with configurable annotations
+- 🔍 **Full-text search** with configurable annotations *(currently under maintenance)*
 - 🔢 **Pagination and sorting** built into every hook
 - 🧩 **Prisma-like API** that feels familiar if you already use Prisma
 - 📱 **Works with any React framework** including Next.js, Remix, etc.
@@ -303,6 +305,281 @@ const { data } = useSuparisma.thing({
 });
 ```
 
+### ⚠️ IMPORTANT: Using Dynamic Filters with React
+
+**You MUST use `useMemo` for dynamic where filters to prevent constant re-subscriptions!**
+
+When creating `where` filters based on state variables, React will create a new object reference on every render, causing the realtime subscription to restart constantly and **breaking realtime updates**.
+
+❌ **WRONG - This breaks realtime:**
+```tsx
+function MyComponent() {
+  const [filter, setFilter] = useState("active");
+  
+  const { data } = useSuparisma.thing({
+    where: filter ? { status: filter } : undefined // ❌ New object every render!
+  });
+}
+```
+
+✅ **CORRECT - Use useMemo:**
+```tsx
+import { useMemo } from 'react';
+
+function MyComponent() {
+  const [filter, setFilter] = useState("active");
+  const [arrayFilter, setArrayFilter] = useState(["item1"]);
+  
+  // Create stable object reference that only changes when dependencies change
+  const whereFilter = useMemo(() => {
+    if (filter) {
+      return { status: filter };
+    }
+    return undefined;
+  }, [filter]); // Only recreate when filter actually changes
+  
+  const { data } = useSuparisma.thing({
+    where: whereFilter // ✅ Stable reference!
+  });
+}
+```
+
+✅ **Complex example with multiple filters:**
+```tsx
+const whereFilter = useMemo(() => {
+  if (arrayFilterValue && arrayOperator) {
+    return {
+      tags: arrayOperator === 'has' 
+        ? { has: [arrayFilterValue] }
+        : arrayOperator === 'hasEvery'
+        ? { hasEvery: ["required", "tag", arrayFilterValue] }
+        : { isEmpty: false }
+    };
+  } else if (statusFilter) {
+    return { status: statusFilter };
+  }
+  return undefined;
+}, [arrayFilterValue, arrayOperator, statusFilter]); // Dependencies
+
+const { data } = useSuparisma.thing({ where: whereFilter });
+```
+
+**Why this matters:**
+- Without `useMemo`, the subscription restarts on EVERY render
+- This causes realtime events to be lost during reconnection
+- You'll see constant "Unsubscribing/Subscribing" messages in the console
+- Realtime updates will appear to be broken
+
+**The same applies to `orderBy` if it's dynamic:**
+```tsx
+const orderByConfig = useMemo(() => ({
+  [sortField]: sortDirection
+}), [sortField, sortDirection]);
+
+const { data } = useSuparisma.thing({ 
+  where: whereFilter,
+  orderBy: orderByConfig
+});
+```
+
+### Array Filtering
+
+Suparisma provides powerful operators for filtering array fields (e.g., `String[]`, `Int[]`, etc.):
+
+```prisma
+model Post {
+  id       String   @id @default(uuid())
+  title    String
+  tags     String[] // Array field
+  ratings  Int[]    // Array field
+  // ... other fields
+}
+```
+
+#### Array Operators
+
+| Operator | Description | Example Usage |
+|----------|-------------|---------------|
+| `has` | Array contains **ANY** of the specified items | `tags: { has: ["react", "typescript"] }` |
+| `hasSome` | Array contains **ANY** of the specified items (alias for `has`) | `tags: { hasSome: ["react", "vue"] }` |
+| `hasEvery` | Array contains **ALL** of the specified items | `tags: { hasEvery: ["react", "typescript"] }` |
+| `isEmpty` | Array is empty or not empty | `tags: { isEmpty: false }` |
+
+#### Array Filtering Examples
+
+```tsx
+// Find posts that have ANY of these tags
+const { data: reactOrVuePosts } = useSuparisma.post({
+  where: {
+    tags: { has: ["react", "vue", "angular"] }
+  }
+});
+// Returns posts with tags like: ["react"], ["vue"], ["react", "typescript"], etc.
+
+// Find posts that have ALL of these tags
+const { data: fullStackPosts } = useSuparisma.post({
+  where: {
+    tags: { hasEvery: ["react", "typescript", "nodejs"] }
+  }
+});
+// Returns posts that contain all three tags (and possibly more)
+
+// Find posts with any of these ratings
+const { data: highRatedPosts } = useSuparisma.post({
+  where: {
+    ratings: { hasSome: [4, 5] }
+  }
+});
+// Returns posts with arrays containing 4 or 5: [3, 4], [5], [1, 2, 4, 5], etc.
+
+// Find posts with no tags
+const { data: untaggedPosts } = useSuparisma.post({
+  where: {
+    tags: { isEmpty: true }
+  }
+});
+
+// Find posts that have tags (non-empty)
+const { data: taggedPosts } = useSuparisma.post({
+  where: {
+    tags: { isEmpty: false }
+  }
+});
+
+// Combine array filtering with other conditions
+const { data: featuredReactPosts } = useSuparisma.post({
+  where: {
+    tags: { has: ["react"] },
+    featured: true,
+    ratings: { hasEvery: [4, 5] } // Must have both 4 AND 5 ratings
+  }
+});
+
+// Exact array match (regular equality)
+const { data: exactMatch } = useSuparisma.post({
+  where: {
+    tags: ["react", "typescript"] // Exact match: only this array
+  }
+});
+```
+
+#### Real-World Array Filtering Scenarios
+
+```tsx
+// E-commerce: Find products by multiple categories
+const { data: products } = useSuparisma.product({
+  where: {
+    categories: { has: ["electronics", "gaming"] } // Any of these categories
+  }
+});
+
+// Social Media: Find posts with specific hashtags
+const { data: trendingPosts } = useSuparisma.post({
+  where: {
+    hashtags: { hasSome: ["trending", "viral", "popular"] }
+  }
+});
+
+// Project Management: Find tasks assigned to specific team members
+const { data: myTasks } = useSuparisma.task({
+  where: {
+    assignedTo: { has: ["john@company.com"] } // Tasks assigned to John
+  }
+});
+
+// Content Management: Find articles with all required tags
+const { data: completeArticles } = useSuparisma.article({
+  where: {
+    requiredTags: { hasEvery: ["reviewed", "approved", "published"] }
+  }
+});
+```
+
+#### Interactive Array Filtering Component
+
+```tsx
+import { useState } from "react";
+import useSuparisma from '../generated';
+
+function ProductFilter() {
+  const [selectedCategories, setSelectedCategories] = useState<string[]>([]);
+  const [filterMode, setFilterMode] = useState<'any' | 'all'>('any');
+
+  const { data: products, loading } = useSuparisma.product({
+    where: selectedCategories.length > 0 ? {
+      categories: filterMode === 'any' 
+        ? { has: selectedCategories }           // ANY of selected categories
+        : { hasEvery: selectedCategories }      // ALL of selected categories
+    } : undefined
+  });
+
+  const handleCategoryToggle = (category: string) => {
+    setSelectedCategories(prev => 
+      prev.includes(category) 
+        ? prev.filter(c => c !== category)
+        : [...prev, category]
+    );
+  };
+
+  return (
+    <div>
+      {/* Filter Mode Toggle */}
+      <div className="mb-4">
+        <label className="mr-4">
+          <input
+            type="radio"
+            value="any"
+            checked={filterMode === 'any'}
+            onChange={(e) => setFilterMode(e.target.value as 'any')}
+          />
+          Match ANY categories
+        </label>
+        <label>
+          <input
+            type="radio"
+            value="all"
+            checked={filterMode === 'all'}
+            onChange={(e) => setFilterMode(e.target.value as 'all')}
+          />
+          Match ALL categories
+        </label>
+      </div>
+
+      {/* Category Checkboxes */}
+      <div className="mb-4">
+        {['electronics', 'clothing', 'books', 'home', 'sports'].map(category => (
+          <label key={category} className="mr-4">
+            <input
+              type="checkbox"
+              checked={selectedCategories.includes(category)}
+              onChange={() => handleCategoryToggle(category)}
+            />
+            {category}
+          </label>
+        ))}
+      </div>
+
+      {/* Results */}
+      <div>
+        {loading ? (
+          <p>Loading products...</p>
+        ) : (
+          <div>
+            <h3>Found {products?.length || 0} products</h3>
+            {products?.map(product => (
+              <div key={product.id}>
+                <h4>{product.name}</h4>
+                <p>Categories: {product.categories.join(', ')}</p>
+              </div>
+            ))}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+```
+
 ### Sorting Data
 
 Sort data using Prisma-like ordering:
@@ -345,6 +622,8 @@ const { data, count } = useSuparisma.thing();
 
 ### Search Functionality
 
+> ⚠️ **MAINTENANCE NOTICE**: Search functionality is currently under maintenance and may not work as expected. We're working on improvements and will update the documentation once it's fully operational.
+
 For fields annotated with `// @enableSearch`, you can use full-text search:
 
 ```tsx

package/dist/generators/coreGenerator.js

@@ -43,6 +43,18 @@ export type SupabaseQueryBuilder = ReturnType<ReturnType<typeof supabase.from>['
  * @example
  * // Posts with titles containing "news"
  * { title: { contains: "news" } }
+ * 
+ * @example
+ * // Array contains ANY of these items (overlaps)
+ * { tags: { has: ["typescript", "react"] } }
+ * 
+ * @example
+ * // Array contains ALL of these items (contains)
+ * { categories: { hasEvery: ["tech", "programming"] } }
+ * 
+ * @example
+ * // Array contains ANY of these items (same as 'has')
+ * { tags: { hasSome: ["javascript", "python"] } }
  */
 export type FilterOperators<T> = {
   /** Equal to value */
@@ -67,6 +79,16 @@ export type FilterOperators<T> = {
   startsWith?: string;
   /** String ends with value (case insensitive) */
   endsWith?: string;
+  
+  // Array-specific operators
+  /** Array contains ANY of the specified items (for array fields) */
+  has?: T extends Array<infer U> ? U[] : never;
+  /** Array contains ANY of the specified items (alias for 'has') */
+  hasSome?: T extends Array<infer U> ? U[] : never;
+  /** Array contains ALL of the specified items (for array fields) */
+  hasEvery?: T extends Array<infer U> ? U[] : never;
+  /** Array is empty (for array fields) */
+  isEmpty?: T extends Array<any> ? boolean : never;
 };
 
 // Type for a single field in an advanced where filter
@@ -239,6 +261,35 @@ export function buildFilterString<T>(where?: T): string | undefined {
         if ('endsWith' in advancedOps && advancedOps.endsWith !== undefined) {
           filters.push(\`\${key}=ilike.%\${advancedOps.endsWith}\`);
         }
+        
+        // Array-specific operators
+        if ('has' in advancedOps && advancedOps.has !== undefined) {
+          // Array contains ANY of the specified items (overlaps)
+          const arrayValue = JSON.stringify(advancedOps.has);
+          filters.push(\`\${key}=ov.\${arrayValue}\`);
+        }
+        
+        if ('hasEvery' in advancedOps && advancedOps.hasEvery !== undefined) {
+          // Array contains ALL of the specified items (contains)
+          const arrayValue = JSON.stringify(advancedOps.hasEvery);
+          filters.push(\`\${key}=cs.\${arrayValue}\`);
+        }
+        
+        if ('hasSome' in advancedOps && advancedOps.hasSome !== undefined) {
+          // Array contains ANY of the specified items (overlaps)
+          const arrayValue = JSON.stringify(advancedOps.hasSome);
+          filters.push(\`\${key}=ov.\${arrayValue}\`);
+        }
+        
+        if ('isEmpty' in advancedOps && advancedOps.isEmpty !== undefined) {
+          if (advancedOps.isEmpty) {
+            // Check if array is empty
+            filters.push(\`\${key}=eq.{}\`);
+          } else {
+            // Check if array is not empty
+            filters.push(\`\${key}=neq.{}\`);
+          }
+        }
       } else {
         // Simple equality
         filters.push(\`\${key}=eq.\${value}\`);
@@ -316,6 +367,37 @@ export function applyFilter<T>(
           // @ts-ignore: Supabase typing issue
           filteredQuery = filteredQuery.ilike(key, \`%\${advancedOps.endsWith}\`);
         }
+        
+        // Array-specific operators
+        if ('has' in advancedOps && advancedOps.has !== undefined) {
+          // Array contains ANY of the specified items (overlaps)
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.overlaps(key, advancedOps.has);
+        }
+        
+        if ('hasEvery' in advancedOps && advancedOps.hasEvery !== undefined) {
+          // Array contains ALL of the specified items (contains)
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.contains(key, advancedOps.hasEvery);
+        }
+        
+        if ('hasSome' in advancedOps && advancedOps.hasSome !== undefined) {
+          // Array contains ANY of the specified items (overlaps)
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.overlaps(key, advancedOps.hasSome);
+        }
+        
+        if ('isEmpty' in advancedOps && advancedOps.isEmpty !== undefined) {
+          if (advancedOps.isEmpty) {
+            // Check if array is empty
+            // @ts-ignore: Supabase typing issue
+            filteredQuery = filteredQuery.eq(key, []);
+          } else {
+            // Check if array is not empty
+            // @ts-ignore: Supabase typing issue  
+            filteredQuery = filteredQuery.neq(key, []);
+          }
+        }
       } else {
         // Simple equality
         // @ts-ignore: Supabase typing issue
@@ -830,24 +912,52 @@ export function createSuparismaHook<
       
       const channelId = channelName || \`changes_to_\${tableName}_\${Math.random().toString(36).substring(2, 15)}\`;
       
-      // Use a dynamic filter string builder inside the event handler or rely on Supabase
-      // For the subscription filter, we must use the initial computedFilter or a stable one.
-      // However, for client-side logic (sorting, adding/removing from list), we use refs.
-      const initialComputedFilter = where ? buildFilterString(where) : realtimeFilter;
-      console.log(\`Setting up subscription for \${tableName} with initial filter: \${initialComputedFilter}\`);
+      // Check if we have complex array filters that should be handled client-side only
+      let hasComplexArrayFilters = false;
+      if (where) {
+        for (const [key, value] of Object.entries(where)) {
+          if (typeof value === 'object' && value !== null) {
+            const advancedOps = value as any;
+            // Check for complex array operators
+            if ('has' in advancedOps || 'hasEvery' in advancedOps || 'hasSome' in advancedOps || 'isEmpty' in advancedOps) {
+              hasComplexArrayFilters = true;
+              break;
+            }
+          }
+        }
+      }
+      
+      // For complex array filters, use no database filter and rely on client-side filtering
+      // For simple filters, use database-level filtering
+      let subscriptionConfig: any = {
+        event: '*',
+        schema: 'public',
+        table: tableName,
+      };
+      
+      if (hasComplexArrayFilters) {
+        // Don't include filter at all for complex array operations
+        console.log(\`Setting up subscription for \${tableName} with NO FILTER (complex array filters detected) - will receive ALL events\`);
+      } else if (where) {
+        // Include filter for simple operations
+        const filter = buildFilterString(where);
+        if (filter) {
+          subscriptionConfig.filter = filter;
+        }
+        console.log(\`Setting up subscription for \${tableName} with database filter: \${filter}\`);
+      } else if (realtimeFilter) {
+        // Use custom realtime filter if provided
+        subscriptionConfig.filter = realtimeFilter;
+        console.log(\`Setting up subscription for \${tableName} with custom filter: \${realtimeFilter}\`);
+      }
       
       const channel = supabase
         .channel(channelId)
         .on(
           'postgres_changes',
-          {
-            event: '*',
-            schema: 'public',
-            table: tableName,
-            filter: initialComputedFilter, // Subscription filter uses initial state
-          },
+          subscriptionConfig,
           (payload) => {
-            console.log(\`Received \${payload.eventType} event for \${tableName}\`, payload);
+            console.log(\`🔥 REALTIME EVENT RECEIVED for \${tableName}:\`, payload.eventType, payload);
             
             // Access current options via refs inside the event handler
             const currentWhere = whereRef.current;
@@ -856,7 +966,10 @@ export function createSuparismaHook<
             const currentOffset = offsetRef.current; // Not directly used in handlers but good for consistency
 
             // Skip realtime updates when search is active
-            if (isSearchingRef.current) return;
+            if (isSearchingRef.current) {
+              console.log('⏭️ Skipping realtime update - search is active');
+              return;
+            }
             
             if (payload.eventType === 'INSERT') {
               // Process insert event
@@ -865,14 +978,46 @@ export function createSuparismaHook<
                   const newRecord = payload.new as TWithRelations;
                   console.log(\`Processing INSERT for \${tableName}\`, { newRecord });
                   
-                  // Check if this record matches our filter if we have one
+                  // ALWAYS check if this record matches our filter client-side
+                  // This is especially important for complex array filters
                   if (currentWhere) { // Use ref value
                     let matchesFilter = true;
                     
-                    // Check each filter condition
+                    // Check each filter condition client-side for complex filters
                     for (const [key, value] of Object.entries(currentWhere)) {
                       if (typeof value === 'object' && value !== null) {
-                        // Complex filter - this is handled by Supabase, assume it matches
+                        // Handle complex array filters client-side
+                        const advancedOps = value as any;
+                        const recordValue = newRecord[key as keyof typeof newRecord] as any;
+                        
+                        // Array-specific operators validation
+                        if ('has' in advancedOps && advancedOps.has !== undefined) {
+                          // Array contains ANY of the specified items
+                          if (!Array.isArray(recordValue) || !advancedOps.has.some((item: any) => recordValue.includes(item))) {
+                            matchesFilter = false;
+                            break;
+                          }
+                        } else if ('hasEvery' in advancedOps && advancedOps.hasEvery !== undefined) {
+                          // Array contains ALL of the specified items
+                          if (!Array.isArray(recordValue) || !advancedOps.hasEvery.every((item: any) => recordValue.includes(item))) {
+                            matchesFilter = false;
+                            break;
+                          }
+                        } else if ('hasSome' in advancedOps && advancedOps.hasSome !== undefined) {
+                          // Array contains ANY of the specified items
+                          if (!Array.isArray(recordValue) || !advancedOps.hasSome.some((item: any) => recordValue.includes(item))) {
+                            matchesFilter = false;
+                            break;
+                          }
+                        } else if ('isEmpty' in advancedOps && advancedOps.isEmpty !== undefined) {
+                          // Array is empty or not empty
+                          const isEmpty = !Array.isArray(recordValue) || recordValue.length === 0;
+                          if (isEmpty !== advancedOps.isEmpty) {
+                            matchesFilter = false;
+                            break;
+                          }
+                        }
+                        // Add other complex filter validations as needed
                       } else if (newRecord[key as keyof typeof newRecord] !== value) {
                         matchesFilter = false;
                         console.log(\`Filter mismatch on \${key}\`, { expected: value, actual: newRecord[key as keyof typeof newRecord] });
@@ -953,12 +1098,68 @@ export function createSuparismaHook<
                 // Access current options via refs
                 const currentOrderBy = orderByRef.current; 
                 const currentLimit = limitRef.current; // If needed for re-fetch logic on update
+                const currentWhere = whereRef.current;
 
                 // Skip if search is active
                 if (isSearchingRef.current) {
                   return prev;
                 }
                 
+                const updatedRecord = payload.new as TWithRelations;
+                
+                // Check if the updated record still matches our current filter
+                if (currentWhere) {
+                  let matchesFilter = true;
+                  
+                  for (const [key, value] of Object.entries(currentWhere)) {
+                    if (typeof value === 'object' && value !== null) {
+                      // Handle complex array filters client-side
+                      const advancedOps = value as any;
+                      const recordValue = updatedRecord[key as keyof typeof updatedRecord] as any;
+                      
+                      // Array-specific operators validation
+                      if ('has' in advancedOps && advancedOps.has !== undefined) {
+                        // Array contains ANY of the specified items
+                        if (!Array.isArray(recordValue) || !advancedOps.has.some((item: any) => recordValue.includes(item))) {
+                          matchesFilter = false;
+                          break;
+                        }
+                      } else if ('hasEvery' in advancedOps && advancedOps.hasEvery !== undefined) {
+                        // Array contains ALL of the specified items
+                        if (!Array.isArray(recordValue) || !advancedOps.hasEvery.every((item: any) => recordValue.includes(item))) {
+                          matchesFilter = false;
+                          break;
+                        }
+                      } else if ('hasSome' in advancedOps && advancedOps.hasSome !== undefined) {
+                        // Array contains ANY of the specified items
+                        if (!Array.isArray(recordValue) || !advancedOps.hasSome.some((item: any) => recordValue.includes(item))) {
+                          matchesFilter = false;
+                          break;
+                        }
+                      } else if ('isEmpty' in advancedOps && advancedOps.isEmpty !== undefined) {
+                        // Array is empty or not empty
+                        const isEmpty = !Array.isArray(recordValue) || recordValue.length === 0;
+                        if (isEmpty !== advancedOps.isEmpty) {
+                          matchesFilter = false;
+                          break;
+                        }
+                      }
+                    } else if (updatedRecord[key as keyof typeof updatedRecord] !== value) {
+                      matchesFilter = false;
+                      break;
+                    }
+                  }
+                  
+                  // If the updated record doesn't match the filter, remove it from the list
+                  if (!matchesFilter) {
+                    console.log('Updated record no longer matches filter, removing from list');
+                    return prev.filter((item) =>
+                      // @ts-ignore: Supabase typing issue
+                      !('id' in item && 'id' in updatedRecord && item.id === updatedRecord.id)
+                    );
+                  }
+                }
+                
                 const newData = prev.map((item) =>
                   // @ts-ignore: Supabase typing issue
                   'id' in item && 'id' in payload.new && item.id === payload.new.id 
@@ -1010,7 +1211,10 @@ export function createSuparismaHook<
               });
             } else if (payload.eventType === 'DELETE') {
               // Process delete event
+              console.log('🗑️ Processing DELETE event for', tableName);
               setData((prev) => {
+                console.log('🗑️ DELETE: Current data before deletion:', prev.length, 'items');
+                
                 // Access current options via refs
                 const currentWhere = whereRef.current;
                 const currentOrderBy = orderByRef.current;
@@ -1019,6 +1223,7 @@ export function createSuparismaHook<
 
                 // Skip if search is active
                 if (isSearchingRef.current) {
+                  console.log('⏭️ DELETE: Skipping - search is active');
                   return prev;
                 }
                 
@@ -1028,15 +1233,21 @@ export function createSuparismaHook<
                 // Filter out the deleted item
                 const filteredData = prev.filter((item) => {
                   // @ts-ignore: Supabase typing issue
-                  return !('id' in item && 'id' in payload.old && item.id === payload.old.id);
+                  const shouldKeep = !('id' in item && 'id' in payload.old && item.id === payload.old.id);
+                  if (!shouldKeep) {
+                    console.log('🗑️ DELETE: Removing item with ID:', item.id);
+                  }
+                  return shouldKeep;
                 });
                 
+                console.log('🗑️ DELETE: Data after deletion:', filteredData.length, 'items (was', currentSize, ')');
+                
                 // Fetch the updated count after the data changes
                 setTimeout(() => fetchTotalCount(), 0);
                 
                 // If we need to maintain the size with a limit
                 if (currentLimit && currentLimit > 0 && filteredData.length < currentSize && currentSize === currentLimit) { // Use ref value
-                  console.log(\`Record deleted with limit \${currentLimit}, will fetch additional record to maintain size\`);
+                  console.log(\`🗑️ DELETE: Record deleted with limit \${currentLimit}, will fetch additional record to maintain size\`);
                   
                   // Use setTimeout to ensure this state update completes first
                   setTimeout(() => {
@@ -1113,7 +1324,7 @@ export function createSuparismaHook<
           searchTimeoutRef.current = null;
         }
       };
-    }, [realtime, channelName, tableName, initialLoadRef]); // Removed where, orderBy, limit, offset from deps
+    }, [realtime, channelName, tableName, where, initialLoadRef]); // Added 'where' back so subscription updates when filter changes
 
     // Create a memoized options object to prevent unnecessary re-renders
     const optionsRef = useRef({ where, orderBy, limit, offset });

package/dist/generators/typeGenerator.js

@@ -119,7 +119,7 @@ function generateModelTypesFile(model) {
 // Edit the generator script instead
 
 import type { ${modelName} } from '@prisma/client';
-import type { ModelResult, SuparismaOptions, SearchQuery, SearchState } from '../utils/core';
+import type { ModelResult, SuparismaOptions, SearchQuery, SearchState, FilterOperators } from '../utils/core';
 
 /**
  * Extended ${modelName} type that includes relation fields.
@@ -208,8 +208,64 @@ ${withRelationsProps
         .join(',\n')}
  *   }
  * });
+ * 
+ * @example
+ * // Array filtering (for array fields)
+ * ${modelName.toLowerCase()}.findMany({
+ *   where: {
+ *     // Array contains specific items
+${withRelationsProps
+        .filter((p) => p.includes('[]'))
+        .slice(0, 1)
+        .map((p) => {
+        const field = p.trim().split(':')[0].trim();
+        return ` *     ${field}: { has: ["item1", "item2"] }`;
+    })
+        .join(',\n')}
+ *   }
+ * });
  */
-export type ${modelName}WhereInput = Partial<${modelName}WithRelations>;
+export type ${modelName}WhereInput = {
+${model.fields
+        .filter((field) => !relationObjectFields.includes(field.name) && !foreignKeyFields.includes(field.name))
+        .map((field) => {
+        const isOptional = true; // All where fields are optional
+        let baseType;
+        switch (field.type) {
+            case 'Int':
+            case 'Float':
+                baseType = 'number';
+                break;
+            case 'Boolean':
+                baseType = 'boolean';
+                break;
+            case 'DateTime':
+                baseType = 'string'; // ISO date string
+                break;
+            case 'Json':
+                baseType = 'any'; // Or a more specific structured type if available
+                break;
+            default:
+                // Covers String, Enum names (e.g., "SomeEnum"), Bytes, Decimal, etc.
+                baseType = 'string';
+        }
+        const finalType = field.isList ? `${baseType}[]` : baseType;
+        const filterType = `${finalType} | FilterOperators<${finalType}>`;
+        return `  ${field.name}${isOptional ? '?' : ''}: ${filterType};`;
+    })
+        .concat(
+    // Add foreign key fields
+    foreignKeyFields.map((field) => {
+        const fieldInfo = model.fields.find((f) => f.name === field);
+        if (fieldInfo) {
+            const baseType = fieldInfo.type === 'Int' ? 'number' : 'string';
+            const filterType = `${baseType} | FilterOperators<${baseType}>`;
+            return `  ${field}?: ${filterType};`;
+        }
+        return '';
+    }).filter(Boolean))
+        .join('\n')}
+};
 
 /**
  * Unique identifier for finding a specific ${modelName} record.

package/dist/parser.js

@@ -12,6 +12,16 @@ function parsePrismaSchema(schemaPath) {
     const schema = fs_1.default.readFileSync(schemaPath, 'utf-8');
     const modelRegex = /model\s+(\w+)\s+{([^}]*)}/gs;
     const models = [];
+    // Extract enum names from the schema
+    const enumRegex = /enum\s+(\w+)\s+{[^}]*}/gs;
+    const enumNames = [];
+    let enumMatch;
+    while ((enumMatch = enumRegex.exec(schema)) !== null) {
+        const enumName = enumMatch[1];
+        if (enumName) {
+            enumNames.push(enumName);
+        }
+    }
     let match;
     while ((match = modelRegex.exec(schema)) !== null) {
         const modelName = match[1] || '';
@@ -45,7 +55,7 @@ function parsePrismaSchema(schemaPath) {
                 continue;
             }
             // Parse field definition - Updated to handle array types
-            const fieldMatch = line.match(/\s*(\w+)\s+(\w+)(\[\])?\??(\?)?\s*(?:@[^)]+)?/);
+            const fieldMatch = line.match(/\s*(\w+)\s+(\w+)(\[\])?(\?)?\s*(?:@[^)]+)?/);
             if (fieldMatch) {
                 const fieldName = fieldMatch[1];
                 const baseFieldType = fieldMatch[2]; // e.g., "String" from "String[]"
@@ -67,9 +77,13 @@ function parsePrismaSchema(schemaPath) {
                         defaultValue = defaultMatch[1];
                     }
                 }
+                // Improved relation detection
+                const primitiveTypes = ['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Json', 'Bytes', 'Decimal', 'BigInt'];
                 const isRelation = line.includes('@relation') ||
                     (!!fieldName &&
-                        (fieldName.endsWith('_id') || fieldName === 'userId' || fieldName === 'user_id'));
+                        (fieldName.endsWith('_id') || fieldName === 'userId' || fieldName === 'user_id')) ||
+                    // Also detect relation fields by checking if the type is not a primitive type and not an enum
+                    (!!baseFieldType && !primitiveTypes.includes(baseFieldType) && !enumNames.includes(baseFieldType));
                 // Check for inline @enableSearch comment
                 if (line.includes('// @enableSearch')) {
                     searchFields.push({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "suparisma",
-	"version": "1.0.3",
+	"version": "1.0.5",
 	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma.",
 	"main": "dist/index.js",
 	"repository": {

package/prisma/schema.prisma

@@ -19,6 +19,14 @@ enum SomeEnum {
   THREE
 }
 
+model User {
+  id        String   @id @default(uuid())
+  name      String
+  email     String   @unique
+  things    Thing[]  // One-to-many relation
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
 
 model Thing {
   id        String   @id @default(uuid())
@@ -27,6 +35,8 @@ model Thing {
   stringArray String[]
   someEnum  SomeEnum @default(ONE)
   someNumber Int?
+  userId    String?
+  user      User?    @relation(fields: [userId], references: [id])
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 }