suparisma 1.0.9 → 1.1.0

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

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,111 +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) {
-        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.
@@ -762,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 {
@@ -989,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
@@ -1185,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
@@ -1224,15 +937,18 @@ 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
@@ -1241,6 +957,7 @@ 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;
@@ -1250,6 +967,7 @@ export function createSuparismaHook<
 
             // Skip realtime updates when search is active
             if (isSearchingRef.current) {
+              console.log('⏭️ Skipping realtime update - search is active');
               return;
             }
             
@@ -1258,13 +976,57 @@ 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
-                    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');
                       return prev;
                     }
                   }
@@ -1276,6 +1038,7 @@ export function createSuparismaHook<
                   );
                   
                   if (exists) {
+                    console.log('Record already exists, skipping insertion');
                     return prev;
                   }
                   
@@ -1346,10 +1109,50 @@ 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) {
+                    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)
@@ -1408,7 +1211,9 @@ 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;
@@ -1418,6 +1223,7 @@ export function createSuparismaHook<
 
                 // Skip if search is active
                 if (isSearchingRef.current) {
+                  console.log('⏭️ DELETE: Skipping - search is active');
                   return prev;
                 }
                 
@@ -1427,14 +1233,21 @@ export function createSuparismaHook<
                 // Filter out the deleted item
                 const filteredData = prev.filter((item) => {
                   // @ts-ignore: Supabase typing issue
-                  return !('id' in item && 'id' in payload.old && item.id === payload.old.id);
+                  const shouldKeep = !('id' in item && 'id' in payload.old && item.id === payload.old.id);
+                  if (!shouldKeep) {
+                    console.log('🗑️ DELETE: Removing item with ID:', item.id);
+                  }
+                  return shouldKeep;
                 });
                 
