suparisma 1.1.2 → 1.2.1

package/dist/generators/coreGenerator.js

@@ -23,9 +23,13 @@ import { supabase } from './supabase-client';
  * @example
  * // Search for users with names containing "john"
  * const query = { field: "name", value: "john" };
+ * 
+ * @example
+ * // Search across multiple fields
+ * const query = { field: "multi", value: "john" };
  */
 export type SearchQuery = {
-  /** The field name to search in */
+  /** The field name to search in, or "multi" for multi-field search */
   field: string;
   /** The search term/value to look for */
   value: string;
@@ -34,6 +38,15 @@ export type SearchQuery = {
 // Define type for Supabase query builder
 export type SupabaseQueryBuilder = ReturnType<ReturnType<typeof supabase.from>['select']>;
 
+/**
+ * Utility function to escape regex special characters for safe RegExp usage
+ * Prevents "Invalid regular expression" errors when search terms contain special characters
+ */
+export function escapeRegexCharacters(str: string): string {
+  // Escape all special regex characters: ( ) [ ] { } + * ? ^ $ | . \\
+  return str.replace(/[()\\[\\]{}+*?^$|.\\\\]/g, '\\\\\\\\$&');
+}
+
 /**
  * Advanced filter operators for complex queries
  * @example
@@ -162,10 +175,22 @@ export type ModelResult<T> = Promise<{
  * users.search.addQuery({ field: "name", value: "john" });
  * 
  * @example
+ * // Search across multiple fields
+ * users.search.searchMultiField("john doe");
+ * 
+ * @example
  * // Check if search is loading
  * if (users.search.loading) {
  *   return <div>Searching...</div>;
  * }
+ * 
+ * @example
+ * // Get current search terms for highlighting
+ * const searchTerms = users.search.getCurrentSearchTerms();
+ * 
+ * @example
+ * // Safely escape regex characters
+ * const escaped = users.search.escapeRegex("user@example.com");
  */
 export type SearchState = {
   /** Current active search queries */
@@ -180,6 +205,14 @@ export type SearchState = {
   removeQuery: (field: string) => void;
   /** Clear all search queries and return to normal data fetching */
   clearQueries: () => void;
+  /** Search across multiple fields (convenience method) */
+  searchMultiField: (value: string) => void;
+  /** Search in a specific field (convenience method) */
+  searchField: (field: string, value: string) => void;
+  /** Get current search terms for custom highlighting */
+  getCurrentSearchTerms: () => string[];
+  /** Safely escape regex special characters */
+  escapeRegex: (text: string) => string;
 };
 
 /**
@@ -897,7 +930,39 @@ export function createSuparismaHook<
         setSearchQueries([]);
         isSearchingRef.current = false;
         findMany({ where, orderBy, take: limit, skip: offset });
-      }, [where, orderBy, limit, offset])
+      }, [where, orderBy, limit, offset]),
+      
+      // Search across multiple fields (convenience method)
+      searchMultiField: useCallback((value: string) => {
+        if (searchFields.length <= 1) {
+          console.warn('Multi-field search requires at least 2 searchable fields');
+          return;
+        }
+        
+        setSearchQueries([{ field: 'multi', value }]);
+        executeSearch([{ field: 'multi', value }]);
+      }, [searchFields.length]),
+      
+      // Search in a specific field (convenience method)
+      searchField: useCallback((field: string, value: string) => {
+        if (!searchFields.includes(field)) {
+          console.warn(\`Field "\${field}" is not searchable. Available fields: \${searchFields.join(', ')}\`);
+          return;
+        }
+        
+        setSearchQueries([{ field, value }]);
+        executeSearch([{ field, value }]);
+      }, [searchFields]),
+      
+      // Get current search terms for custom highlighting
+      getCurrentSearchTerms: useCallback(() => {
+        return searchQueries.map(q => q.value.trim());
+      }, [searchQueries]),
+      
+      // Safely escape regex special characters
+      escapeRegex: useCallback((text: string) => {
+        return escapeRegexCharacters(text);
+      }, [])
     };
     
     // Execute search based on queries
@@ -920,13 +985,52 @@ export function createSuparismaHook<
         try {
           let results: TWithRelations[] = [];
           
+          // Validate search queries
+          const validQueries = queries.filter(query => {
+            if (!query.field || !query.value) {
+              console.warn('Invalid search query - missing field or value:', query);
+              return false;
+            }
+            // Allow "multi" as a special field for multi-field search
+            if (query.field === 'multi' && searchFields.length > 1) {
+              return true;
+            }
+            if (!searchFields.includes(query.field)) {
+              console.warn(\`Field "\${query.field}" is not searchable. Available fields: \${searchFields.join(', ')}, or "multi" for multi-field search\`);
+              return false;
+            }
+            return true;
+          });
+          
+          if (validQueries.length === 0) {
+            console.log('No valid search queries found');
+            setData([]);
+            setCount(0);
+            return;
+          }
+          
           // 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\`;
+          const searchPromises = validQueries.map(query => {
+            // Build function name based on field type
+            const functionName = query.field === 'multi' 
+              ? \`search_\${tableName.toLowerCase()}_multi_field\`
+              : \`search_\${tableName.toLowerCase()}_by_\${query.field.toLowerCase()}_prefix\`;
             
-            // Call RPC function
-            return supabase.rpc(functionName, { prefix: query.value.trim() });
+            console.log(\`🔍 Executing search: \${functionName}(search_prefix: "\${query.value.trim()}")\`);
+            
+            // Call RPC function with proper error handling
+            return Promise.resolve(supabase.rpc(functionName, { search_prefix: query.value.trim() }))
+              .then((result: any) => ({
+                ...result,
+                queryField: query.field,
+                queryValue: query.value
+              }))
+              .catch((error: any) => ({
+                data: null,
+                error: error,
+                queryField: query.field,
+                queryValue: query.value
+              }));
           });
           
           // Execute all search queries in parallel
@@ -934,82 +1038,88 @@ export function createSuparismaHook<
           
           // Combine and deduplicate results
           const allResults: Record<string, TWithRelations> = {};
+          let hasErrors = false;
           
           // Process each search result
-          searchResults.forEach((result, index) => {
+          searchResults.forEach((result: any, index: number) => {
             if (result.error) {
-              console.error(\`Search error for \${queries[index]?.field}:\`, result.error);
+              console.error(\`🔍 Search error for field "\${result.queryField}" with value "\${result.queryValue}":\`, result.error);
+              hasErrors = true;
               return;
             }
             
-            if (result.data) {
+            if (result.data && Array.isArray(result.data)) {
+              console.log(\`🔍 Search results for "\${result.queryField}": \${result.data.length} items\`);
+              
               // 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) {
+                if (item && typeof item === 'object' && 'id' in item && item.id) {
                   // @ts-ignore: Add to results using id as key
                   allResults[item.id] = item;
                 }
               }
+            } else if (result.data) {
+              console.warn(\`🔍 Unexpected search result format for "\${result.queryField}":\`, typeof result.data);
             }
           });
           
           // Convert back to array
           results = Object.values(allResults);
+          console.log(\`🔍 Combined search results: \${results.length} unique items\`);
           
-          // Apply any where conditions client-side
+          // Apply any where conditions client-side (now using the proper filter function)
           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;
-            });
+            const originalCount = results.length;
+            results = results.filter((item) => matchesFilter(item, where));
+            console.log(\`🔍 After applying where filter: \${results.length}/\${originalCount} items\`);
           }
           
           // Set count directly for search results
           setCount(results.length);
           
-          // Apply ordering if needed
+          // Apply ordering if needed (using the proper compare function)
           if (orderBy) {
-            const orderEntries = Object.entries(orderBy);
-            if (orderEntries.length > 0) {
-              const [orderField, direction] = orderEntries[0] || [];
+            const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
               results = [...results].sort((a, b) => {
-                const aValue = a[orderField as keyof typeof a] ?? '';
-                const bValue = b[orderField as keyof typeof b] ?? '';
+              for (const orderByClause of orderByArray) {
+                for (const [field, direction] of Object.entries(orderByClause)) {
+                  const aValue = a[field as keyof typeof a];
+                  const bValue = b[field as keyof typeof b];
                 
-                if (direction === 'asc') {
-                  return aValue < bValue ? -1 : aValue > bValue ? 1 : 0;
-                } else {
-                  return aValue > bValue ? -1 : aValue < bValue ? 1 : 0;
+                  if (aValue === bValue) continue;
+                  
+                  return compareValues(aValue, bValue, direction as 'asc' | 'desc');
                 }
-              });
-            }
+              }
+              return 0;
+            });
           }
           
           // Apply pagination if needed
           let paginatedResults = results;
-          if (limit && limit > 0) {
-            paginatedResults = results.slice(0, limit);
-          }
-          
           if (offset && offset > 0) {
             paginatedResults = paginatedResults.slice(offset);
           }
           
+          if (limit && limit > 0) {
+            paginatedResults = paginatedResults.slice(0, limit);
+          }
+          
+          console.log(\`🔍 Final search results: \${paginatedResults.length} items (total: \${results.length})\`);
+          
           // Update data with search results
           setData(paginatedResults);
+          
+          // Show error if there were issues but still show partial results
+          if (hasErrors && results.length === 0) {
+            setError(new Error('Search failed - please check if search functions are properly configured'));
+          }
         } catch (err) {
-          console.error('Search error:', err);
+          console.error('🔍 Search error:', err);
           setError(err as Error);
+          setData([]);
+          setCount(0);
         } finally {
           setSearchLoading(false);
         }

package/dist/generators/typeGenerator.js

@@ -118,33 +118,16 @@ function generateModelTypesFile(model) {
     // Generate imports section for zod custom types
     let customImports = '';
     if (model.zodImports && model.zodImports.length > 0) {
-        // Add zod import for type inference
-        customImports = 'import { z } from \'zod\';\n';
-        // Get the zod schemas file path from environment variable
-        const zodSchemasPath = process.env.ZOD_SCHEMAS_FILE_PATH || '../commonTypes';
-        // Add custom imports with environment variable path
-        customImports += model.zodImports
-            .map(zodImport => {
-            // Extract the types from the original import statement
-            const typeMatch = zodImport.importStatement.match(/import\s+{\s*([^}]+)\s*}\s+from/);
-            if (typeMatch) {
-                const types = typeMatch[1].trim();
-                return `import { ${types} } from '${zodSchemasPath}'`;
-            }
-            // Fallback to original import if parsing fails
-            return zodImport.importStatement;
-        })
-            .join('\n') + '\n\n';
-        // Add type definitions for imported zod schemas if needed
-        // This is a simplified approach - you might want to make this more sophisticated
+        // For projects without zod dependency, fallback to any types instead of importing zod
+        // This prevents TypeScript errors when zod is not installed
         const customTypeDefinitions = model.zodImports
             .flatMap(zodImport => zodImport.types)
             .filter((type, index, array) => array.indexOf(type) === index) // Remove duplicates
             .map(type => {
-            // If it ends with 'Schema', create a corresponding type
+            // If it ends with 'Schema', create a corresponding type using any instead of zod
             if (type.endsWith('Schema')) {
                 const typeName = type.replace('Schema', '');
-                return `export type ${typeName} = z.infer<typeof ${type}>;`;
+                return `// Fallback type when zod is not available\nexport type ${typeName} = any;`;
             }
             return '';
         })

package/dist/index.js

@@ -105,20 +105,45 @@ function analyzePrismaSchema(schemaPath) {
                 : modelName;
             const enableRealtime = !modelBodyWithComments.includes('// @disableRealtime');
             const searchFields = [];
-            // Split model body into lines to check preceding line for @enableSearch
+            // Split model body into lines to check for @enableSearch directives
             const bodyLines = modelBody.trim().split('\n');
+            let nextFieldShouldBeSearchable = false;
             for (let i = 0; i < bodyLines.length; i++) {
-                const currentLine = bodyLines[i].trim();
-                const previousLine = i > 0 ? bodyLines[i - 1].trim() : "";
-                // Check if the PREVIOUS line contains the @enableSearch comment
-                if (previousLine.includes('// @enableSearch')) {
-                    // Try to parse the CURRENT line as a field definition
-                    // Basic regex: fieldName fieldType (optional attributes/comments)
-                    const fieldMatch = currentLine.match(/^(\w+)\s+(\w+)/);
-                    if (fieldMatch) {
-                        const fieldName = fieldMatch[1];
-                        const fieldType = fieldMatch[2];
-                        if (fieldName && fieldType) {
+                const currentLine = bodyLines[i]?.trim() || '';
+                // Skip blank lines and non-field lines
+                if (!currentLine || currentLine.startsWith('@@')) {
+                    continue;
+                }
+                // Check for /// @enableSearch directive (applies to NEXT field)
+                if (currentLine === '/// @enableSearch') {
+                    nextFieldShouldBeSearchable = true;
+                    continue;
+                }
+                // Check for standalone // @enableSearch comment (applies to NEXT field)  
+                if (currentLine === '// @enableSearch') {
+                    nextFieldShouldBeSearchable = true;
+                    continue;
+                }
+                // Check if line is a comment - SKIP ALL TYPES of comments but keep search flag
+                if (currentLine.startsWith('///') || currentLine.startsWith('//')) {
+                    continue;
+                }
+                // Parse field definition - Updated to handle array types and inline comments  
+                const fieldMatch = currentLine.match(/^\s*(\w+)\s+(\w+)(\[\])?(\?)?\s*/);
+                if (fieldMatch) {
+                    const fieldName = fieldMatch[1];
+                    const fieldType = fieldMatch[2];
+                    // Check if this field should be searchable due to @enableSearch directive
+                    if (nextFieldShouldBeSearchable && fieldName && fieldType) {
+                        searchFields.push({
+                            name: fieldName,
+                            type: fieldType,
+                        });
+                        nextFieldShouldBeSearchable = false; // Reset flag
+                    }
+                    // Check for inline // @enableSearch comment
+                    if (currentLine.includes('// @enableSearch')) {
+                        if (fieldName && fieldType && !searchFields.some(f => f.name === fieldName)) {
                             searchFields.push({
                                 name: fieldName,
                                 type: fieldType,
@@ -195,6 +220,7 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
             if (model.searchFields.length > 0) {
                 console.log(`  🔍 Setting up full-text search for model ${model.name}:`);
                 const { rows: columns } = await pool.query(`SELECT column_name FROM information_schema.columns WHERE table_schema = 'public' AND table_name = $1`, [actualTableName]);
+                // Create individual field search functions
                 for (const searchField of model.searchFields) {
                     const matchingColumn = columns.find((c) => c.column_name.toLowerCase() === searchField.name.toLowerCase());
                     if (!matchingColumn) {
@@ -206,16 +232,73 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
                     const indexName = `idx_gin_search_${actualTableName.toLowerCase()}_${actualColumnName.toLowerCase()}`;
                     console.log(`    ➡️ Configuring field "${actualColumnName}":`);
                     try {
-                        // Create search function
+                        // Create search function with improved partial search and error handling
                         const createFunctionQuery = `
               CREATE OR REPLACE FUNCTION "public"."${functionName}"(search_prefix text)
               RETURNS SETOF "public"."${actualTableName}" AS $$
+              DECLARE
+                clean_prefix text;
+                words text[];
+                word text;
+                tsquery_str text := '';
               BEGIN
+                -- Handle empty or null search terms
+                IF search_prefix IS NULL OR trim(search_prefix) = '' THEN
+                  RETURN;
+                END IF;
+                
+                -- Clean the search prefix: remove special characters, normalize spaces
+                clean_prefix := regexp_replace(trim(search_prefix), '[^a-zA-Z0-9\\s]', ' ', 'g');
+                clean_prefix := regexp_replace(clean_prefix, '\\s+', ' ', 'g');
+                clean_prefix := trim(clean_prefix);
+                
+                -- Handle empty string after cleaning
+                IF clean_prefix = '' THEN
+                  RETURN;
+                END IF;
+                
+                -- Split into words and build partial search query
+                words := string_to_array(clean_prefix, ' ');
+                
+                -- Build tsquery for partial matching
+                FOR i IN 1..array_length(words, 1) LOOP
+                  word := words[i];
+                  IF word != '' THEN
+                    IF tsquery_str != '' THEN
+                      tsquery_str := tsquery_str || ' & ';
+                    END IF;
+                    -- Add prefix matching for each word
+                    tsquery_str := tsquery_str || word || ':*';
+                  END IF;
+                END LOOP;
+                
+                -- Return query with proper error handling
                 RETURN QUERY
                 SELECT * FROM "public"."${actualTableName}"
-                WHERE to_tsvector('english', "${actualColumnName}") @@ to_tsquery('english', search_prefix || ':*');
+                WHERE 
+                  "${actualColumnName}" IS NOT NULL 
+                  AND "${actualColumnName}" != ''
+                  AND (
+                    -- Use the built tsquery for structured search
+                    to_tsvector('english', "${actualColumnName}") @@ to_tsquery('english', tsquery_str)
+                    OR
+                    -- Fallback to simple text matching for very partial matches
+                    "${actualColumnName}" ILIKE '%' || search_prefix || '%'
+                  );
+              EXCEPTION
+                WHEN others THEN
+                  -- Log error and return empty result set instead of failing
+                  RAISE NOTICE 'Search function error: %, falling back to simple ILIKE search', SQLERRM;
+                  -- Fallback to simple pattern matching
+                  RETURN QUERY
+                  SELECT * FROM "public"."${actualTableName}"
+                  WHERE 
+                    "${actualColumnName}" IS NOT NULL 
+                    AND "${actualColumnName}" != ''
+                    AND "${actualColumnName}" ILIKE '%' || search_prefix || '%';
+                  RETURN;
               END;
-              $$ LANGUAGE plpgsql STABLE;`; // Added STABLE for potential performance benefits
+              $$ LANGUAGE plpgsql STABLE;`; // Added STABLE for performance
                         await pool.query(createFunctionQuery);
                         console.log(`      ✅ Created/Replaced RPC function: "${functionName}"(search_prefix text)`);
                         // Create GIN index
@@ -250,6 +333,114 @@ async function configurePrismaTablesForSuparisma(schemaPath) {
                         console.error(`      ❌ Failed to set up search for "${actualTableName}"."${actualColumnName}": ${err.message}`);
                     }
                 }
+                // Create multi-field search function if there are multiple searchable fields
+                if (model.searchFields.length > 1) {
+                    console.log(`    ➡️ Creating multi-field search function:`);
+                    try {
+                        const validSearchFields = model.searchFields.filter(field => columns.find(c => c.column_name.toLowerCase() === field.name.toLowerCase()));
+                        if (validSearchFields.length > 1) {
+                            const multiFieldFunctionName = `search_${actualTableName.toLowerCase()}_multi_field`;
+                            const multiFieldIndexName = `idx_gin_search_${actualTableName.toLowerCase()}_multi_field`;
+                            // Get actual column names
+                            const actualColumnNames = validSearchFields.map(field => {
+                                const matchingColumn = columns.find(c => c.column_name.toLowerCase() === field.name.toLowerCase());
+                                return matchingColumn.column_name;
+                            });
+                            // Create multi-field search function with improved partial search
+                            const createMultiFieldFunctionQuery = `
+                CREATE OR REPLACE FUNCTION "public"."${multiFieldFunctionName}"(search_prefix text)
+                RETURNS SETOF "public"."${actualTableName}" AS $$
+                DECLARE
+                  clean_prefix text;
+                  words text[];
+                  word text;
+                  tsquery_str text := '';
+                  combined_text text;
+                BEGIN
+                  -- Handle empty or null search terms
+                  IF search_prefix IS NULL OR trim(search_prefix) = '' THEN
+                    RETURN;
+                  END IF;
+                  
+                  -- Clean the search prefix: remove special characters, normalize spaces
+                  clean_prefix := regexp_replace(trim(search_prefix), '[^a-zA-Z0-9\\s]', ' ', 'g');
+                  clean_prefix := regexp_replace(clean_prefix, '\\s+', ' ', 'g');
+                  clean_prefix := trim(clean_prefix);
+                  
+                  -- Handle empty string after cleaning
+                  IF clean_prefix = '' THEN
+                    RETURN;
+                  END IF;
+                  
+                  -- Split into words and build partial search query
+                  words := string_to_array(clean_prefix, ' ');
+                  
+                  -- Build tsquery for partial matching
+                  FOR i IN 1..array_length(words, 1) LOOP
+                    word := words[i];
+                    IF word != '' THEN
+                      IF tsquery_str != '' THEN
+                        tsquery_str := tsquery_str || ' & ';
+                      END IF;
+                      -- Add prefix matching for each word
+                      tsquery_str := tsquery_str || word || ':*';
+                    END IF;
+                  END LOOP;
+                  
+                  -- Return query searching across all searchable fields
+                  RETURN QUERY
+                  SELECT * FROM "public"."${actualTableName}"
+                  WHERE 
+                    (
+                      -- Use the built tsquery for structured search
+                      to_tsvector('english', 
+                        COALESCE("${actualColumnNames.join('", \'\') || \' \' || COALESCE("')}", '')
+                      ) @@ to_tsquery('english', tsquery_str)
+                      OR
+                      -- Fallback to simple text matching across all fields
+                      (${actualColumnNames.map(col => `"${col}" ILIKE '%' || search_prefix || '%'`).join(' OR ')})
+                    );
+                EXCEPTION
+                  WHEN others THEN
+                    -- Log error and return empty result set instead of failing
+                    RAISE NOTICE 'Multi-field search function error: %, falling back to simple ILIKE search', SQLERRM;
+                    -- Fallback to simple pattern matching across all fields
+                    RETURN QUERY
+                    SELECT * FROM "public"."${actualTableName}"
+                    WHERE 
+                      (${actualColumnNames.map(col => `"${col}" ILIKE '%' || search_prefix || '%'`).join(' OR ')});
+                    RETURN;
+                END;
+                $$ LANGUAGE plpgsql STABLE;`;
+                            await pool.query(createMultiFieldFunctionQuery);
+                            console.log(`      ✅ Created multi-field search function: "${multiFieldFunctionName}"(search_prefix text)`);
+                            // Create multi-field GIN index
+                            const createMultiFieldIndexQuery = `
+                DO $$
+                BEGIN
+                  IF NOT EXISTS (
+                    SELECT 1 FROM pg_indexes 
+                    WHERE schemaname = 'public' 
+                    AND tablename = '${actualTableName}'
+                    AND indexname = '${multiFieldIndexName}'
+                  ) THEN
+                    CREATE INDEX "${multiFieldIndexName}" ON "public"."${actualTableName}" 
+                    USING GIN (to_tsvector('english', 
+                      COALESCE("${actualColumnNames.join('", \'\') || \' \' || COALESCE("')}", '')
+                    ));
+                    RAISE NOTICE '      ✅ Created multi-field GIN index: "${multiFieldIndexName}"';
+                  ELSE
+                    RAISE NOTICE '      ℹ️ Multi-field GIN index "${multiFieldIndexName}" already exists.';
+                  END IF;
+                END;
+                $$;`;
+                            await pool.query(createMultiFieldIndexQuery);
+                        }
+                    }
+                    catch (err) {
+                        console.error(`      ❌ Failed to set up multi-field search for "${actualTableName}": ${err.message}`);
+                    }
+                }
             }
             else {
                 console.log(`  ℹ️ No fields marked with // @enableSearch for model ${model.name}.`);