suparisma 1.0.7 → 1.0.9

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:
@@ -955,7 +1166,7 @@ async function handleSubmit(event) {
       name: formData.name,
       someNumber: parseInt(formData.number)
     });
-    console.log('Created!', result);
+    // Handle successful creation
   } catch (err) {
     console.error('Failed to create thing:', err);
   }

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,111 @@ 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) {
+        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 +762,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 +989,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 +1185,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
@@ -937,18 +1224,15 @@ export function createSuparismaHook<
       
       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
@@ -957,7 +1241,6 @@ export function createSuparismaHook<
           'postgres_changes',
           subscriptionConfig,
           (payload) => {
-            console.log(\`🔥 REALTIME EVENT RECEIVED for \${tableName}:\`, payload.eventType, payload);
             
             // Access current options via refs inside the event handler
             const currentWhere = whereRef.current;
@@ -967,7 +1250,6 @@ export function createSuparismaHook<
 
             // Skip realtime updates when search is active
             if (isSearchingRef.current) {
-              console.log('⏭️ Skipping realtime update - search is active');
               return;
             }
             
@@ -976,57 +1258,13 @@ export function createSuparismaHook<
               setData((prev) => {
                 try {
                   const newRecord = payload.new as TWithRelations;
-                  console.log(\`Processing INSERT for \${tableName}\`, { newRecord });
                   
                   // 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');
                       return prev;
                     }
                   }
@@ -1038,7 +1276,6 @@ export function createSuparismaHook<
                   );
                   
                   if (exists) {
-                    console.log('Record already exists, skipping insertion');
                     return prev;
                   }
                   
@@ -1109,50 +1346,10 @@ 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) {
-                    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)
@@ -1211,9 +1408,7 @@ 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;
@@ -1223,7 +1418,6 @@ export function createSuparismaHook<
 
                 // Skip if search is active
                 if (isSearchingRef.current) {
-                  console.log('⏭️ DELETE: Skipping - search is active');
                   return prev;
                 }
                 
@@ -1233,21 +1427,14 @@ export function createSuparismaHook<
                 // Filter out the deleted item
                 const filteredData = prev.filter((item) => {
                   // @ts-ignore: Supabase typing issue
-                  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;
+                  return !('id' in item && 'id' in payload.old && item.id === payload.old.id);
                 });
                 
-                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(\`🗑️ DELETE: Record deleted with limit \${currentLimit}, will fetch additional record to maintain size\`);
                   
                   // Use setTimeout to ensure this state update completes first
                   setTimeout(() => {
@@ -1305,19 +1492,16 @@ export function createSuparismaHook<
             }
           }
         )
-        .subscribe((status) => {
-          console.log(\`Subscription status for \${tableName}\`, status);
-        });
+        .subscribe();
       
       // Store the channel ref
       channelRef.current = channel;
         
-      return () => {
-        console.log(\`Unsubscribing from \${channelId}\`);
-        if (channelRef.current) {
-          supabase.removeChannel(channelRef.current); // Correct way to remove channel
-          channelRef.current = null;
-        }
+              return () => {
+          if (channelRef.current) {
+            supabase.removeChannel(channelRef.current); // Correct way to remove channel
+            channelRef.current = null;
+          }
         
         if (searchTimeoutRef.current) {
           clearTimeout(searchTimeoutRef.current);
@@ -1362,7 +1546,6 @@ export function createSuparismaHook<
       if (initialLoadRef.current) {
         // Only reload if options have changed significantly
         if (optionsChanged()) {
-          console.log(\`Options changed for \${tableName}, reloading data\`);
           findMany({
             where,
             orderBy,
@@ -1874,6 +2057,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');
@@ -1881,5 +2065,4 @@ export function createSuparismaHook<
         fs_1.default.mkdirSync(config_1.UTILS_DIR, { recursive: true });
     }
     fs_1.default.writeFileSync(outputPath, coreContent);
-    console.log(`Generated core utility file at ${outputPath}`);
 }

package/dist/generators/hookGenerator.js

@@ -113,5 +113,4 @@ export const ${config_1.HOOK_NAME_PREFIX}${modelName} = createSuparismaHook<
         fs_1.default.mkdirSync(config_1.HOOKS_DIR, { recursive: true });
     }
     fs_1.default.writeFileSync(outputPath, hookContent);
-    console.log(`Generated hook for ${modelName} at ${outputPath}`);
 }

package/dist/generators/indexGenerator.js

@@ -101,5 +101,4 @@ export default useSuparisma;
         fs_1.default.mkdirSync(config_1.OUTPUT_DIR, { recursive: true });
     }
     fs_1.default.writeFileSync(outputPath, content);
-    console.log(`Generated main module file at ${outputPath}`);
 }

package/dist/generators/supabaseClientGenerator.js

@@ -22,5 +22,4 @@ export const supabase = createClient(
         fs_1.default.mkdirSync(config_1.UTILS_DIR, { recursive: true });
     }
     fs_1.default.writeFileSync(outputPath, supabaseClientContent);
-    console.log(`🚀 Generated Supabase client file at: ${outputPath}`);
 }

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')}
 };
 
@@ -655,7 +687,6 @@ ${createInputProps
         fs_1.default.mkdirSync(config_1.TYPES_DIR, { recursive: true });
     }
     fs_1.default.writeFileSync(outputPath, typeContent);
-    console.log(`Generated type definitions for ${modelName} at ${outputPath}`);
     return {
         modelName,
         tableName,

package/dist/index.js

@@ -84,7 +84,6 @@ function checkEnvironmentVariables() {
         errorMessage += '\nPlease add these variables to your .env file or ensure they are available in your environment and try again.';
         throw new Error(errorMessage);
     }
-    console.log('✅ All required environment variables are set.');
 }
 function analyzePrismaSchema(schemaPath) {
     try {
@@ -148,8 +147,6 @@ function analyzePrismaSchema(schemaPath) {
  */
 async function configurePrismaTablesForSuparisma(schemaPath) {
     try {
-        // COMPLETELY BYPASS NORMAL OPERATION FOR SIMPLICITY
-        console.log('🔧 Using direct SQL approach to avoid PostgreSQL case sensitivity issues...');
         // Load environment variables
         dotenv.config();
         // Get direct PostgreSQL connection URL
@@ -162,7 +159,6 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
         const pg = await Promise.resolve().then(() => __importStar(require('pg')));
         const { Pool } = pg.default || pg;
         const pool = new Pool({ connectionString: process.env.DIRECT_URL });
-        console.log('🔌 Connected to PostgreSQL database for configuration.');
         const { rows: allTables } = await pool.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`);
         for (const model of modelInfos) {
             const matchingTable = allTables.find((t) => t.table_name.toLowerCase() === model.tableName.toLowerCase());
@@ -171,29 +167,20 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
                 continue;
             }
             const actualTableName = matchingTable.table_name;
-            console.log(`Processing model ${model.name} (table: "${actualTableName}")`);
             // Realtime setup (existing logic)
             if (model.enableRealtime) {
                 const alterPublicationQuery = `ALTER PUBLICATION supabase_realtime ADD TABLE "${actualTableName}";`;
                 try {
                     await pool.query(alterPublicationQuery);
-                    console.log(`  ✅ Added "${actualTableName}" to supabase_realtime publication for real-time updates.`);
                 }
                 catch (err) {
-                    if (err.message.includes('already member')) {
-                        console.log(`  ℹ️ Table "${actualTableName}" was already in supabase_realtime publication.`);
-                    }
-                    else {
+                    if (!err.message.includes('already member')) {
                         console.error(`  ❌ Failed to add "${actualTableName}" to supabase_realtime: ${err.message}`);
                     }
                 }
             }
-            else {
-                console.log(`  ℹ️ Realtime disabled for model ${model.name}.`);
-            }
             // Search setup
             if (model.searchFields.length > 0) {
-                console.log(`  🔍 Setting up full-text search for model ${model.name}:`);
                 const { rows: columns } = await pool.query(`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = $1`, [actualTableName]);
                 for (const searchField of model.searchFields) {
                     const matchingColumn = columns.find((c) => c.column_name.toLowerCase() === searchField.name.toLowerCase());
@@ -204,7 +191,6 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
                     const actualColumnName = matchingColumn.column_name;
                     const functionName = `search_${actualTableName.toLowerCase()}_by_${actualColumnName.toLowerCase()}_prefix`;
                     const indexName = `idx_gin_search_${actualTableName.toLowerCase()}_${actualColumnName.toLowerCase()}`;
-                    console.log(`    ➡️ Configuring field "${actualColumnName}":`);
                     try {
                         // Create search function
                         const createFunctionQuery = `
@@ -217,7 +203,6 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
               END;
               $$ LANGUAGE plpgsql STABLE;`; // Added STABLE for potential performance benefits
                         await pool.query(createFunctionQuery);
-                        console.log(`      ✅ Created/Replaced RPC function: "${functionName}"(search_prefix text)`);
                         // Create GIN index
                         const createIndexQuery = `
               DO $$
@@ -229,39 +214,21 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
                   AND indexname = '${indexName}'
                 ) THEN
                   CREATE INDEX "${indexName}" ON "public"."${actualTableName}" USING GIN (to_tsvector('english', "${actualColumnName}"));
-                  RAISE NOTICE '      ✅ Created GIN index: "${indexName}" on "${actualTableName}"("${actualColumnName}")';
-                ELSE
-                  RAISE NOTICE '      ℹ️ GIN index "${indexName}" on "${actualTableName}"("${actualColumnName}") already exists.';
                 END IF;
               END;
               $$;`;
-                        const indexResult = await pool.query(createIndexQuery);
-                        // Output notices from the DO $$ block (PostgreSQL specific)
-                        if (indexResult.rows.length > 0 && indexResult.rows[0].notice) {
-                            console.log(indexResult.rows[0].notice.replace(/^NOTICE:  /, ''));
-                        }
-                        else if (!indexResult.rows.find((r) => r.notice?.includes('Created GIN index'))) {
-                            // If DO $$ block doesn't emit specific notice for creation and it didn't say exists.
-                            // This is a fallback log, actual creation/existence is handled by the DO block.
-                            // The important part is that the index will be there.
-                        }
+                        await pool.query(createIndexQuery);
                     }
                     catch (err) {
                         console.error(`      ❌ Failed to set up search for "${actualTableName}"."${actualColumnName}": ${err.message}`);
                     }
                 }
             }
-            else {
-                console.log(`  ℹ️ No fields marked with // @enableSearch for model ${model.name}.`);
-            }
-            console.log('---------------------------------------------------');
         }
         await pool.end();
-        console.log('🎉 Database configuration complete.');
     }
     catch (err) {
         console.error('❌ Error during database configuration:', err);
-        console.log('⚠️ Hook generation will continue, but database features like search or realtime might not be fully configured.');
     }
 }
 /**
@@ -269,22 +236,16 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
  */
 async function generateHooks() {
     try {
-        console.log('🚀 Starting Suparisma hook generation...');
         checkEnvironmentVariables();
-        console.log(`Prisma schema path: ${config_1.PRISMA_SCHEMA_PATH}`);
-        console.log(`Output directory: ${config_1.OUTPUT_DIR}`);
         // Delete the entire output directory if it exists to clean up any stale files
         if (fs_1.default.existsSync(config_1.OUTPUT_DIR)) {
-            console.log(`🧹 Cleaning up previous generated files in ${config_1.OUTPUT_DIR}...`);
             fs_1.default.rmSync(config_1.OUTPUT_DIR, { recursive: true, force: true });
-            console.log(`✅ Removed previous generated directory`);
         }
         // Ensure all specific output directories exist, OUTPUT_DIR is the root and will be created if needed by sub-creations.
         const dirsToEnsure = [config_1.TYPES_DIR, config_1.HOOKS_DIR, config_1.UTILS_DIR];
         dirsToEnsure.forEach(dir => {
             if (!fs_1.default.existsSync(dir)) {
                 fs_1.default.mkdirSync(dir, { recursive: true });
-                console.log(`Created directory: ${dir}`);
             }
         });
         // Generate Supabase client file (goes to UTILS_DIR)
@@ -300,7 +261,6 @@ async function generateHooks() {
             modelInfos.push(modelInfo);
         }
         (0, indexGenerator_1.generateMainIndexFile)(modelInfos);
-        console.log(`✅ Successfully generated all suparisma hooks and types in "${config_1.OUTPUT_DIR}"!`);
     }
     catch (error) {
         console.error('❌ Error generating hooks:', error);

package/package.json

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