suparisma 1.1.2 → 1.2.2

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,51 @@ 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, '\\\\\\\\$&');
+}
+
+/**
+ * Generate a UUID v4, with fallback for environments without crypto.randomUUID()
+ * Works in: browsers, Node.js, and React Native (with react-native-get-random-values polyfill)
+ * 
+ * For React Native, ensure you have installed and imported the polyfill:
+ * - pnpm install react-native-get-random-values
+ * - Import at app entry point: import 'react-native-get-random-values';
+ */
+export function generateUUID(): string {
+  // Try native crypto.randomUUID() first (modern browsers & Node.js 16.7+)
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID();
+  }
+  
+  // Fallback using crypto.getRandomValues() (works with react-native-get-random-values polyfill)
+  if (typeof crypto !== 'undefined' && typeof crypto.getRandomValues === 'function') {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    
+    // Set version (4) and variant (RFC 4122)
+    bytes[6] = (bytes[6] & 0x0f) | 0x40; // Version 4
+    bytes[8] = (bytes[8] & 0x3f) | 0x80; // Variant RFC 4122
+    
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+    return \`\${hex.slice(0, 8)}-\${hex.slice(8, 12)}-\${hex.slice(12, 16)}-\${hex.slice(16, 20)}-\${hex.slice(20)}\`;
+  }
+  
+  // Last resort fallback using Math.random() (not cryptographically secure)
+  console.warn('[Suparisma] crypto API not available, using Math.random() fallback for UUID generation');
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
 /**
  * Advanced filter operators for complex queries
  * @example
@@ -162,10 +211,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 +241,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 +966,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 +1021,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
@@ -934,82 +1074,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);
         }
@@ -1580,7 +1726,7 @@ export function createSuparismaHook<
             if (defaultValue.includes('now()') || defaultValue.includes('now')) {
               appliedDefaults[field] = now.toISOString(); // Database expects ISO string
             } else if (defaultValue.includes('uuid()') || defaultValue.includes('uuid')) {
-              appliedDefaults[field] = crypto.randomUUID();
+              appliedDefaults[field] = generateUUID();
             } 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);

package/dist/generators/supabaseClientGenerator.js

@@ -6,21 +6,83 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSupabaseClientFile = generateSupabaseClientFile;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const config_1 = require("../config"); // Ensure this is UTILS_DIR
+const config_1 = require("../config");
+/**
+ * Generate the Supabase client file based on the target platform.
+ * Supports both web (Next.js, etc.) and React Native/Expo.
+ */
 function generateSupabaseClientFile() {
-    const supabaseClientContent = `// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+    let supabaseClientContent;
+    if (config_1.PLATFORM === 'react-native') {
+        // React Native / Expo compatible client
+        supabaseClientContent = `// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+// Platform: React Native / Expo
+//
+// IMPORTANT: Before using Suparisma in React Native, ensure you have:
+// 1. Installed required dependencies:
+//    pnpm install @supabase/supabase-js @react-native-async-storage/async-storage react-native-url-polyfill
+//
+// 2. Added polyfills at your app's entry point (e.g., App.tsx or index.js):
+//    import 'react-native-url-polyfill/auto';
+//
+// 3. Set your Supabase credentials below or via environment variables
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
 import { createClient } from '@supabase/supabase-js';
 
-export const supabase = createClient(
-  process.env.NEXT_PUBLIC_SUPABASE_URL!,
-  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
-);
+// Option 1: Set your Supabase credentials directly (for quick setup)
+// const SUPABASE_URL = 'https://your-project.supabase.co';
+// const SUPABASE_ANON_KEY = 'your-anon-key';
+
+// Option 2: Use environment variables (recommended for production)
+// With Expo, use expo-constants or babel-plugin-inline-dotenv
+// With bare React Native, use react-native-dotenv
+const SUPABASE_URL = process.env.EXPO_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || '';
+const SUPABASE_ANON_KEY = process.env.EXPO_PUBLIC_SUPABASE_ANON_KEY || process.env.SUPABASE_ANON_KEY || '';
+
+if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+  console.warn(
+    '[Suparisma] Supabase credentials not found. Please set EXPO_PUBLIC_SUPABASE_URL and EXPO_PUBLIC_SUPABASE_ANON_KEY ' +
+    'in your environment variables, or update the credentials directly in this file.'
+  );
+}
+
+export const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+  auth: {
+    storage: AsyncStorage,
+    autoRefreshToken: true,
+    persistSession: true,
+    detectSessionInUrl: false, // Important for React Native
+  },
+});
 `;
+    }
+    else {
+        // Web platform (Next.js, Remix, etc.)
+        supabaseClientContent = `// THIS FILE IS AUTO-GENERATED - DO NOT EDIT DIRECTLY
+// Platform: Web (Next.js, Remix, etc.)
+import { createClient } from '@supabase/supabase-js';
+
+// For Next.js, use NEXT_PUBLIC_ prefix
+// For other frameworks, adjust the environment variable names as needed
+const SUPABASE_URL = process.env.NEXT_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || '';
+const SUPABASE_ANON_KEY = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || process.env.SUPABASE_ANON_KEY || '';
+
+if (!SUPABASE_URL || !SUPABASE_ANON_KEY) {
+  console.warn(
+    '[Suparisma] Supabase credentials not found. Please set NEXT_PUBLIC_SUPABASE_URL and NEXT_PUBLIC_SUPABASE_ANON_KEY ' +
+    '(or SUPABASE_URL and SUPABASE_ANON_KEY) in your environment variables.'
+  );
+}
+
+export const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
+`;
+    }
     // Output to the UTILS_DIR
     const outputPath = path_1.default.join(config_1.UTILS_DIR, 'supabase-client.ts');
     if (!fs_1.default.existsSync(config_1.UTILS_DIR)) {
         fs_1.default.mkdirSync(config_1.UTILS_DIR, { recursive: true });
     }
     fs_1.default.writeFileSync(outputPath, supabaseClientContent);
-    console.log(`🚀 Generated Supabase client file at: ${outputPath}`);
+    console.log(`🚀 Generated Supabase client file at: ${outputPath} (platform: ${config_1.PLATFORM})`);
 }

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 '';
         })