suparisma 0.0.1 → 0.0.2

package/dist/hooks/generated/core.js

@@ -1,1089 +0,0 @@
-"use strict";
-// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
-// Edit the generator script instead: scripts/generate-realtime-hooks.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFilterString = buildFilterString;
-exports.applyFilter = applyFilter;
-exports.applyOrderBy = applyOrderBy;
-exports.createSuparismaHook = createSuparismaHook;
-const react_1 = require("react");
-const supabase_1 = require("@monorepo/src/lib/supabase");
-/**
- * Convert a type-safe where filter to Supabase filter string
- */
-function buildFilterString(where) {
-    if (!where)
-        return undefined;
-    const filters = [];
-    for (const [key, value] of Object.entries(where)) {
-        if (value !== undefined) {
-            if (typeof value === 'object' && value !== null) {
-                // Handle advanced operators
-                const advancedOps = value;
-                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
- */
-function applyFilter(query, where) {
-    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;
-                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
- */
-function applyOrderBy(query, orderBy, hasCreatedAt) {
-    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.
- */
-function createSuparismaHook(config) {
-    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 = {}) {
-        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] = (0, react_1.useState)([]);
-        const [error, setError] = (0, react_1.useState)(null);
-        const [loading, setLoading] = (0, react_1.useState)(false);
-        // Search state
-        const [searchQueries, setSearchQueries] = (0, react_1.useState)([]);
-        const [searchLoading, setSearchLoading] = (0, react_1.useState)(false);
-        const initialLoadRef = (0, react_1.useRef)(false);
-        const channelRef = (0, react_1.useRef)(null);
-        const searchTimeoutRef = (0, react_1.useRef)(null);
-        const isSearchingRef = (0, react_1.useRef)(false);
-        // Create the search state object with all required methods
-        const search = {
-            queries: searchQueries,
-            loading: searchLoading,
-            // Set all search queries at once
-            setQueries: (0, react_1.useCallback)((queries) => {
-                // 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: (0, react_1.useCallback)((query) => {
-                // 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: (0, react_1.useCallback)((field) => {
-                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: (0, react_1.useCallback)(() => {
-                setSearchQueries([]);
-                isSearchingRef.current = false;
-                findMany({ where, orderBy, take: limit, skip: offset });
-            }, [where, orderBy, limit, offset])
-        };
-        // Execute search based on queries
-        const executeSearch = (0, react_1.useCallback)(async (queries) => {
-            // 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 = [];
-                    // 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_1.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 = {};
-                    // 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) {
-                                // @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] !== 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] ?? '';
-                                const bValue = b[orderField] ?? '';
-                                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);
-                }
-                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 = (0, react_1.useCallback)(async (params) => {
-            try {
-                setLoading(true);
-                setError(null);
-                let query = supabase_1.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 || []);
-                // Only update data if not currently searching
-                if (!isSearchingRef.current) {
-                    setData(typedData);
-                }
-                return { data: typedData, error: null };
-            }
-            catch (err) {
-                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 = (0, react_1.useCallback)(async (where) => {
-            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];
-                if (value === undefined) {
-                    throw new Error('A unique identifier is required');
-                }
-                const { data, error } = await supabase_1.supabase
-                    .from(tableName)
-                    .select('*')
-                    .eq(primaryKey, value)
-                    .maybeSingle();
-                if (error)
-                    throw error;
-                return { data: data, error: null };
-            }
-            catch (err) {
-                console.error('Error finding unique record:', err);
-                setError(err);
-                return { data: null, error: err };
-            }
-            finally {
-                setLoading(false);
-            }
-        }, []);
-        // Set up realtime subscription for the list
-        (0, react_1.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_1.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;
-                            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] !== value) {
-                                        matchesFilter = false;
-                                        console.log(`Filter mismatch on ${key}`, { expected: value, actual: newRecord[key] });
-                                        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] ?? '';
-                                        const bValue = b[orderField] ?? '';
-                                        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
-                            : 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 = (0, react_1.useRef)({ where, orderBy, limit, offset });
-        // Compare current options with previous options
-        const optionsChanged = (0, react_1.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
-        (0, react_1.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 = (0, react_1.useCallback)(async (data) => {
-            try {
-                setLoading(true);
-                setError(null);
-                const now = new Date().toISOString();
-                // Apply default values from schema
-                const appliedDefaults = {};
-                // 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_1.supabase
-                    .from(tableName)
-                    .insert([itemWithDefaults])
-                    .select();
-                if (error)
-                    throw error;
-                // Return created record
-                return { data: result?.[0], error: null };
-            }
-            catch (err) {
-                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 = (0, react_1.useCallback)(async (params) => {
-            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];
-                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_1.supabase
-                    .from(tableName)
-                    .update(itemWithDefaults)
-                    .eq(primaryKey, value)
-                    .select();
-                if (error)
-                    throw error;
-                // Return updated record
-                return { data: data?.[0], error: null };
-            }
-            catch (err) {
-                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 = (0, react_1.useCallback)(async (where) => {
-            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];
-                if (value === undefined) {
-                    throw new Error('A unique identifier is required');
-                }
-                // First fetch the record to return it
-                const { data: recordToDelete } = await supabase_1.supabase
-                    .from(tableName)
-                    .select('*')
-                    .eq(primaryKey, value)
-                    .maybeSingle();
-                if (!recordToDelete) {
-                    throw new Error('Record not found');
-                }
-                // Then delete it
-                const { error } = await supabase_1.supabase
-                    .from(tableName)
-                    .delete()
-                    .eq(primaryKey, value);
-                if (error)
-                    throw error;
-                // Return the deleted record
-                return { data: recordToDelete, error: null };
-            }
-            catch (err) {
-                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 = (0, react_1.useCallback)(async (params) => {
-            try {
-                setLoading(true);
-                setError(null);
-                // First, get the records that will be deleted to count them
-                let query = supabase_1.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_1.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) {
-                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 = (0, react_1.useCallback)(async (params) => {
-            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) {
-                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 = (0, react_1.useCallback)(async (params) => {
-            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) {
-                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 = (0, react_1.useCallback)(async (params) => {
-            try {
-                let query = supabase_1.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 = (0, react_1.useCallback)((params) => {
-            // 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;
-    };
-}