suparisma 1.1.1 → 1.2.1

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}.`);

package/dist/parser.js

@@ -70,10 +70,10 @@ function parseZodImport(comment) {
  */
 function parsePrismaSchema(schemaPath) {
     const schema = fs_1.default.readFileSync(schemaPath, 'utf-8');
-    const modelRegex = /model\s+(\w+)\s+{([^}]*)}/gs;
+    const modelRegex = /model\s+(\w+)\s+{([^}]*)}/g;
     const models = [];
     // Extract enum names from the schema
-    const enumRegex = /enum\s+(\w+)\s+{[^}]*}/gs;
+    const enumRegex = /enum\s+(\w+)\s+{[^}]*}/g;
     const enumNames = [];
     let enumMatch;
     while ((enumMatch = enumRegex.exec(schema)) !== null) {
@@ -95,77 +95,87 @@ function parsePrismaSchema(schemaPath) {
         const searchFields = [];
         // Track zod imports at model level
         const zodImports = [];
-        const lines = modelBody.split('\n');
-        let lastFieldName = '';
-        let lastFieldType = '';
+        // Use EXACT same logic as analyzePrismaSchema for consistency
+        const bodyLines = modelBody.trim().split('\n');
+        let nextFieldShouldBeSearchable = false;
         let pendingZodDirective;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i]?.trim();
+        for (let i = 0; i < bodyLines.length; i++) {
+            const currentLine = bodyLines[i]?.trim();
             // Skip blank lines and non-field lines
-            if (!line || line.startsWith('@@')) {
+            if (!currentLine || currentLine.startsWith('@@')) {
                 continue;
             }
-            // Check for standalone @enableSearch comment
-            if (line === '// @enableSearch' && lastFieldName) {
-                searchFields.push({
-                    name: lastFieldName,
-                    type: lastFieldType,
-                });
+            // Check for /// @enableSearch directive (applies to NEXT field)
+            if (currentLine === '/// @enableSearch') {
+                nextFieldShouldBeSearchable = true;
                 continue;
             }
-            // Check if line is a comment
-            if (line.startsWith('//')) {
+            // 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('//')) {
                 // Parse zod directives from comments
-                const zodDirective = parseZodDirective(line);
+                const zodDirective = parseZodDirective(currentLine);
                 if (zodDirective) {
                     pendingZodDirective = zodDirective;
                 }
                 // Parse zod imports from comments
-                const zodImportInfos = parseZodImport(line);
+                const zodImportInfos = parseZodImport(currentLine);
                 zodImports.push(...zodImportInfos);
                 continue;
             }
-            // Parse field definition - Updated to handle array types
-            const fieldMatch = line.match(/\s*(\w+)\s+(\w+)(\[\])?(\?)?\s*(?:@[^)]+)?/);
+            // 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 baseFieldType = fieldMatch[2]; // e.g., "String" from "String[]"
+                const baseFieldType = fieldMatch[2];
+                // Check if this field should be searchable due to @enableSearch directive
+                if (nextFieldShouldBeSearchable && fieldName && baseFieldType) {
+                    searchFields.push({
+                        name: fieldName,
+                        type: baseFieldType,
+                    });
+                    nextFieldShouldBeSearchable = false; // Reset flag
+                }
+                // Check for inline // @enableSearch comment
+                if (currentLine.includes('// @enableSearch')) {
+                    if (fieldName && baseFieldType && !searchFields.some(f => f.name === fieldName)) {
+                        searchFields.push({
+                            name: fieldName,
+                            type: baseFieldType,
+                        });
+                    }
+                }
+                // Continue with field processing for the fields array
                 const isArray = !!fieldMatch[3]; // [] makes it an array
                 const isOptional = !!fieldMatch[4]; // ? makes it optional
-                // Store for potential standalone @enableSearch comment
-                lastFieldName = fieldName || '';
-                lastFieldType = baseFieldType || '';
                 // Detect special fields
-                const isId = line.includes('@id');
+                const isId = currentLine.includes('@id');
                 const isCreatedAt = fieldName === 'created_at' || fieldName === 'createdAt';
                 const isUpdatedAt = fieldName === 'updated_at' || fieldName === 'updatedAt';
-                const hasDefaultValue = line.includes('@default');
+                const hasDefaultValue = currentLine.includes('@default');
                 // Extract default value if present
                 let defaultValue;
                 if (hasDefaultValue) {
-                    const defaultMatch = line.match(/@default\(\s*(.+?)\s*\)/);
+                    const defaultMatch = currentLine.match(/@default\(\s*(.+?)\s*\)/);
                     if (defaultMatch) {
                         defaultValue = defaultMatch[1];
                     }
                 }
                 // Improved relation detection
                 const primitiveTypes = ['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Json', 'Bytes', 'Decimal', 'BigInt'];
-                const isRelation = line.includes('@relation') ||
+                const isRelation = currentLine.includes('@relation') ||
                     (!!fieldName &&
                         (fieldName.endsWith('_id') || fieldName === 'userId' || fieldName === 'user_id')) ||
                     // Also detect relation fields by checking if the type is not a primitive type and not an enum
                     (!!baseFieldType && !primitiveTypes.includes(baseFieldType) && !enumNames.includes(baseFieldType));
-                // Check for inline @enableSearch comment
-                if (line.includes('// @enableSearch')) {
-                    searchFields.push({
-                        name: fieldName || '',
-                        type: baseFieldType || '',
-                    });
-                }
                 // Check for inline zod directive
                 let fieldZodDirective = pendingZodDirective;
-                if (line.includes('/// @zod.')) {
-                    const inlineZodDirective = parseZodDirective(line);
+                if (currentLine.includes('/// @zod.')) {
+                    const inlineZodDirective = parseZodDirective(currentLine);
                     if (inlineZodDirective) {
                         fieldZodDirective = inlineZodDirective;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "suparisma",
-	"version": "1.1.1",
+	"version": "1.2.1",
 	"description": "Opinionated typesafe React realtime CRUD hooks generator for all your Supabase tables, powered by Prisma.",
 	"main": "dist/index.js",
 	"repository": {

package/prisma/schema.prisma

@@ -21,7 +21,9 @@ enum SomeEnum {
 
 model User {
   id        String   @id @default(uuid())
+  // @enableSearch
   name      String
+  // @enableSearch  
   email     String   @unique
   things    Thing[]  // One-to-many relation
   createdAt DateTime @default(now())
@@ -33,11 +35,14 @@ model Thing {
   id        String   @id @default(uuid())
   // @enableSearch
   name      String? 
+  // @enableSearch
+  /// Somehting here
+  description String? /// @thing
   stringArray String[]
   someEnum  SomeEnum @default(ONE)
   someNumber Int?
 
-  /// [Json]
+  // @enableSearch
   someJson Json? /// @zod.custom.use(z.array(LLMNodeSchema).nullable())
   userId    String?
   user      User?    @relation(fields: [userId], references: [id])