suparisma 1.0.8 → 1.0.12

package/README.md

@@ -23,7 +23,6 @@ A powerful, typesafe React hook generator for Supabase, driven by your Prisma sc
   - [Filtering Data](#filtering-data)
   - [⚠️ IMPORTANT: Using Dynamic Filters with React](#️-important-using-dynamic-filters-with-react)
   - [Array Filtering](#array-filtering)
-  - [OR/AND Conditions](#orand-conditions)
   - [Sorting Data](#sorting-data)
   - [Pagination](#pagination)
   - [Search Functionality](#search-functionality)
@@ -62,7 +61,6 @@ Suparisma bridges this gap by:
 - 🔄 **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 *(currently under maintenance)*
-- ⚡ **Advanced filtering** with OR/AND conditions for complex queries
 - 🔢 **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.
@@ -582,215 +580,6 @@ function ProductFilter() {
 }
 ```
 
-### OR/AND Conditions
-
-Suparisma supports powerful logical operations to combine multiple filter conditions:
-
-#### OR Conditions - Match ANY condition
-
-Use `OR` to find records that match **any** of the provided conditions:
-
-```tsx
-// Find users with name "John" OR email containing "@admin"
-const { data: users } = useSuparisma.user({
-  where: {
-    OR: [
-      { name: "John" },
-      { email: { contains: "@admin" } }
-    ]
-  }
-});
-
-// Complex OR with multiple field types
-const { data: posts } = useSuparisma.post({
-  where: {
-    OR: [
-      { title: { contains: "react" } },
-      { tags: { has: ["typescript"] } },
-      { author: { name: "John Doe" } },
-      { publishedAt: { gte: new Date('2024-01-01') } }
-    ]
-  }
-});
-
-// OR with array operators
-const { data: products } = useSuparisma.product({
-  where: {
-    OR: [
-      { categories: { has: ["electronics"] } },
-      { categories: { has: ["gaming"] } },
-      { price: { lt: 100 } }
-    ]
-  }
-});
-```
-
-#### AND Conditions - Match ALL conditions
-
-Use `AND` for explicit conjunction (though regular object properties are ANDed by default):
-
-```tsx
-// Explicit AND conditions
-const { data: premiumUsers } = useSuparisma.user({
-  where: {
-    AND: [
-      { active: true },
-      { subscriptionTier: "premium" },
-      { lastLoginAt: { gte: new Date('2024-01-01') } }
-    ]
-  }
-});
-
-// Mix AND with other conditions
-const { data: qualifiedPosts } = useSuparisma.post({
-  where: {
-    published: true, // Regular condition (implicit AND)
-    AND: [
-      { views: { gte: 1000 } },
-      { likes: { gte: 100 } }
-    ]
-  }
-});
-```
-
-#### Combining OR and AND
-
-Create complex nested logic by combining OR and AND:
-
-```tsx
-// Advanced search: (Premium users OR moderators) AND active
-const { data: privilegedUsers } = useSuparisma.user({
-  where: {
-    active: true, // Must be active
-    OR: [
-      { role: "premium" },
-      { role: "moderator" }
-    ]
-  }
-});
-
-// Content filtering: (Recent posts OR popular posts) AND published
-const { data: featuredPosts } = useSuparisma.post({
-  where: {
-    published: true,
-    OR: [
-      { createdAt: { gte: new Date('2024-01-01') } }, // Recent
-      { views: { gte: 10000 } } // Popular
-    ]
-  }
-});
-
-// Complex search across multiple fields and conditions
-const { data: searchResults } = useSuparisma.product({
-  where: {
-    active: true,
-    AND: [
-      {
-        OR: [
-          { name: { contains: searchTerm } },
-          { description: { contains: searchTerm } },
-          { tags: { has: [searchTerm] } }
-        ]
-      },
-      {
-        OR: [
-          { price: { between: [minPrice, maxPrice] } },
-          { onSale: true }
-        ]
-      }
-    ]
-  }
-});
-```
-
-#### Real-World Examples
-
-**Multi-field search for e-commerce:**
-```tsx
-const { data: products } = useSuparisma.product({
-  where: {
-    OR: [
-      { name: { contains: "laptop" } },
-      { description: { contains: "laptop" } },
-      { categories: { has: ["computers", "electronics"] } },
-      { brand: { in: ["Apple", "Dell", "HP"] } }
-    ]
-  }
-});
-```
-
-**User permission filtering:**
-```tsx
-const { data: accessiblePosts } = useSuparisma.post({
-  where: {
-    OR: [
-      { public: true },
-      { authorId: currentUserId },
-      { 
-        AND: [
-          { published: true },
-          { collaborators: { has: [currentUserId] } }
-        ]
-      }
-    ]
-  }
-});
-```
-
-**Dynamic search with React state:**
-```tsx
-import { useMemo } from 'react';
-
-function SearchComponent() {
-  const [searchTerm, setSearchTerm] = useState("");
-  const [category, setCategory] = useState("");
-  const [priceRange, setPriceRange] = useState({ min: 0, max: 1000 });
-
-  // ✅ Use useMemo for stable object reference
-  const searchFilter = useMemo(() => {
-    const conditions = [];
-    
-    // Add search term condition
-    if (searchTerm) {
-      conditions.push({
-        OR: [
-          { name: { contains: searchTerm } },
-          { description: { contains: searchTerm } },
-          { tags: { has: [searchTerm] } }
-        ]
-      });
-    }
-    
-    // Add category condition
-    if (category) {
-      conditions.push({
-        categories: { has: [category] }
-      });
-    }
-    
-    // Add price range condition
-    conditions.push({
-      price: { gte: priceRange.min, lte: priceRange.max }
-    });
-    
-    return conditions.length > 0 ? { AND: conditions } : undefined;
-  }, [searchTerm, category, priceRange]);
-  
-  const { data: products } = useSuparisma.product({
-    where: searchFilter
-  });
-  
-  // ... rest of component
-}
-```
-
-#### Important Notes
-
-1. **Performance**: OR conditions may require client-side filtering for realtime updates
-2. **Realtime**: Complex OR/AND combinations automatically enable client-side filtering mode
-3. **Memory**: Use `useMemo` for dynamic OR/AND filters to maintain stable object references
-4. **Nesting**: You can nest OR within AND and vice versa for complex logic
-
 ### Sorting Data
 
 Sort data using Prisma-like ordering:

package/dist/generators/coreGenerator.js

@@ -94,21 +94,6 @@ export type FilterOperators<T> = {
 // Type for a single field in an advanced where filter
 export type AdvancedWhereInput<T> = {
   [K in keyof T]?: T[K] | FilterOperators<T[K]>;
-} & {
-  /** 
-   * OR condition - match records that satisfy ANY of the provided conditions
-   * @example
-   * // Find users where name is "John" OR email contains "@admin"
-   * { OR: [{ name: "John" }, { email: { contains: "@admin" } }] }
-   */
-  OR?: AdvancedWhereInput<T>[];
-  /** 
-   * AND condition - match records that satisfy ALL of the provided conditions (default behavior)
-   * @example
-   * // Find users where name is "John" AND age > 18
-   * { AND: [{ name: "John" }, { age: { gt: 18 } }] }
-   */
-  AND?: AdvancedWhereInput<T>[];
 };
 
 /**
@@ -192,19 +177,6 @@ export type SearchState = {
   clearQueries: () => void;
 };
 
-/**
- * Escape values for Supabase filter strings
- */
-function escapeFilterValue(value: any): string {
-  if (typeof value === 'string') {
-    // If the string contains spaces or special characters, wrap it in quotes
-    if (value.includes(' ') || value.includes(',') || value.includes('(') || value.includes(')')) {
-      return \`"\${value.replace(/"/g, '\\\\"')}"\`;
-    }
-  }
-  return String(value);
-}
-
 /**
  * Compare two values for sorting with proper type handling
  */
@@ -243,73 +215,9 @@ export function buildFilterString<T>(where?: T): string | undefined {
   if (!where) return undefined;
   
   const filters: string[] = [];
-  const orConditions: string[] = [];
   
   for (const [key, value] of Object.entries(where)) {
     if (value !== undefined) {
-      // Handle OR conditions
-      if (key === 'OR' && Array.isArray(value)) {
-        const orParts: string[] = [];
-        for (const orCondition of value) {
-          // Build individual OR condition parts using proper dot notation
-          for (const [orKey, orValue] of Object.entries(orCondition)) {
-            if (orValue !== undefined) {
-              if (typeof orValue === 'object' && orValue !== null) {
-                // Handle advanced operators in OR conditions
-                const advancedOps = orValue as unknown as FilterOperators<any>;
-                
-                if ('equals' in advancedOps && advancedOps.equals !== undefined) {
-                  orParts.push(\`\${orKey}.eq.\${advancedOps.equals}\`);
-                } else if ('contains' in advancedOps && advancedOps.contains !== undefined) {
-                  orParts.push(\`\${orKey}.ilike.*\${advancedOps.contains}*\`);
-                } else if ('has' in advancedOps && advancedOps.has !== undefined) {
-                  // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
-                  const arrayValue = \`{\${advancedOps.has.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
-                  orParts.push(\`\${orKey}.ov.\${arrayValue}\`);
-                } else if ('hasEvery' in advancedOps && advancedOps.hasEvery !== undefined) {
-                  // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
-                  const arrayValue = \`{\${advancedOps.hasEvery.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
-                  orParts.push(\`\${orKey}.cs.\${arrayValue}\`);
-                } else if ('hasSome' in advancedOps && advancedOps.hasSome !== undefined) {
-                  // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
-                  const arrayValue = \`{\${advancedOps.hasSome.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
-                  orParts.push(\`\${orKey}.ov.\${arrayValue}\`);
-                } else if ('gt' in advancedOps && advancedOps.gt !== undefined) {
-                  orParts.push(\`\${orKey}.gt.\${advancedOps.gt}\`);
-                } else if ('gte' in advancedOps && advancedOps.gte !== undefined) {
-                  orParts.push(\`\${orKey}.gte.\${advancedOps.gte}\`);
-                } else if ('lt' in advancedOps && advancedOps.lt !== undefined) {
-                  orParts.push(\`\${orKey}.lt.\${advancedOps.lt}\`);
-                } else if ('lte' in advancedOps && advancedOps.lte !== undefined) {
-                  orParts.push(\`\${orKey}.lte.\${advancedOps.lte}\`);
-                } else if ('in' in advancedOps && advancedOps.in?.length) {
-                  orParts.push(\`\${orKey}.in.(\${advancedOps.in.join(',')})\`);
-                }
-              } else {
-                // Simple equality in OR condition
-                orParts.push(\`\${orKey}.eq.\${escapeFilterValue(orValue)}\`);
-              }
-            }
-          }
-        }
-        
-        if (orParts.length > 0) {
-          orConditions.push(\`or(\${orParts.join(',')})\`);
-        }
-        continue;
-      }
-      
-      // Handle AND conditions (explicit)
-      if (key === 'AND' && Array.isArray(value)) {
-        for (const andCondition of value) {
-          const andFilter = buildFilterString(andCondition);
-          if (andFilter) {
-            filters.push(andFilter);
-          }
-        }
-        continue;
-      }
-      
       if (typeof value === 'object' && value !== null) {
         // Handle advanced operators
         const advancedOps = value as unknown as FilterOperators<any>;
@@ -357,22 +265,19 @@ export function buildFilterString<T>(where?: T): string | undefined {
         // Array-specific operators
         if ('has' in advancedOps && advancedOps.has !== undefined) {
           // Array contains ANY of the specified items (overlaps)
-          // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
-          const arrayValue = \`{\${advancedOps.has.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
+          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)
-          // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
-          const arrayValue = \`{\${advancedOps.hasEvery.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
+          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)
-          // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
-          const arrayValue = \`{\${advancedOps.hasSome.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
+          const arrayValue = JSON.stringify(advancedOps.hasSome);
           filters.push(\`\${key}=ov.\${arrayValue}\`);
         }
         
@@ -392,18 +297,7 @@ export function buildFilterString<T>(where?: T): string | undefined {
     }
   }
   
-  // Combine filters with OR conditions
-  const allConditions: string[] = [];
-  
-  if (filters.length > 0) {
-    allConditions.push(filters.join(','));
-  }
-  
-  if (orConditions.length > 0) {
-    allConditions.push(\`or(\${orConditions.join(',')})\`);
-  }
-  
-  return allConditions.length > 0 ? allConditions.join(',') : undefined;
+  return filters.length > 0 ? filters.join(',') : undefined;
 }
 
 /**
@@ -420,69 +314,6 @@ export function applyFilter<T>(
   // Apply each filter condition
   for (const [key, value] of Object.entries(where)) {
     if (value !== undefined) {
-      // Handle OR conditions
-      if (key === 'OR' && Array.isArray(value)) {
-        // For OR conditions, build the proper dot notation filter string
-        const orParts: string[] = [];
-        
-        for (const orCondition of value) {
-          for (const [orKey, orValue] of Object.entries(orCondition)) {
-            if (orValue !== undefined) {
-              if (typeof orValue === 'object' && orValue !== null) {
-                // Handle advanced operators in OR conditions
-                const advancedOps = orValue as unknown as FilterOperators<any>;
-                
-                if ('equals' in advancedOps && advancedOps.equals !== undefined) {
-                  orParts.push(\`\${orKey}.eq.\${advancedOps.equals}\`);
-                } else if ('contains' in advancedOps && advancedOps.contains !== undefined) {
-                  orParts.push(\`\${orKey}.ilike.*\${advancedOps.contains}*\`);
-                } else if ('has' in advancedOps && advancedOps.has !== undefined) {
-                  // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
-                  const arrayValue = \`{\${advancedOps.has.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
-                  orParts.push(\`\${orKey}.ov.\${arrayValue}\`);
-                } else if ('hasEvery' in advancedOps && advancedOps.hasEvery !== undefined) {
-                  // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
-                  const arrayValue = \`{\${advancedOps.hasEvery.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
-                  orParts.push(\`\${orKey}.cs.\${arrayValue}\`);
-                } else if ('hasSome' in advancedOps && advancedOps.hasSome !== undefined) {
-                  // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
-                  const arrayValue = \`{\${advancedOps.hasSome.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
-                  orParts.push(\`\${orKey}.ov.\${arrayValue}\`);
-                } else if ('gt' in advancedOps && advancedOps.gt !== undefined) {
-                  orParts.push(\`\${orKey}.gt.\${advancedOps.gt}\`);
-                } else if ('gte' in advancedOps && advancedOps.gte !== undefined) {
-                  orParts.push(\`\${orKey}.gte.\${advancedOps.gte}\`);
-                } else if ('lt' in advancedOps && advancedOps.lt !== undefined) {
-                  orParts.push(\`\${orKey}.lt.\${advancedOps.lt}\`);
-                } else if ('lte' in advancedOps && advancedOps.lte !== undefined) {
-                  orParts.push(\`\${orKey}.lte.\${advancedOps.lte}\`);
-                } else if ('in' in advancedOps && advancedOps.in?.length) {
-                  orParts.push(\`\${orKey}.in.(\${advancedOps.in.join(',')})\`);
-                }
-              } else {
-                // Simple equality in OR condition
-                orParts.push(\`\${orKey}.eq.\${escapeFilterValue(orValue)}\`);
-              }
-            }
-          }
-        }
-        
-        if (orParts.length > 0) {
-          // @ts-ignore: Supabase typing issue
-          filteredQuery = filteredQuery.or(orParts.join(','));
-        }
-        continue;
-      }
-      
-      // Handle AND conditions (explicit)
-      if (key === 'AND' && Array.isArray(value)) {
-        // For explicit AND conditions, apply each condition normally
-        for (const andCondition of value) {
-          filteredQuery = applyFilter(filteredQuery, andCondition);
-        }
-        continue;
-      }
-      
       if (typeof value === 'object' && value !== null) {
         // Handle advanced operators
         const advancedOps = value as unknown as FilterOperators<any>;
@@ -614,112 +445,6 @@ export function applyOrderBy<T>(
   return orderedQuery;
 }
 
-/**
- * Client-side filter validation for realtime events
- */
-function clientSideFilterCheck<T>(record: any, where: T): boolean {
-  if (!where) return true;
-  
-  for (const [key, value] of Object.entries(where)) {
-    if (value !== undefined) {
-      // Handle OR conditions
-      if (key === 'OR' && Array.isArray(value)) {
-        // For OR, at least one condition must match
-        const orMatches = value.some(orCondition => clientSideFilterCheck(record, orCondition));
-        if (!orMatches) {
-          return false;
-        }
-        continue;
-      }
-      
-      // Handle AND conditions (explicit)
-      if (key === 'AND' && Array.isArray(value)) {
-        // For AND, all conditions must match
-        const andMatches = value.every(andCondition => clientSideFilterCheck(record, andCondition));
-        if (!andMatches) {
-          return false;
-        }
-        continue;
-      }
-      
-      if (typeof value === 'object' && value !== null) {
-        // Handle complex array filters client-side
-        const advancedOps = value as any;
-        const recordValue = record[key as keyof typeof record] 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))) {
-            return false;
-          }
-        } 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))) {
-            return false;
-          }
-        } 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))) {
-            return false;
-          }
-        } 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) {
-            return false;
-          }
-        } else if ('equals' in advancedOps && advancedOps.equals !== undefined) {
-          if (recordValue !== advancedOps.equals) {
-            return false;
-          }
-        } else if ('not' in advancedOps && advancedOps.not !== undefined) {
-          if (recordValue === advancedOps.not) {
-            return false;
-          }
-        } else if ('gt' in advancedOps && advancedOps.gt !== undefined) {
-          if (!(recordValue > advancedOps.gt)) {
-            return false;
-          }
-        } else if ('gte' in advancedOps && advancedOps.gte !== undefined) {
-          if (!(recordValue >= advancedOps.gte)) {
-            return false;
-          }
-        } else if ('lt' in advancedOps && advancedOps.lt !== undefined) {
-          if (!(recordValue < advancedOps.lt)) {
-            return false;
-          }
-        } else if ('lte' in advancedOps && advancedOps.lte !== undefined) {
-          if (!(recordValue <= advancedOps.lte)) {
-            return false;
-          }
-        } else if ('in' in advancedOps && advancedOps.in !== undefined) {
-          if (!advancedOps.in.includes(recordValue)) {
-            return false;
-          }
-        } else if ('contains' in advancedOps && advancedOps.contains !== undefined) {
-          if (!String(recordValue).toLowerCase().includes(String(advancedOps.contains).toLowerCase())) {
-            return false;
-          }
-        } else if ('startsWith' in advancedOps && advancedOps.startsWith !== undefined) {
-          if (!String(recordValue).toLowerCase().startsWith(String(advancedOps.startsWith).toLowerCase())) {
-            return false;
-          }
-        } else if ('endsWith' in advancedOps && advancedOps.endsWith !== undefined) {
-          if (!String(recordValue).toLowerCase().endsWith(String(advancedOps.endsWith).toLowerCase())) {
-            return false;
-          }
-        }
-      } else if (record[key as keyof typeof record] !== value) {
-        console.log(\`Filter mismatch on \${key}\`, { expected: value, actual: record[key as keyof typeof record] });
-        return false;
-      }
-    }
-  }
-  
-  return true;
-}
-
 /**
  * Core hook factory function that creates a type-safe realtime hook for a specific model.
  * This is the foundation for all Suparisma hooks.
@@ -763,23 +488,12 @@ export function createSuparismaHook<
    * const users = useSuparismaUser();
    * const { data, loading, error } = users;
    * 
-    * @example
- * // With filtering
- * const users = useSuparismaUser({ 
- *   where: { role: 'admin' },
- *   orderBy: { created_at: 'desc' }
- * });
- * 
- * @example
- * // With OR conditions for search
- * const users = useSuparismaUser({ 
- *   where: { 
- *     OR: [
- *       { name: { contains: "john" } },
- *       { email: { contains: "john" } }
- *     ]
- *   }
- * });
+   * @example
+   * // With filtering
+   * const users = useSuparismaUser({ 
+   *   where: { role: 'admin' },
+   *   orderBy: { created_at: 'desc' }
+   * });
    */
   return function useSuparismaHook(options: SuparismaOptions<TWhereInput, TOrderByInput> = {}) {
     const {
@@ -990,7 +704,19 @@ export function createSuparismaHook<
           
           // Apply any where conditions client-side
           if (where) {
-            results = results.filter((item) => clientSideFilterCheck(item, where));
+            results = results.filter((item) => {
+              for (const [key, value] of Object.entries(where)) {
+                if (typeof value === 'object' && value !== null) {
+                  // Skip complex filters for now
+                  continue;
+                }
+                
+                if (item[key as keyof typeof item] !== value) {
+                  return false;
+                }
+              }
+              return true;
+            });
           }
           
           // Set count directly for search results
@@ -1186,33 +912,19 @@ export function createSuparismaHook<
       
       const channelId = channelName || \`changes_to_\${tableName}_\${Math.random().toString(36).substring(2, 15)}\`;
       
-      // Check if we have complex array filters or OR/AND conditions that should be handled client-side only
+      // Check if we have complex array filters that should be handled client-side only
       let hasComplexArrayFilters = false;
       if (where) {
-        const checkForComplexFilters = (whereClause: any): boolean => {
-          for (const [key, value] of Object.entries(whereClause)) {
-            // OR/AND conditions require client-side filtering
-            if (key === 'OR' || key === 'AND') {
-              return true;
-            }
-            
-            if (typeof value === 'object' && value !== null) {
-              // Check if it's an array of conditions (nested OR/AND)
-              if (Array.isArray(value)) {
-                return true;
-              }
-              
-              const advancedOps = value as any;
-              // Check for complex array operators
-              if ('has' in advancedOps || 'hasEvery' in advancedOps || 'hasSome' in advancedOps || 'isEmpty' in advancedOps) {
-                return true;
-              }
+        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;
             }
           }
-          return false;
-        };
-        
-        hasComplexArrayFilters = checkForComplexFilters(where);
+        }
       }
       
       // For complex array filters, use no database filter and rely on client-side filtering
@@ -1269,7 +981,49 @@ export function createSuparismaHook<
                   // ALWAYS check if this record matches our filter client-side
                   // This is especially important for complex array filters
                   if (currentWhere) { // Use ref value
-                    const matchesFilter = clientSideFilterCheck(newRecord, currentWhere);
+                    let matchesFilter = true;
+                    
+                    // Check each filter condition client-side for complex filters
+                    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 = 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] });
+                        break;
+                      }
+                    }
                     
                     if (!matchesFilter) {
                       console.log('New record does not match filter criteria, skipping');
@@ -1355,7 +1109,46 @@ export function createSuparismaHook<
                 
                 // Check if the updated record still matches our current filter
                 if (currentWhere) {
-                  const matchesFilter = clientSideFilterCheck(updatedRecord, 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) {
@@ -2081,7 +1874,6 @@ export function createSuparismaHook<
       : api;
   };
 }
-
 `; // Ensure template literal is closed
     // Output to the UTILS_DIR
     const outputPath = path_1.default.join(config_1.UTILS_DIR, 'core.ts');

package/dist/generators/typeGenerator.js

@@ -118,44 +118,40 @@ function generateModelTypesFile(model) {
     // Generate imports section for zod custom types
     let customImports = '';
     if (model.zodImports && model.zodImports.length > 0) {
-        try {
-            // Get the zod schemas file path from environment variable
-            const zodSchemasPath = process.env.ZOD_SCHEMAS_FILE_PATH || '../commonTypes';
-            // Add custom imports with environment variable path, but make them conditional
-            const importStatements = model.zodImports
-                .map(zodImport => {
-                // Extract the types from the original import statement
-                const typeMatch = zodImport.importStatement.match(/import\s+{\s*([^}]+)\s*}\s+from/);
-                if (typeMatch) {
-                    const types = typeMatch[1].trim();
-                    return `// Optional: install zod and create the commonTypes file if you want type safety for JSON fields\n// import { ${types} } from '${zodSchemasPath}'`;
-                }
-                return `// ${zodImport.importStatement}`;
-            })
-                .join('\n') + '\n\n';
-            customImports += importStatements;
-            // Add type definitions for imported zod schemas as simple types
-            const customTypeDefinitions = model.zodImports
-                .flatMap(zodImport => zodImport.types)
-                .filter((type, index, array) => array.indexOf(type) === index) // Remove duplicates
-                .map(type => {
-                // If it ends with 'Schema', create a corresponding type as any for now
-                if (type.endsWith('Schema')) {
-                    const typeName = type.replace('Schema', '');
-                    return `// Fallback type - replace with actual type if you implement zod schemas\nexport type ${typeName} = any;`;
-                }
-                return '';
-            })
-                .filter(Boolean)
-                .join('\n');
-            if (customTypeDefinitions) {
-                customImports += customTypeDefinitions + '\n\n';
+        // Add zod import for type inference
+        customImports = 'import { z } from \'zod\';\n';
+        // Get the zod schemas file path from environment variable
+        const zodSchemasPath = process.env.ZOD_SCHEMAS_FILE_PATH || '../commonTypes';
+        // Add custom imports with environment variable path
+        customImports += model.zodImports
+            .map(zodImport => {
+            // Extract the types from the original import statement
+            const typeMatch = zodImport.importStatement.match(/import\s+{\s*([^}]+)\s*}\s+from/);
+            if (typeMatch) {
+                const types = typeMatch[1].trim();
+                return `import { ${types} } from '${zodSchemasPath}'`;
             }
-        }
-        catch (error) {
-            // If there's any error with zod imports, just use a fallback
-            console.warn('Warning: Skipping custom zod imports due to configuration issues');
-            customImports = '';
+            // Fallback to original import if parsing fails
+            return zodImport.importStatement;
+        })
+            .join('\n') + '\n\n';
+        // Add type definitions for imported zod schemas if needed
+        // This is a simplified approach - you might want to make this more sophisticated
+        const customTypeDefinitions = model.zodImports
+            .flatMap(zodImport => zodImport.types)
+            .filter((type, index, array) => array.indexOf(type) === index) // Remove duplicates
+            .map(type => {
+            // If it ends with 'Schema', create a corresponding type
+            if (type.endsWith('Schema')) {
+                const typeName = type.replace('Schema', '');
+                return `export type ${typeName} = z.infer<typeof ${type}>;`;
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+        if (customTypeDefinitions) {
+            customImports += customTypeDefinitions + '\n\n';
         }
     }
     // Generate the type content with TSDoc comments
@@ -268,28 +264,6 @@ ${withRelationsProps
         .join(',\n')}
  *   }
  * });
- * 
- * @example
- * // OR conditions - find records matching ANY condition
- * ${modelName.toLowerCase()}.findMany({
- *   where: {
- *     OR: [
- *       { name: "John" },
- *       { email: { contains: "@admin" } }
- *     ]
- *   }
- * });
- * 
- * @example
- * // AND conditions - find records matching ALL conditions
- * ${modelName.toLowerCase()}.findMany({
- *   where: {
- *     AND: [
- *       { active: true },
- *       { age: { gte: 18 } }
- *     ]
- *   }
- * });
  */
 export type ${modelName}WhereInput = {
 ${model.fields
@@ -311,12 +285,6 @@ ${model.fields
         }
         return '';
     }).filter(Boolean))
-        .concat([
-        '  /** OR condition - match records that satisfy ANY of the provided conditions */',
-        `  OR?: ${modelName}WhereInput[];`,
-        '  /** AND condition - match records that satisfy ALL of the provided conditions */',
-        `  AND?: ${modelName}WhereInput[];`
-    ])
         .join('\n')}
 };
 

package/package.json

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