suparisma 1.0.7 → 1.0.8

package/README.md

@@ -23,6 +23,7 @@ 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)
@@ -61,6 +62,7 @@ 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.
@@ -580,6 +582,215 @@ 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,6 +94,21 @@ 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>[];
 };
 
 /**
@@ -177,6 +192,19 @@ 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
  */
@@ -215,9 +243,73 @@ 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>;
@@ -265,19 +357,22 @@ 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)
-          const arrayValue = JSON.stringify(advancedOps.has);
+          // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
+          const arrayValue = \`{\${advancedOps.has.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
           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);
+          // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
+          const arrayValue = \`{\${advancedOps.hasEvery.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
           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);
+          // Use PostgreSQL array syntax: {item1,item2} not ["item1","item2"]
+          const arrayValue = \`{\${advancedOps.hasSome.map((item: any) => escapeFilterValue(item)).join(',')}}\`;
           filters.push(\`\${key}=ov.\${arrayValue}\`);
         }
         
@@ -297,7 +392,18 @@ export function buildFilterString<T>(where?: T): string | undefined {
     }
   }
   
-  return filters.length > 0 ? filters.join(',') : 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;
 }
 
 /**
@@ -314,6 +420,69 @@ 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>;
@@ -445,6 +614,112 @@ 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.
@@ -488,12 +763,23 @@ 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 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" } }
+ *     ]
+ *   }
+ * });
    */
   return function useSuparismaHook(options: SuparismaOptions<TWhereInput, TOrderByInput> = {}) {
     const {
@@ -704,19 +990,7 @@ export function createSuparismaHook<
           
           // Apply any where conditions client-side
           if (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;
-            });
+            results = results.filter((item) => clientSideFilterCheck(item, where));
           }
           
           // Set count directly for search results
@@ -912,19 +1186,33 @@ export function createSuparismaHook<
       
       const channelId = channelName || \`changes_to_\${tableName}_\${Math.random().toString(36).substring(2, 15)}\`;
       
-      // Check if we have complex array filters that should be handled client-side only
+      // Check if we have complex array filters or OR/AND conditions 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;
+        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;
+              }
             }
           }
-        }
+          return false;
+        };
+        
+        hasComplexArrayFilters = checkForComplexFilters(where);
       }
       
       // For complex array filters, use no database filter and rely on client-side filtering
@@ -981,49 +1269,7 @@ 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
-                    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;
-                      }
-                    }
+                    const matchesFilter = clientSideFilterCheck(newRecord, currentWhere);
                     
                     if (!matchesFilter) {
                       console.log('New record does not match filter criteria, skipping');
@@ -1109,46 +1355,7 @@ export function createSuparismaHook<
                 
                 // 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;
-                    }
-                  }
+                  const matchesFilter = clientSideFilterCheck(updatedRecord, currentWhere);
                   
                   // If the updated record doesn't match the filter, remove it from the list
                   if (!matchesFilter) {
@@ -1874,6 +2081,7 @@ 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,40 +118,44 @@ function generateModelTypesFile(model) {
     // Generate imports section for zod custom types
     let customImports = '';
     if (model.zodImports && model.zodImports.length > 0) {
-        // 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}'`;
+        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';
             }
-            // 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';
+        }
+        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 = '';
         }
     }
     // Generate the type content with TSDoc comments
@@ -264,6 +268,28 @@ ${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
@@ -285,6 +311,12 @@ ${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.7",
+	"version": "1.0.8",
 	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma.",
 	"main": "dist/index.js",
 	"repository": {