suparisma 1.1.1 → 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;
 };
 
 /**
@@ -248,19 +281,23 @@ export function buildFilterString<T>(where?: T): string | undefined {
         }
         
         if ('gt' in advancedOps && advancedOps.gt !== undefined) {
-          filters.push(\`\${key}=gt.\${advancedOps.gt}\`);
+          const value = advancedOps.gt instanceof Date ? advancedOps.gt.toISOString() : advancedOps.gt;
+          filters.push(\`\${key}=gt.\${value}\`);
         }
         
         if ('gte' in advancedOps && advancedOps.gte !== undefined) {
-          filters.push(\`\${key}=gte.\${advancedOps.gte}\`);
+          const value = advancedOps.gte instanceof Date ? advancedOps.gte.toISOString() : advancedOps.gte;
+          filters.push(\`\${key}=gte.\${value}\`);
         }
         
         if ('lt' in advancedOps && advancedOps.lt !== undefined) {
-          filters.push(\`\${key}=lt.\${advancedOps.lt}\`);
+          const value = advancedOps.lt instanceof Date ? advancedOps.lt.toISOString() : advancedOps.lt;
+          filters.push(\`\${key}=lt.\${value}\`);
         }
         
         if ('lte' in advancedOps && advancedOps.lte !== undefined) {
-          filters.push(\`\${key}=lte.\${advancedOps.lte}\`);
+          const value = advancedOps.lte instanceof Date ? advancedOps.lte.toISOString() : advancedOps.lte;
+          filters.push(\`\${key}=lte.\${value}\`);
         }
         
         if ('in' in advancedOps && advancedOps.in?.length) {
@@ -345,23 +382,31 @@ function applyConditionGroup<T>(
         }
         
         if ('gt' in advancedOps && advancedOps.gt !== undefined) {
+          // Convert Date objects to ISO strings for Supabase
+          const value = advancedOps.gt instanceof Date ? advancedOps.gt.toISOString() : advancedOps.gt;
           // @ts-ignore: Supabase typing issue
-          filteredQuery = filteredQuery.gt(key, advancedOps.gt);
+          filteredQuery = filteredQuery.gt(key, value);
         }
         
         if ('gte' in advancedOps && advancedOps.gte !== undefined) {
+          // Convert Date objects to ISO strings for Supabase
+          const value = advancedOps.gte instanceof Date ? advancedOps.gte.toISOString() : advancedOps.gte;
           // @ts-ignore: Supabase typing issue
-          filteredQuery = filteredQuery.gte(key, advancedOps.gte);
+          filteredQuery = filteredQuery.gte(key, value);
         }
         
         if ('lt' in advancedOps && advancedOps.lt !== undefined) {
+          // Convert Date objects to ISO strings for Supabase
+          const value = advancedOps.lt instanceof Date ? advancedOps.lt.toISOString() : advancedOps.lt;
           // @ts-ignore: Supabase typing issue
-          filteredQuery = filteredQuery.lt(key, advancedOps.lt);
+          filteredQuery = filteredQuery.lt(key, value);
         }
         
         if ('lte' in advancedOps && advancedOps.lte !== undefined) {
+          // Convert Date objects to ISO strings for Supabase
+          const value = advancedOps.lte instanceof Date ? advancedOps.lte.toISOString() : advancedOps.lte;
           // @ts-ignore: Supabase typing issue
-          filteredQuery = filteredQuery.lte(key, advancedOps.lte);
+          filteredQuery = filteredQuery.lte(key, value);
         }
         
         if ('in' in advancedOps && advancedOps.in?.length) {
@@ -458,13 +503,17 @@ export function applyFilter<T>(
               } else if ('not' in advancedOps && advancedOps.not !== undefined) {
                 orFilters.push(\`\${key}.neq.\${advancedOps.not}\`);
               } else if ('gt' in advancedOps && advancedOps.gt !== undefined) {
-                orFilters.push(\`\${key}.gt.\${advancedOps.gt}\`);
+                const value = advancedOps.gt instanceof Date ? advancedOps.gt.toISOString() : advancedOps.gt;
+                orFilters.push(\`\${key}.gt.\${value}\`);
               } else if ('gte' in advancedOps && advancedOps.gte !== undefined) {
-                orFilters.push(\`\${key}.gte.\${advancedOps.gte}\`);
+                const value = advancedOps.gte instanceof Date ? advancedOps.gte.toISOString() : advancedOps.gte;
+                orFilters.push(\`\${key}.gte.\${value}\`);
               } else if ('lt' in advancedOps && advancedOps.lt !== undefined) {
-                orFilters.push(\`\${key}.lt.\${advancedOps.lt}\`);
+                const value = advancedOps.lt instanceof Date ? advancedOps.lt.toISOString() : advancedOps.lt;
+                orFilters.push(\`\${key}.lt.\${value}\`);
               } else if ('lte' in advancedOps && advancedOps.lte !== undefined) {
-                orFilters.push(\`\${key}.lte.\${advancedOps.lte}\`);
+                const value = advancedOps.lte instanceof Date ? advancedOps.lte.toISOString() : advancedOps.lte;
+                orFilters.push(\`\${key}.lte.\${value}\`);
               } else if ('in' in advancedOps && advancedOps.in?.length) {
                 orFilters.push(\`\${key}.in.(\${advancedOps.in.join(',')})\`);
               } else if ('contains' in advancedOps && advancedOps.contains !== undefined) {
@@ -528,6 +577,18 @@ function matchesFilter<T>(record: any, filter: T): boolean {
     }
   }
   
+  // Helper function to convert values to comparable format for date/time comparisons
+  const getComparableValue = (value: any): any => {
+    if (value instanceof Date) {
+      return value.getTime();
+    }
+    if (typeof value === 'string' && value.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)) {
+      // ISO date string
+      return new Date(value).getTime();
+    }
+    return value;
+  };
+
   // Helper function to check individual field conditions
   const checkFieldConditions = (conditions: any): boolean => {
     for (const [key, value] of Object.entries(conditions)) {
@@ -547,19 +608,27 @@ function matchesFilter<T>(record: any, filter: T): boolean {
           }
           
           if ('gt' in advancedOps && advancedOps.gt !== undefined) {
-            if (!(recordValue > advancedOps.gt)) return false;
+            const recordComparable = getComparableValue(recordValue);
+            const filterComparable = getComparableValue(advancedOps.gt);
+            if (!(recordComparable > filterComparable)) return false;
           }
           
           if ('gte' in advancedOps && advancedOps.gte !== undefined) {
-            if (!(recordValue >= advancedOps.gte)) return false;
+            const recordComparable = getComparableValue(recordValue);
+            const filterComparable = getComparableValue(advancedOps.gte);
+            if (!(recordComparable >= filterComparable)) return false;
           }
           
           if ('lt' in advancedOps && advancedOps.lt !== undefined) {
-            if (!(recordValue < advancedOps.lt)) return false;
+            const recordComparable = getComparableValue(recordValue);
+            const filterComparable = getComparableValue(advancedOps.lt);
+            if (!(recordComparable < filterComparable)) return false;
           }
           
           if ('lte' in advancedOps && advancedOps.lte !== undefined) {
-            if (!(recordValue <= advancedOps.lte)) return false;
+            const recordComparable = getComparableValue(recordValue);
+            const filterComparable = getComparableValue(advancedOps.lte);
+            if (!(recordComparable <= filterComparable)) return false;
           }
           
           if ('in' in advancedOps && advancedOps.in?.length) {
@@ -861,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
@@ -884,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\`;
+            
+            console.log(\`🔍 Executing search: \${functionName}(search_prefix: "\${query.value.trim()}")\`);
             
-            // Call RPC function
-            return supabase.rpc(functionName, { 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
@@ -898,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);
         }
@@ -1518,7 +1664,20 @@ export function createSuparismaHook<
         setLoading(true);
         setError(null);
         
-        const now = new Date().toISOString();
+        const now = new Date();
+        
+        // Helper function to convert Date objects to ISO strings for database
+        const convertDatesForDatabase = (obj: any): any => {
+          const result: any = {};
+          for (const [key, value] of Object.entries(obj)) {
+            if (value instanceof Date) {
+              result[key] = value.toISOString();
+            } else {
+              result[key] = value;
+            }
+          }
+          return result;
+        };
         
         // Apply default values from schema
         const appliedDefaults: Record<string, any> = {};
@@ -1529,7 +1688,7 @@ export function createSuparismaHook<
           if (!(field in data)) {
             // Parse the default value based on its type
             if (defaultValue.includes('now()') || defaultValue.includes('now')) {
-              appliedDefaults[field] = now;
+              appliedDefaults[field] = now.toISOString(); // Database expects ISO string
             } else if (defaultValue.includes('uuid()') || defaultValue.includes('uuid')) {
               appliedDefaults[field] = crypto.randomUUID();
             } else if (defaultValue.includes('cuid()') || defaultValue.includes('cuid')) {
@@ -1550,13 +1709,13 @@ export function createSuparismaHook<
           }
         }
         
-        const itemWithDefaults = {
+        const itemWithDefaults = convertDatesForDatabase({
           ...appliedDefaults, // Apply schema defaults first
           ...data, // Then user data (overrides defaults)
-          // Use the actual field names from Prisma
-          ...(hasCreatedAt ? { [createdAtField]: now } : {}), 
-          ...(hasUpdatedAt ? { [updatedAtField]: now } : {})
-        };
+          // Use the actual field names from Prisma - convert Date to ISO string for database
+          ...(hasCreatedAt ? { [createdAtField]: now.toISOString() } : {}), 
+          ...(hasUpdatedAt ? { [updatedAtField]: now.toISOString() } : {})
+        });
         
         const { data: result, error } = await supabase
           .from(tableName)
@@ -1624,17 +1783,30 @@ export function createSuparismaHook<
           throw new Error('A unique identifier is required');
         }
         
-        const now = new Date().toISOString();
+        const now = new Date();
+        
+        // Helper function to convert Date objects to ISO strings for database
+        const convertDatesForDatabase = (obj: any): any => {
+          const result: any = {};
+          for (const [key, value] of Object.entries(obj)) {
+            if (value instanceof Date) {
+              result[key] = value.toISOString();
+            } else {
+              result[key] = value;
+            }
+          }
+          return result;
+        };
         
         // 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 = {
+        const itemWithDefaults = convertDatesForDatabase({
           ...params.data,
-          // Use the actual updatedAt field name from Prisma
-          ...(hasUpdatedAt ? { [updatedAtField]: now } : {})
-        };
+          // Use the actual updatedAt field name from Prisma - convert Date to ISO string for database
+          ...(hasUpdatedAt ? { [updatedAtField]: now.toISOString() } : {})
+        });
         
         const { data, error } = await supabase
           .from(tableName)

package/dist/generators/typeGenerator.js

@@ -69,7 +69,7 @@ function generateModelTypesFile(model) {
                 baseType = 'boolean';
                 break;
             case 'DateTime':
-                baseType = 'string'; // ISO date string
+                baseType = 'Date'; // Proper Date type for DateTime fields
                 break;
             case 'Json':
                 baseType = 'any'; // Or a more specific structured type if available
@@ -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 '';
         })