+                console.log('🗑️ DELETE: Data after deletion:', filteredData.length, 'items (was', currentSize, ')');
+                
                 // Fetch the updated count after the data changes
                 setTimeout(() => fetchTotalCount(), 0);
                 
                 // If we need to maintain the size with a limit
                 if (currentLimit && currentLimit > 0 && filteredData.length < currentSize && currentSize === currentLimit) { // Use ref value
+                  console.log(\`🗑️ DELETE: Record deleted with limit \${currentLimit}, will fetch additional record to maintain size\`);
                   
                   // Use setTimeout to ensure this state update completes first
                   setTimeout(() => {
@@ -1492,16 +1305,19 @@ export function createSuparismaHook<
             }
           }
         )
-        .subscribe();
+        .subscribe((status) => {
+          console.log(\`Subscription status for \${tableName}\`, status);
+        });
       
       // Store the channel ref
       channelRef.current = channel;
         
-              return () => {
-          if (channelRef.current) {
-            supabase.removeChannel(channelRef.current); // Correct way to remove channel
-            channelRef.current = null;
-          }
+      return () => {
+        console.log(\`Unsubscribing from \${channelId}\`);
+        if (channelRef.current) {
+          supabase.removeChannel(channelRef.current); // Correct way to remove channel
+          channelRef.current = null;
+        }
         
         if (searchTimeoutRef.current) {
           clearTimeout(searchTimeoutRef.current);
@@ -1546,6 +1362,7 @@ 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,
@@ -1575,6 +1392,8 @@ export function createSuparismaHook<
     /**
      * Create a new record with the provided data.
      * Default values from the schema will be applied if not provided.
+     * NOTE: This operation does NOT immediately update the local state.
+     * The state will be updated when the realtime INSERT event is received.
      * 
      * @param data - The data to create the record with
      * @returns A promise with the created record or error
@@ -1647,8 +1466,8 @@ export function createSuparismaHook<
         
         if (error) throw error;
         
-        // Update the total count after a successful creation
-        setTimeout(() => fetchTotalCount(), 0);
+        // DO NOT UPDATE LOCAL STATE HERE - Let realtime INSERT event handle it
+        console.log('✅ Created ' + tableName + ' record, waiting for realtime INSERT event to update state');
         
         // Return created record
         return { data: result?.[0] as TWithRelations, error: null };
@@ -1659,10 +1478,12 @@ export function createSuparismaHook<
       } finally {
         setLoading(false);
       }
-    }, [fetchTotalCount]);
+    }, []);
 
     /**
      * Update an existing record identified by a unique identifier.
+     * NOTE: This operation does NOT immediately update the local state.
+     * The state will be updated when the realtime UPDATE event is received.
      * 
      * @param params - Object containing the identifier and update data
      * @returns A promise with the updated record or error
@@ -1724,10 +1545,8 @@ export function createSuparismaHook<
         
         if (error) throw error;
         
-        // Update the total count after a successful update
-        // This is for consistency with other operations, and because
-        // updates can sometimes affect filtering based on updated values
-        setTimeout(() => fetchTotalCount(), 0);
+        // DO NOT UPDATE LOCAL STATE HERE - Let realtime UPDATE event handle it
+        console.log('✅ Updated ' + tableName + ' record, waiting for realtime UPDATE event to update state');
         
         // Return updated record
         return { data: data?.[0] as TWithRelations, error: null };
@@ -1738,10 +1557,12 @@ export function createSuparismaHook<
       } finally {
         setLoading(false);
       }
-    }, [fetchTotalCount]);
+    }, []);
 
     /**
      * Delete a record by its unique identifier.
+     * NOTE: This operation does NOT immediately update the local state.
+     * The state will be updated when the realtime DELETE event is received.
      * 
      * @param where - The unique identifier to delete the record by
      * @returns A promise with the deleted record or error
@@ -1791,8 +1612,8 @@ export function createSuparismaHook<
         
         if (error) throw error;
         
-        // Update the total count after a successful deletion
-        setTimeout(() => fetchTotalCount(), 0);
+        // DO NOT UPDATE LOCAL STATE HERE - Let realtime DELETE event handle it
+        console.log('✅ Deleted ' + tableName + ' record, waiting for realtime DELETE event to update state');
         
         // Return the deleted record
         return { data: recordToDelete as TWithRelations, error: null };
@@ -1803,10 +1624,12 @@ export function createSuparismaHook<
       } finally {
         setLoading(false);
       }
-    }, [fetchTotalCount]);
+    }, []);
 
     /**
      * Delete multiple records matching the filter criteria.
+     * NOTE: This operation does NOT immediately update the local state.
+     * The state will be updated when realtime DELETE events are received for each record.
      * 
      * @param params - Query parameters for filtering records to delete
      * @returns A promise with the count of deleted records or error
@@ -1816,7 +1639,7 @@ export function createSuparismaHook<
      * const result = await users.deleteMany({
      *   where: { active: false }
      * });
-     * console.log(\`Deleted \${result.count} inactive users\`);
+     * console.log('Deleted ' + result.count + ' inactive users');
      * 
      * @example
      * // Delete all records (use with caution!)
@@ -1860,8 +1683,8 @@ export function createSuparismaHook<
         
         if (deleteError) throw deleteError;
         
-        // Update the total count after a successful bulk deletion
-        setTimeout(() => fetchTotalCount(), 0);
+        // DO NOT UPDATE LOCAL STATE HERE - Let realtime DELETE events handle it
+        console.log('✅ Deleted ' + recordsToDelete.length + ' ' + tableName + ' records, waiting for realtime DELETE events to update state');
         
         // Return the count of deleted records
         return { count: recordsToDelete.length, error: null };
@@ -1872,7 +1695,7 @@ export function createSuparismaHook<
       } finally {
         setLoading(false);
       }
-    }, [fetchTotalCount]);
+    }, []);
 
     /**
      * Find the first record matching the filter criteria.
@@ -2057,7 +1880,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');
@@ -2065,4 +1887,5 @@ 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,4 +113,5 @@ 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,4 +101,5 @@ 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,4 +22,5 @@ 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,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')}
 };
 
@@ -687,6 +655,7 @@ ${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,6 +84,7 @@ 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 {
@@ -147,6 +148,8 @@ 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
@@ -159,6 +162,7 @@ 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());
@@ -167,20 +171,29 @@ 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')) {
+                    if (err.message.includes('already member')) {
+                        console.log(`  ℹ️ Table "${actualTableName}" was already in supabase_realtime publication.`);
+                    }
+                    else {
                         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());
@@ -191,6 +204,7 @@ 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 = `
@@ -203,6 +217,7 @@ 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 $$
@@ -214,21 +229,39 @@ 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;
               $$;`;
-                        await pool.query(createIndexQuery);
+                        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.
+                        }
                     }
                     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.');
     }
 }
 /**
@@ -236,16 +269,22 @@ 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)
@@ -261,6 +300,7 @@ 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.9",
+	"version": "1.1.0",
 	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma.",
 	"main": "dist/index.js",
 	"repository": {