suparisma 0.0.1

package/dist/generators/coreGenerator.js

@@ -0,0 +1,1430 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCoreFile = generateCoreFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../config");
+/**
+ * Generate core hook factory file
+ */
+function generateCoreFile() {
+    const coreContent = `// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+// Edit the generator script instead: scripts/generate-realtime-hooks.ts
+
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { supabase } from '../supabase-client-generated';
+
+/**
+ * Represents a single search query against a field
+ * @example
+ * // Search for users with names containing "john"
+ * const query = { field: "name", value: "john" };
+ */
+export type SearchQuery = {
+  /** The field name to search in */
+  field: string;
+  /** The search term/value to look for */
+  value: string;
+};
+
+// Define type for Supabase query builder
+export type SupabaseQueryBuilder = ReturnType<ReturnType<typeof supabase.from>['select']>;
+
+/**
+ * Advanced filter operators for complex queries
+ * @example
+ * // Users older than 21
+ * { age: { gt: 21 } }
+ * 
+ * @example
+ * // Posts with titles containing "news"
+ * { title: { contains: "news" } }
+ */
+export type FilterOperators<T> = {
+  /** Equal to value */
+  equals?: T;
+  /** Not equal to value */
+  not?: T;
+  /** Value is in the array */
+  in?: T[];
+  /** Value is not in the array */
+  notIn?: T[];
+  /** Less than value */
+  lt?: T;
+  /** Less than or equal to value */
+  lte?: T;
+  /** Greater than value */
+  gt?: T;
+  /** Greater than or equal to value */
+  gte?: T;
+  /** String contains value (case insensitive) */
+  contains?: string;
+  /** String starts with value (case insensitive) */
+  startsWith?: string;
+  /** String ends with value (case insensitive) */
+  endsWith?: string;
+};
+
+// Type for a single field in an advanced where filter
+export type AdvancedWhereInput<T> = {
+  [K in keyof T]?: T[K] | FilterOperators<T[K]>;
+};
+
+/**
+ * Configuration options for the Suparisma hooks
+ * @example
+ * // Basic usage
+ * const { data } = useSuparismaUser();
+ * 
+ * @example
+ * // With filtering
+ * const { data } = useSuparismaUser({
+ *   where: { age: { gt: 21 } }
+ * });
+ * 
+ * @example
+ * // With ordering and limits
+ * const { data } = useSuparismaUser({
+ *   orderBy: { created_at: 'desc' },
+ *   limit: 10
+ * });
+ */
+export type SuparismaOptions<TWhereInput, TOrderByInput> = {
+  /** Whether to enable realtime updates (default: true) */
+  realtime?: boolean;
+  /** Custom channel name for realtime subscription */
+  channelName?: string;
+  /** Type-safe filter for queries and realtime events */
+  where?: TWhereInput;
+  /** Legacy string filter (use 'where' instead for type safety) */
+  realtimeFilter?: string;
+  /** Type-safe ordering for queries */
+  orderBy?: TOrderByInput;
+  /** Limit the number of records returned */
+  limit?: number;
+  /** Offset for pagination (skip records) */
+  offset?: number;
+};
+
+/**
+ * Return type for database operations
+ * @example
+ * const result = await users.create({ name: "John" });
+ * if (result.error) {
+ *   console.error(result.error);
+ * } else {
+ *   console.log(result.data);
+ * }
+ */
+export type ModelResult<T> = Promise<{
+  data: T;
+  error: null;
+} | {
+  data: null;
+  error: Error;
+}>;
+
+/**
+ * Complete search state and methods for searchable models
+ * @example
+ * // Search for users with name containing "john"
+ * users.search.addQuery({ field: "name", value: "john" });
+ * 
+ * @example
+ * // Check if search is loading
+ * if (users.search.loading) {
+ *   return <div>Searching...</div>;
+ * }
+ */
+export type SearchState = {
+  /** Current active search queries */
+  queries: SearchQuery[];
+  /** Whether a search is currently in progress */
+  loading: boolean;
+  /** Replace all search queries with a new set */
+  setQueries: (queries: SearchQuery[]) => void;
+  /** Add a new search query (replaces existing query for same field) */
+  addQuery: (query: SearchQuery) => void;
+  /** Remove a search query by field name */
+  removeQuery: (field: string) => void;
+  /** Clear all search queries and return to normal data fetching */
+  clearQueries: () => void;
+};
+
+/**
+ * Convert a type-safe where filter to Supabase filter string
+ */
+export function buildFilterString<T>(where?: T): string | undefined {
+  if (!where) return undefined;
+  
+  const filters: string[] = [];
+  
+  for (const [key, value] of Object.entries(where)) {
+    if (value !== undefined) {
+      if (typeof value === 'object' && value !== null) {
+        // Handle advanced operators
+        const advancedOps = value as unknown as FilterOperators<any>;
+        
+        if ('equals' in advancedOps && advancedOps.equals !== undefined) {
+          filters.push(\`\${key}=eq.\${advancedOps.equals}\`);
+        }
+        
+        if ('not' in advancedOps && advancedOps.not !== undefined) {
+          filters.push(\`\${key}=neq.\${advancedOps.not}\`);
+        }
+        
+        if ('gt' in advancedOps && advancedOps.gt !== undefined) {
+          filters.push(\`\${key}=gt.\${advancedOps.gt}\`);
+        }
+        
+        if ('gte' in advancedOps && advancedOps.gte !== undefined) {
+          filters.push(\`\${key}=gte.\${advancedOps.gte}\`);
+        }
+        
+        if ('lt' in advancedOps && advancedOps.lt !== undefined) {
+          filters.push(\`\${key}=lt.\${advancedOps.lt}\`);
+        }
+        
+        if ('lte' in advancedOps && advancedOps.lte !== undefined) {
+          filters.push(\`\${key}=lte.\${advancedOps.lte}\`);
+        }
+        
+        if ('in' in advancedOps && advancedOps.in?.length) {
+          filters.push(\`\${key}=in.(\${advancedOps.in.join(',')})\`);
+        }
+        
+        if ('contains' in advancedOps && advancedOps.contains !== undefined) {
+          filters.push(\`\${key}=ilike.*\${advancedOps.contains}*\`);
+        }
+        
+        if ('startsWith' in advancedOps && advancedOps.startsWith !== undefined) {
+          filters.push(\`\${key}=ilike.\${advancedOps.startsWith}%\`);
+        }
+        
+        if ('endsWith' in advancedOps && advancedOps.endsWith !== undefined) {
+          filters.push(\`\${key}=ilike.%\${advancedOps.endsWith}\`);
+        }
+      } else {
+        // Simple equality
+        filters.push(\`\${key}=eq.\${value}\`);
+      }
+    }
+  }
+  
+  return filters.length > 0 ? filters.join(',') : undefined;
+}
+
+/**
+ * Apply filter to the query builder
+ */
+export function applyFilter<T>(
+  query: SupabaseQueryBuilder, 
+  where: T
+): SupabaseQueryBuilder {
+  if (!where) return query;
+
+  let filteredQuery = query;
+  
+  // Apply each filter condition
+  for (const [key, value] of Object.entries(where)) {
+    if (value !== undefined) {
+      if (typeof value === 'object' && value !== null) {
+        // Handle advanced operators
+        const advancedOps = value as unknown as FilterOperators<any>;
+        
+        if ('equals' in advancedOps && advancedOps.equals !== undefined) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.eq(key, advancedOps.equals);
+        }
+        
+        if ('not' in advancedOps && advancedOps.not !== undefined) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.neq(key, advancedOps.not);
+        }
+        
+        if ('gt' in advancedOps && advancedOps.gt !== undefined) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.gt(key, advancedOps.gt);
+        }
+        
+        if ('gte' in advancedOps && advancedOps.gte !== undefined) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.gte(key, advancedOps.gte);
+        }
+        
+        if ('lt' in advancedOps && advancedOps.lt !== undefined) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.lt(key, advancedOps.lt);
+        }
+        
+        if ('lte' in advancedOps && advancedOps.lte !== undefined) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.lte(key, advancedOps.lte);
+        }
+        
+        if ('in' in advancedOps && advancedOps.in?.length) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.in(key, advancedOps.in);
+        }
+        
+        if ('contains' in advancedOps && advancedOps.contains !== undefined) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.ilike(key, \`*\${advancedOps.contains}*\`);
+        }
+        
+        if ('startsWith' in advancedOps && advancedOps.startsWith !== undefined) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.ilike(key, \`\${advancedOps.startsWith}%\`);
+        }
+        
+        if ('endsWith' in advancedOps && advancedOps.endsWith !== undefined) {
+          // @ts-ignore: Supabase typing issue
+          filteredQuery = filteredQuery.ilike(key, \`%\${advancedOps.endsWith}\`);
+        }
+      } else {
+        // Simple equality
+        // @ts-ignore: Supabase typing issue
+        filteredQuery = filteredQuery.eq(key, value);
+      }
+    }
+  }
+  
+  return filteredQuery;
+}
+
+/**
+ * Apply order by to the query builder
+ */
+export function applyOrderBy<T>(
+  query: SupabaseQueryBuilder,
+  orderBy?: T,
+  hasCreatedAt?: boolean
+): SupabaseQueryBuilder {
+  if (!orderBy) {
+    // By default, sort by created_at if available
+    if (hasCreatedAt) {
+      // @ts-ignore: Supabase typing issue
+      return query.order('created_at', { ascending: false });
+    }
+    return query;
+  }
+  
+  // Apply each order by clause
+  let orderedQuery = query;
+  for (const [key, direction] of Object.entries(orderBy)) {
+    // @ts-ignore: Supabase typing issue
+    orderedQuery = orderedQuery.order(key, {
+      ascending: direction === 'asc'
+    });
+  }
+  
+  return orderedQuery;
+}
+
+/**
+ * Core hook factory function that creates a type-safe realtime hook for a specific model.
+ * This is the foundation for all Suparisma hooks.
+ */
+export function createSuparismaHook<
+  TModel,
+  TWithRelations,
+  TCreateInput,
+  TUpdateInput,
+  TWhereInput,
+  TWhereUniqueInput,
+  TOrderByInput
+>(config: {
+  tableName: string;
+  hasCreatedAt: boolean;
+  hasUpdatedAt: boolean;
+  searchFields?: string[];
+  defaultValues?: Record<string, string>; // Added parameter for default values
+}) {
+  const { tableName, hasCreatedAt, hasUpdatedAt, searchFields = [], defaultValues = {} } = config;
+  
+  /**
+   * The main hook function that provides all data access methods for a model.
+   * 
+   * @param options - Optional configuration for data fetching, filtering, and realtime
+   * 
+   * @returns An API object with data state and CRUD methods
+   * 
+   * @example
+   * // Basic usage
+   * const users = useSuparismaUser();
+   * const { data, loading, error } = users;
+   * 
+   * @example
+   * // With filtering
+   * const users = useSuparismaUser({ 
+   *   where: { role: 'admin' },
+   *   orderBy: { created_at: 'desc' }
+   * });
+   */
+  return function useSuparismaHook(options: SuparismaOptions<TWhereInput, TOrderByInput> = {}) {
+    const {
+      realtime = true,
+      channelName,
+      where,
+      realtimeFilter,
+      orderBy,
+      limit,
+      offset,
+    } = options;
+    
+    // Compute the actual filter string from the type-safe where object or use legacy filter
+    const computedFilter = where ? buildFilterString(where) : realtimeFilter;
+    
+    // Single data collection for holding results
+    const [data, setData] = useState<TWithRelations[]>([]);
+    const [error, setError] = useState<Error | null>(null);
+    const [loading, setLoading] = useState<boolean>(false);
+    
+    // Search state
+    const [searchQueries, setSearchQueries] = useState<SearchQuery[]>([]);
+    const [searchLoading, setSearchLoading] = useState<boolean>(false);
+    
+    const initialLoadRef = useRef(false);
+    const channelRef = useRef<ReturnType<typeof supabase.channel> | null>(null);
+    const searchTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+    const isSearchingRef = useRef<boolean>(false);
+    
+    // Create the search state object with all required methods
+    const search: SearchState = {
+      queries: searchQueries,
+      loading: searchLoading,
+      
+      // Set all search queries at once
+      setQueries: useCallback((queries: SearchQuery[]) => {
+        // Validate that all fields are searchable
+        const validQueries = queries.filter(query => 
+          searchFields.includes(query.field) && query.value.trim() !== ''
+        );
+        
+        setSearchQueries(validQueries);
+        
+        // Execute search if there are valid queries
+        if (validQueries.length > 0) {
+          executeSearch(validQueries);
+        } else {
+          // If no valid queries, reset to normal data fetching
+          isSearchingRef.current = false;
+          findMany({ where, orderBy, take: limit, skip: offset });
+        }
+      }, [where, orderBy, limit, offset]),
+      
+      // Add a single search query
+      addQuery: useCallback((query: SearchQuery) => {
+        // Validate that the field is searchable
+        if (!searchFields.includes(query.field) || query.value.trim() === '') {
+          return;
+        }
+        
+        setSearchQueries(prev => {
+          // Replace if query for this field already exists, otherwise add
+          const exists = prev.some(q => q.field === query.field);
+          const newQueries = exists 
+            ? prev.map(q => q.field === query.field ? query : q)
+            : [...prev, query];
+            
+          // Execute search with updated queries
+          executeSearch(newQueries);
+          
+          return newQueries;
+        });
+      }, []),
+      
+      // Remove a search query by field
+      removeQuery: useCallback((field: string) => {
+        setSearchQueries(prev => {
+          const newQueries = prev.filter(q => q.field !== field);
+          
+          // If we still have queries, execute search with remaining queries
+          if (newQueries.length > 0) {
+            executeSearch(newQueries);
+          } else {
+            // If no queries left, reset to normal data fetching
+            isSearchingRef.current = false;
+            findMany({ where, orderBy, take: limit, skip: offset });
+          }
+          
+          return newQueries;
+        });
+      }, [where, orderBy, limit, offset]),
+      
+      // Clear all search queries
+      clearQueries: useCallback(() => {
+        setSearchQueries([]);
+        isSearchingRef.current = false;
+        findMany({ where, orderBy, take: limit, skip: offset });
+      }, [where, orderBy, limit, offset])
+    };
+    
+    // Execute search based on queries
+    const executeSearch = useCallback(async (queries: SearchQuery[]) => {
+      // Clear the previous timeout
+      if (searchTimeoutRef.current) {
+        clearTimeout(searchTimeoutRef.current);
+      }
+      
+      // Skip if no searchable fields or no valid queries
+      if (searchFields.length === 0 || queries.length === 0) {
+        return;
+      }
+      
+      setSearchLoading(true);
+      isSearchingRef.current = true;
+      
+      // Use debounce to prevent rapid searches
+      searchTimeoutRef.current = setTimeout(async () => {
+        try {
+          let results: TWithRelations[] = [];
+          
+          // Execute RPC function for each query using Promise.all
+          const searchPromises = queries.map(query => {
+            // Build function name: search_tablename_by_fieldname_prefix
+            const functionName = \`search_\${tableName}_by_\${query.field}_prefix\`;
+            
+            // Call RPC function
+            return supabase.rpc(functionName, { prefix: query.value.trim() });
+          });
+          
+          // Execute all search queries in parallel
+          const searchResults = await Promise.all(searchPromises);
+          
+          // Combine and deduplicate results
+          const allResults: Record<string, TWithRelations> = {};
+          
+          // Process each search result
+          searchResults.forEach((result, index) => {
+            if (result.error) {
+              console.error(\`Search error for \${queries[index]?.field}:\`, result.error);
+              return;
+            }
+            
+            if (result.data) {
+              // Add each result, using id as key to deduplicate
+              for (const item of result.data as TWithRelations[]) {
+                // @ts-ignore: Assume item has an id property
+                if (item.id) {
+                  // @ts-ignore: Add to results using id as key
+                  allResults[item.id] = item;
+                }
+              }
+            }
+          });
+          
+          // Convert back to array
+          results = Object.values(allResults);
+          
+          // 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;
+            });
+          }
+          
+          // Apply ordering if needed
+          if (orderBy) {
+            const orderEntries = Object.entries(orderBy);
+            if (orderEntries.length > 0) {
+              const [orderField, direction] = orderEntries[0] || [];
+              results = [...results].sort((a, b) => {
+                const aValue = a[orderField as keyof typeof a] ?? '';
+                const bValue = b[orderField as keyof typeof b] ?? '';
+                
+                if (direction === 'asc') {
+                  return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
+                } else {
+                  return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
+                }
+              });
+            }
+          }
+          
+          // Apply pagination if needed
+          if (limit && limit > 0) {
+            results = results.slice(0, limit);
+          }
+          
+          if (offset && offset > 0) {
+            results = results.slice(offset);
+          }
+          
+          // Update data with search results
+          setData(results);
+        } catch (err) {
+          console.error('Search error:', err);
+          setError(err as Error);
+        } finally {
+          setSearchLoading(false);
+        }
+      }, 300); // 300ms debounce
+    }, [tableName, searchFields, where, orderBy, limit, offset]);
+
+    /**
+     * Fetch multiple records with support for filtering, sorting, and pagination.
+     * 
+     * @param params - Query parameters for filtering and ordering records
+     * @returns A promise with the fetched data or error
+     * 
+     * @example
+     * // Get all active users
+     * const result = await users.findMany({
+     *   where: { active: true }
+     * });
+     * 
+     * @example
+     * // Get 10 most recent posts with pagination
+     * const page1 = await posts.findMany({
+     *   orderBy: { created_at: 'desc' },
+     *   take: 10,
+     *   skip: 0
+     * });
+     * 
+     * const page2 = await posts.findMany({
+     *   orderBy: { created_at: 'desc' },
+     *   take: 10,
+     *   skip: 10
+     * });
+     */
+    const findMany = useCallback(async (params?: {
+      where?: TWhereInput;
+      orderBy?: TOrderByInput;
+      take?: number;
+      skip?: number;
+    }): ModelResult<TWithRelations[]> => {
+      try {
+        setLoading(true);
+        setError(null);
+        
+        let query = supabase.from(tableName).select('*');
+        
+        // Apply where conditions if provided
+        if (params?.where) {
+          query = applyFilter(query, params.where);
+        }
+        
+        // Apply order by if provided
+        if (params?.orderBy) {
+          query = applyOrderBy(query, params.orderBy, hasCreatedAt);
+        } else if (hasCreatedAt) {
+          // Default ordering if available
+          // @ts-ignore: Supabase typing issue
+          query = query.order('created_at', { ascending: false });
+        }
+        
+        // Apply limit if provided
+        if (params?.take) {
+          query = query.limit(params.take);
+        }
+        
+        // Apply offset if provided (for pagination)
+        if (params?.skip) {
+          query = query.range(params.skip, params.skip + (params.take || 10) - 1);
+        }
+        
+        const { data, error } = await query;
+        
+        if (error) throw error;
+        
+        const typedData = (data || []) as TWithRelations[];
+        
+        // Only update data if not currently searching
+        if (!isSearchingRef.current) {
+          setData(typedData);
+        }
+        
+        return { data: typedData, error: null };
+      } catch (err: any) {
+        console.error('Error finding records:', err);
+        setError(err);
+        return { data: null, error: err };
+      } finally {
+        setLoading(false);
+      }
+    }, []);
+
+    /**
+     * Find a single record by its unique identifier (usually ID).
+     * 
+     * @param where - The unique identifier to find the record by
+     * @returns A promise with the found record or error
+     * 
+     * @example
+     * // Find user by ID
+     * const result = await users.findUnique({ id: "123" });
+     * if (result.data) {
+     *   console.log("Found user:", result.data.name);
+     * }
+     */
+    const findUnique = useCallback(async (
+      where: TWhereUniqueInput
+    ): ModelResult<TWithRelations> => {
+      try {
+        setLoading(true);
+        setError(null);
+        
+        // Find the primary field (usually 'id')
+        // @ts-ignore: Supabase typing issue
+        const primaryKey = Object.keys(where)[0];
+        if (!primaryKey) {
+          throw new Error('A unique identifier is required');
+        }
+        
+        const value = where[primaryKey as keyof typeof where];
+        if (value === undefined) {
+          throw new Error('A unique identifier is required');
+        }
+        
+        const { data, error } = await supabase
+          .from(tableName)
+          .select('*')
+          .eq(primaryKey, value)
+          .maybeSingle();
+        
+        if (error) throw error;
+        
+        return { data: data as TWithRelations, error: null };
+      } catch (err: any) {
+        console.error('Error finding unique record:', err);
+        setError(err);
+        return { data: null, error: err };
+      } finally {
+        setLoading(false);
+      }
+    }, []);
+
+    // Set up realtime subscription for the list
+    useEffect(() => {
+      if (!realtime) return;
+      
+      // Clean up previous subscription if it exists
+      if (channelRef.current) {
+        channelRef.current.unsubscribe();
+        channelRef.current = null;
+      }
+      
+      const channelId = channelName || \`changes_to_\${tableName}_\${Math.random().toString(36).substring(2, 15)}\`;
+      
+      // Store the current filter and options for closure
+      const currentFilter = computedFilter;
+      const currentWhere = where;
+      const currentOrderBy = orderBy;
+      const currentLimit = limit;
+      const currentOffset = offset;
+      
+      console.log(\`Setting up subscription for \${tableName} with filter: \${currentFilter}\`);
+      
+      const channel = supabase
+        .channel(channelId)
+        .on(
+          'postgres_changes',
+          {
+            event: '*',
+            schema: 'public',
+            table: tableName,
+            filter: currentFilter,
+          },
+          (payload) => {
+            console.log(\`Received \${payload.eventType} event for \${tableName}\`, payload);
+            
+            // Skip realtime updates when search is active
+            if (isSearchingRef.current) return;
+            
+            if (payload.eventType === 'INSERT') {
+              // Process insert event
+              setData((prev) => {
+                try {
+                  const newRecord = payload.new as TWithRelations;
+                  console.log(\`Processing INSERT for \${tableName}\`, { newRecord });
+                  
+                  // Check if this record matches our filter if we have one
+                  if (currentWhere) {
+                    let matchesFilter = true;
+                    
+                    // Check each filter condition
+                    for (const [key, value] of Object.entries(currentWhere)) {
+                      if (typeof value === 'object' && value !== null) {
+                        // Complex filter - this is handled by Supabase, assume it matches
+                      } 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;
+                    }
+                  }
+                  
+                  // Check if record already exists (avoid duplicates)
+                  const exists = prev.some(item => 
+                    // @ts-ignore: Supabase typing issue
+                    'id' in item && 'id' in newRecord && item.id === newRecord.id
+                  );
+                  
+                  if (exists) {
+                    console.log('Record already exists, skipping insertion');
+                    return prev;
+                  }
+                  
+                  // Add the new record to the data
+                  let newData = [newRecord, ...prev];
+                  
+                  // Apply ordering if specified
+                  if (currentOrderBy) {
+                    const [orderField, direction] = Object.entries(currentOrderBy)[0] || [];
+                    if (orderField) {
+                      newData = [...newData].sort((a, b) => {
+                        const aValue = a[orderField as keyof typeof a] ?? '';
+                        const bValue = b[orderField as keyof typeof b] ?? '';
+                        
+                        if (direction === 'asc') {
+                          return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
+                        } else {
+                          return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
+                        }
+                      });
+                    }
+                  }
+                  
+                  // Apply limit if specified
+                  if (currentLimit && currentLimit > 0) {
+                    newData = newData.slice(0, currentLimit);
+                  }
+                  
+                  return newData;
+                } catch (error) {
+                  console.error('Error processing INSERT event:', error);
+                  return prev;
+                }
+              });
+            } else if (payload.eventType === 'UPDATE') {
+              // Process update event
+              setData((prev) => {
+                // Skip if search is active
+                if (isSearchingRef.current) {
+                  return prev;
+                }
+                
+                return prev.map((item) =>
+                  // @ts-ignore: Supabase typing issue
+                  'id' in item && 'id' in payload.new && item.id === payload.new.id 
+                    ? (payload.new as TWithRelations) 
+                    : item
+                );
+              });
+            } else if (payload.eventType === 'DELETE') {
+              // Process delete event
+              setData((prev) => {
+                // Skip if search is active
+                if (isSearchingRef.current) {
+                  return prev;
+                }
+                
+                // Save the current size before filtering
+                const currentSize = prev.length;
+                
+                // 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);
+                });
+                
+                // If we need to maintain the size with a limit
+                if (currentLimit && currentLimit > 0 && filteredData.length < currentSize && currentSize === currentLimit) {
+                  console.log(\`Record deleted with limit \${currentLimit}, will fetch additional record to maintain size\`);
+                  
+                  // Use setTimeout to ensure this state update completes first
+                  setTimeout(() => {
+                    findMany({
+                      where: currentWhere,
+                      orderBy: currentOrderBy,
+                      take: currentLimit,
+                      skip: currentOffset
+                    });
+                  }, 0);
+                }
+                
+                return filteredData;
+              });
+            }
+          }
+        )
+        .subscribe((status) => {
+          console.log(\`Subscription status for \${tableName}\`, status);
+        });
+      
+      // Store the channel ref
+      channelRef.current = channel;
+        
+      return () => {
+        console.log(\`Unsubscribing from \${channelId}\`);
+        if (channelRef.current) {
+          channelRef.current.unsubscribe();
+          channelRef.current = null;
+        }
+        
+        if (searchTimeoutRef.current) {
+          clearTimeout(searchTimeoutRef.current);
+          searchTimeoutRef.current = null;
+        }
+      };
+    }, [realtime, channelName, computedFilter]);
+
+    // Create a memoized options object to prevent unnecessary re-renders
+    const optionsRef = useRef({ where, orderBy, limit, offset });
+    
+    // Compare current options with previous options
+    const optionsChanged = useCallback(() => {
+      // Create stable string representations for deep comparison
+      const whereStr = where ? JSON.stringify(where) : '';
+      const orderByStr = orderBy ? JSON.stringify(orderBy) : '';
+      const prevWhereStr = optionsRef.current.where ? JSON.stringify(optionsRef.current.where) : '';
+      const prevOrderByStr = optionsRef.current.orderBy ? JSON.stringify(optionsRef.current.orderBy) : '';
+      
+      // Compare the stable representations
+      const hasChanged = 
+        whereStr !== prevWhereStr ||
+        orderByStr !== prevOrderByStr ||
+        limit !== optionsRef.current.limit ||
+        offset !== optionsRef.current.offset;
+      
+      if (hasChanged) {
+        // Update the ref with the new values
+        optionsRef.current = { where, orderBy, limit, offset };
+        return true;
+      }
+      
+      return false;
+    }, [where, orderBy, limit, offset]);
+
+    // Load initial data based on options
+    useEffect(() => {
+      // Skip if search is active
+      if (isSearchingRef.current) return;
+      
+      // Skip if we've already loaded or if no filter criteria are provided
+      if (initialLoadRef.current) {
+        // Only reload if options have changed significantly
+        if (optionsChanged()) {
+          console.log(\`Options changed for \${tableName}, reloading data\`);
+          findMany({
+            where,
+            orderBy,
+            take: limit,
+            skip: offset
+          });
+        }
+        return;
+      }
+      
+      // Initial load
+      initialLoadRef.current = true;
+      findMany({
+        where,
+        orderBy,
+        take: limit,
+        skip: offset
+      });
+    }, [findMany, where, orderBy, limit, offset, optionsChanged]);
+
+    /**
+     * Create a new record with the provided data.
+     * Default values from the schema will be applied if not provided.
+     * 
+     * @param data - The data to create the record with
+     * @returns A promise with the created record or error
+     * 
+     * @example
+     * // Create a new user
+     * const result = await users.create({
+     *   name: "John Doe",
+     *   email: "john@example.com"
+     * });
+     * 
+     * @example
+     * // Create with custom ID (overriding default)
+     * const result = await users.create({
+     *   id: "custom-id-123",
+     *   name: "John Doe"
+     * });
+     */
+    const create = useCallback(async (
+      data: TCreateInput
+    ): ModelResult<TWithRelations> => {
+      try {
+        setLoading(true);
+        setError(null);
+        
+        const now = new Date().toISOString();
+        
+        // Apply default values from schema
+        const appliedDefaults: Record<string, any> = {};
+        
+        // Apply all default values that aren't already in the data
+        for (const [field, defaultValue] of Object.entries(defaultValues)) {
+          // @ts-ignore: Supabase typing issue
+          if (!(field in data)) {
+            // Parse the default value based on its type
+            if (defaultValue.includes('now()') || defaultValue.includes('now')) {
+              appliedDefaults[field] = now;
+            } else if (defaultValue.includes('uuid()') || defaultValue.includes('uuid')) {
+              appliedDefaults[field] = crypto.randomUUID();
+            } else if (defaultValue.includes('cuid()') || defaultValue.includes('cuid')) {
+              // Simple cuid-like implementation for client-side
+              appliedDefaults[field] = 'c' + Math.random().toString(36).substring(2, 15);
+            } else if (defaultValue.includes('true')) {
+              appliedDefaults[field] = true;
+            } else if (defaultValue.includes('false')) {
+              appliedDefaults[field] = false;
+            } else if (!isNaN(Number(defaultValue))) {
+              // If it's a number
+              appliedDefaults[field] = Number(defaultValue);
+            } else {
+              // String or other value, remove quotes if present
+              const strValue = defaultValue.replace(/^["'](.*)["']$/, '$1');
+              appliedDefaults[field] = strValue;
+            }
+          }
+        }
+        
+        const itemWithDefaults = {
+          ...appliedDefaults, // Apply schema defaults first
+          ...data, // Then user data (overrides defaults)
+          ...(hasCreatedAt ? { created_at: now } : {}), // Always set timestamps
+          ...(hasUpdatedAt ? { updated_at: now } : {})
+        };
+        
+        const { data: result, error } = await supabase
+          .from(tableName)
+          .insert([itemWithDefaults])
+          .select();
+        
+        if (error) throw error;
+        
+        // Return created record
+        return { data: result?.[0] as TWithRelations, error: null };
+      } catch (err: any) {
+        console.error('Error creating record:', err);
+        setError(err);
+        return { data: null, error: err };
+      } finally {
+        setLoading(false);
+      }
+    }, []);
+
+    /**
+     * Update an existing record identified by a unique identifier.
+     * 
+     * @param params - Object containing the identifier and update data
+     * @returns A promise with the updated record or error
+     * 
+     * @example
+     * // Update a user's name
+     * const result = await users.update({
+     *   where: { id: "123" },
+     *   data: { name: "New Name" }
+     * });
+     * 
+     * @example
+     * // Update multiple fields
+     * const result = await users.update({
+     *   where: { id: "123" },
+     *   data: { 
+     *     name: "New Name",
+     *     active: false
+     *   }
+     * });
+     */
+    const update = useCallback(async (params: {
+      where: TWhereUniqueInput;
+      data: TUpdateInput;
+    }): ModelResult<TWithRelations> => {
+      try {
+        setLoading(true);
+        setError(null);
+        
+        // Find the primary field (usually 'id')
+        // @ts-ignore: Supabase typing issue
+        const primaryKey = Object.keys(params.where)[0];
+        if (!primaryKey) {
+          throw new Error('A unique identifier is required');
+        }
+        
+        const value = params.where[primaryKey as keyof typeof params.where];
+        if (value === undefined) {
+          throw new Error('A unique identifier is required');
+        }
+        
+        const now = new Date().toISOString();
+        
+        // We do not apply default values for updates
+        // Default values are only for creation, not for updates,
+        // as existing records already have these values set
+        
+        const itemWithDefaults = {
+          ...params.data,
+          ...(hasUpdatedAt ? { updated_at: now } : {})
+        };
+        
+        const { data, error } = await supabase
+          .from(tableName)
+          .update(itemWithDefaults)
+          .eq(primaryKey, value)
+          .select();
+        
+        if (error) throw error;
+        
+        // Return updated record
+        return { data: data?.[0] as TWithRelations, error: null };
+      } catch (err: any) {
+        console.error('Error updating record:', err);
+        setError(err);
+        return { data: null, error: err };
+      } finally {
+        setLoading(false);
+      }
+    }, []);
+
+    /**
+     * Delete a record by its unique identifier.
+     * 
+     * @param where - The unique identifier to delete the record by
+     * @returns A promise with the deleted record or error
+     * 
+     * @example
+     * // Delete a user by ID
+     * const result = await users.delete({ id: "123" });
+     * if (result.data) {
+     *   console.log("Deleted user:", result.data.name);
+     * }
+     */
+    const deleteRecord = useCallback(async (
+      where: TWhereUniqueInput
+    ): ModelResult<TWithRelations> => {
+      try {
+        setLoading(true);
+        setError(null);
+        
+        // Find the primary field (usually 'id')
+        // @ts-ignore: Supabase typing issue
+        const primaryKey = Object.keys(where)[0];
+        if (!primaryKey) {
+          throw new Error('A unique identifier is required');
+        }
+        
+        const value = where[primaryKey as keyof typeof where];
+        if (value === undefined) {
+          throw new Error('A unique identifier is required');
+        }
+        
+        // First fetch the record to return it
+        const { data: recordToDelete } = await supabase
+          .from(tableName)
+          .select('*')
+          .eq(primaryKey, value)
+          .maybeSingle();
+        
+        if (!recordToDelete) {
+          throw new Error('Record not found');
+        }
+        
+        // Then delete it
+        const { error } = await supabase
+          .from(tableName)
+          .delete()
+          .eq(primaryKey, value);
+        
+        if (error) throw error;
+        
+        // Return the deleted record
+        return { data: recordToDelete as TWithRelations, error: null };
+      } catch (err: any) {
+        console.error('Error deleting record:', err);
+        setError(err);
+        return { data: null, error: err };
+      } finally {
+        setLoading(false);
+      }
+    }, []);
+
+    /**
+     * Delete multiple records matching the filter criteria.
+     * 
+     * @param params - Query parameters for filtering records to delete
+     * @returns A promise with the count of deleted records or error
+     * 
+     * @example
+     * // Delete all inactive users
+     * const result = await users.deleteMany({
+     *   where: { active: false }
+     * });
+     * console.log(\`Deleted \${result.count} inactive users\`);
+     * 
+     * @example
+     * // Delete all records (use with caution!)
+     * const result = await users.deleteMany();
+     */
+    const deleteMany = useCallback(async (params?: {
+      where?: TWhereInput;
+    }): Promise<{ count: number; error: Error | null }> => {
+      try {
+        setLoading(true);
+        setError(null);
+        
+        // First, get the records that will be deleted to count them
+        let query = supabase.from(tableName).select('*');
+        
+        // Apply where conditions if provided
+        if (params?.where) {
+          query = applyFilter(query, params.where);
+        }
+        
+        // Get records that will be deleted
+        const { data: recordsToDelete, error: fetchError } = await query;
+        
+        if (fetchError) throw fetchError;
+        
+        if (!recordsToDelete?.length) {
+          return { count: 0, error: null };
+        }
+        
+        // Build the delete query
+        let deleteQuery = supabase.from(tableName).delete();
+        
+        // Apply the same filter to the delete operation
+        if (params?.where) {
+          // @ts-ignore: Supabase typing issue
+          deleteQuery = applyFilter(deleteQuery, params.where);
+        }
+        
+        // Perform the delete
+        const { error: deleteError } = await deleteQuery;
+        
+        if (deleteError) throw deleteError;
+        
+        // Return the count of deleted records
+        return { count: recordsToDelete.length, error: null };
+      } catch (err: any) {
+        console.error('Error deleting multiple records:', err);
+        setError(err);
+        return { count: 0, error: err };
+      } finally {
+        setLoading(false);
+      }
+    }, []);
+
+    /**
+     * Find the first record matching the filter criteria.
+     * 
+     * @param params - Query parameters for filtering and ordering
+     * @returns A promise with the first matching record or error
+     * 
+     * @example
+     * // Find the first admin user
+     * const result = await users.findFirst({
+     *   where: { role: 'admin' }
+     * });
+     * 
+     * @example
+     * // Find the oldest post
+     * const result = await posts.findFirst({
+     *   orderBy: { created_at: 'asc' }
+     * });
+     */
+    const findFirst = useCallback(async (params?: {
+      where?: TWhereInput;
+      orderBy?: TOrderByInput;
+    }): ModelResult<TWithRelations> => {
+      try {
+        const result = await findMany({
+          ...params,
+          take: 1
+        });
+        
+        if (result.error) return { data: null, error: result.error };
+        if (!result.data.length) return { data: null, error: new Error('No records found') };
+        
+        // @ts-ignore: Supabase typing issue
+        return { data: result.data[0], error: null };
+      } catch (err: any) {
+        console.error('Error finding first record:', err);
+        return { data: null, error: err };
+      }
+    }, [findMany]);
+
+    /**
+     * Create a record if it doesn't exist, or update it if it does.
+     * 
+     * @param params - Object containing the identifier, update data, and create data
+     * @returns A promise with the created or updated record or error
+     * 
+     * @example
+     * // Upsert a user by ID
+     * const result = await users.upsert({
+     *   where: { id: "123" },
+     *   update: { lastLogin: new Date().toISOString() },
+     *   create: { 
+     *     id: "123", 
+     *     name: "John Doe", 
+     *     email: "john@example.com",
+     *     lastLogin: new Date().toISOString()
+     *   }
+     * });
+     */
+    const upsert = useCallback(async (params: {
+      where: TWhereUniqueInput;
+      update: TUpdateInput;
+      create: TCreateInput;
+    }): ModelResult<TWithRelations> => {
+      try {
+        // Check if record exists
+        const { data: existing } = await findUnique(params.where);
+        
+        // Update if exists, otherwise create
+        if (existing) {
+          return update({ where: params.where, data: params.update });
+        } else {
+          return create(params.create);
+        }
+      } catch (err: any) {
+        console.error('Error upserting record:', err);
+        return { data: null, error: err };
+      }
+    }, [findUnique, update, create]);
+
+    /**
+     * Count the number of records matching the filter criteria.
+     * 
+     * @param params - Query parameters for filtering
+     * @returns A promise with the count of matching records
+     * 
+     * @example
+     * // Count all users
+     * const count = await users.count();
+     * 
+     * @example
+     * // Count active users
+     * const activeCount = await users.count({
+     *   where: { active: true }
+     * });
+     */
+    const count = useCallback(async (params?: {
+      where?: TWhereInput;
+    }): Promise<number> => {
+      try {
+        let query = supabase.from(tableName).select('*', { count: 'exact', head: true });
+        
+        // Use provided where filter, or fall back to the hook's original where filter
+        const effectiveWhere = params?.where ?? where;
+        
+        if (effectiveWhere) {
+          query = applyFilter(query, effectiveWhere);
+        }
+        
+        const { count, error } = await query;
+        
+        if (error) throw error;
+        
+        return count || 0;
+      } catch (err) {
+        console.error('Error counting records:', err);
+        return 0;
+      }
+    }, [where]);
+
+    /**
+     * Manually refresh the data with current filter settings.
+     * Useful after external operations or when realtime is disabled.
+     * 
+     * @param params - Optional override parameters for this specific refresh
+     * @returns A promise with the refreshed data or error
+     * 
+     * @example
+     * // Refresh with current filter settings
+     * await users.refresh();
+     * 
+     * @example
+     * // Refresh with different filters for this call only
+     * await users.refresh({
+     *   where: { active: true },
+     *   orderBy: { name: 'asc' }
+     * });
+     */
+    const refresh = useCallback((params?: {
+      where?: TWhereInput;
+      orderBy?: TOrderByInput;
+      take?: number;
+      skip?: number;
+    }) => {
+      // If search is active, refresh search results
+      if (isSearchingRef.current && searchQueries.length > 0) {
+        executeSearch(searchQueries);
+        return Promise.resolve({ data: data, error: null });
+      }
+      
+      // Otherwise, refresh normal data using original params if not explicitly overridden
+      return findMany({
+        where: params?.where ?? where,
+        orderBy: params?.orderBy ?? orderBy,
+        take: params?.take ?? limit,
+        skip: params?.skip ?? offset
+      });
+    }, [findMany, data, searchQueries, where, orderBy, limit, offset]);
+    
+    // Construct final hook API with or without search
+    const api = {
+      // State
+      data,
+      error,
+      loading,
+      
+      // Finder methods
+      findUnique,
+      findMany,
+      findFirst,
+      
+      // Mutation methods
+      create,
+      update,
+      delete: deleteRecord,
+      deleteMany,
+      upsert,
+      
+      // Utilities
+      count,
+      
+      // Manual refresh
+      refresh
+    };
+    
+    // Add search object if searchable fields are present
+    return searchFields.length > 0 
+      ? { 
+          ...api, 
+          search 
+        } 
+      : api;
+  };
+}`;
+    const outputPath = path_1.default.join(config_1.OUTPUT_DIR, 'core.ts');
+    fs_1.default.writeFileSync(outputPath, coreContent);
+    console.log(`Updated core hook factory with improved refresh and count functions at ${outputPath}`);
+}