fix(sqlstorage): fix cursor pagination with json tag lookup and placeholder handling

* Use JSON struct tags instead of Go field names for cursor value extraction
* Remove PostgreSQL  pre-conversion that conflicted with GORM's placeholders

Author: Lutherwaves

storage/search/lucene/parser_test.go

@@ -134,37 +134,37 @@ func TestBasicFieldSearch(t *testing.T) {
 		{
 			name:       "simple field query",
 			query:      "name:john",
-			wantSQL:    []string{`"name"`, "=", "$1"},
+			wantSQL:    []string{`"name"`, "=", "?"},
 			wantNot:    []string{"ILIKE", "LIKE"},
 			wantParams: []any{"john"},
 			wantErr:    false,
 		},
 		{
 			name:       "wildcard prefix",
 			query:      "name:john*",
-			wantSQL:    []string{`"name"`, "ILIKE", "$1"},
+			wantSQL:    []string{`"name"`, "ILIKE", "?"},
 			wantNot:    []string{"="},
 			wantParams: []any{"john%"},
 			wantErr:    false,
 		},
 		{
 			name:       "wildcard suffix",
 			query:      "name:*john",
-			wantSQL:    []string{`"name"`, "ILIKE", "$1"},
+			wantSQL:    []string{`"name"`, "ILIKE", "?"},
 			wantParams: []any{"%john"},
 			wantErr:    false,
 		},
 		{
 			name:       "wildcard contains",
 			query:      "name:*john*",
-			wantSQL:    []string{`"name"`, "ILIKE", "$1"},
+			wantSQL:    []string{`"name"`, "ILIKE", "?"},
 			wantParams: []any{"%john%"},
 			wantErr:    false,
 		},
 		{
 			name:       "email field",
 			query:      `email:"test@example.com"`,
-			wantSQL:    []string{`"email"`, "=", "$1"},
+			wantSQL:    []string{`"email"`, "=", "?"},
 			wantParams: []any{"test@example.com"},
 			wantErr:    false,
 		},
@@ -706,7 +706,7 @@ func TestNullValueQueries(t *testing.T) {
 			name:       "field is null (lowercase)",
 			query:      "parent_id:null",
 			wantSQL:    []string{`"parent_id"`, "IS NULL"},
-			wantNot:    []string{"=", "$1"},
+			wantNot:    []string{"=", "?"},
 			wantParams: []any{},
 			wantErr:    false,
 		},
@@ -741,7 +741,7 @@ func TestNullValueQueries(t *testing.T) {
 		{
 			name:       "nil should be treated as literal value (not NULL)",
 			query:      "name:nil",
-			wantSQL:    []string{`"name"`, "=", "$1"},
+			wantSQL:    []string{`"name"`, "=", "?"},
 			wantParams: []any{"nil"},
 			wantErr:    false,
 		},
@@ -1206,8 +1206,8 @@ func TestParser_ProviderSpecific(t *testing.T) {
 			name:       "postgresql placeholder",
 			query:      "name:john",
 			provider:   "postgresql",
-			wantSQL:    []string{"$1"},
-			wantNot:    []string{"?"},
+			wantSQL:    []string{"?"},
+			wantNot:    []string{"$"},
 			wantParams: []any{"john"},
 			wantErr:    false,
 		},

storage/search/lucene/sql_driver.go

@@ -82,14 +82,10 @@ func (s *SQLDriver) RenderParam(e *expr.Expression) (string, []any, error) {
 		return "", nil, err
 	}
 
-	// Convert ? placeholders to provider-specific format
-	// PostgreSQL uses $1, $2, $3; MySQL and SQLite use ?
-	switch s.provider {
-	case "postgresql":
-		str = convertToPostgresPlaceholders(str)
-	case "mysql", "sqlite":
-		// Already uses ? placeholders, no conversion needed
-	}
+	// Keep ? placeholders for all providers.
+	// GORM's PostgreSQL driver handles ? → $N conversion automatically,
+	// so pre-converting here would conflict with additional WHERE clauses
+	// (e.g. cursor pagination) that GORM adds with its own ? placeholders.
 
 	return str, params, nil
 }
@@ -404,7 +400,7 @@ func validateSubFieldName(subField string) error {
 	if subField == "" {
 		return fmt.Errorf("subfield name cannot be empty")
 	}
-	
+
 	if !jsonSubFieldPattern.MatchString(subField) {
 		return fmt.Errorf("invalid subfield name '%s': contains unsafe characters (only alphanumeric, underscore, and dot allowed)", subField)
 	}

storage/search/lucene/sql_driver_test.go

@@ -204,14 +204,9 @@ func TestSQLDriver_RenderParam(t *testing.T) {
 				if len(params) != tt.wantCount {
 					t.Errorf("RenderParam() params count = %v, want %v", len(params), tt.wantCount)
 				}
-				if provider == "postgresql" {
-					if !strings.Contains(sql, "$") {
-						t.Errorf("RenderParam() expected PostgreSQL placeholders ($1, $2), got %v", sql)
-					}
-				} else {
-					if strings.Contains(sql, "$") && !strings.Contains(sql, "?") {
-						t.Errorf("RenderParam() expected ? placeholders for %v, got %v", provider, sql)
-					}
+				// All providers use ? placeholders; GORM handles $N conversion for PostgreSQL
+				if tt.wantCount > 0 && !strings.Contains(sql, "?") {
+					t.Errorf("RenderParam() expected ? placeholders for %v, got %v", provider, sql)
 				}
 			})
 		}
@@ -1443,11 +1438,11 @@ func TestSQLDriver_ProviderSpecific(t *testing.T) {
 				Left:  expr.Column("name"),
 				Right: &expr.Expression{Op: expr.Literal, Left: "john"},
 			},
-			wantSQL:   []string{"$1"},
+			wantSQL:   []string{"?"},
 			wantCount: 1,
 			checkFunc: func(t *testing.T, sql string, params []any) {
-				if !strings.Contains(sql, "$") {
-					t.Errorf("expected PostgreSQL placeholder ($1), got %v", sql)
+				if !strings.Contains(sql, "?") {
+					t.Errorf("expected ? placeholder, got %v", sql)
 				}
 			},
 		},

storage/sql.go

@@ -260,11 +260,11 @@ func (s *SQLAdapter) executePaginatedQuery(
 	nextCursor := ""
 	if destSlice.Len() > limit {
 		lastItem := destSlice.Index(limit - 1)
-		field := reflect.Indirect(lastItem).FieldByName(sortKey)
+		field := findFieldByJSONTag(reflect.Indirect(lastItem), sortKey)
 		if !field.IsValid() {
-			slog.Warn("cursor extraction failed: sort_key does not match any exported struct field",
+			slog.Warn("cursor extraction failed: sort_key does not match any json tag on the struct",
 				"sort_key", sortKey,
-				"hint", "sort_key must be the Go struct field name (e.g. 'CreatedAt'), not the DB column name (e.g. 'created_at')")
+				"hint", "sort_key must match a json tag (e.g. 'created_at'), not the Go field name (e.g. 'CreatedAt')")
 		} else if field.Kind() != reflect.String {
 			slog.Warn("cursor extraction failed: struct field is not a string",
 				"sort_key", sortKey,
@@ -278,6 +278,23 @@ func (s *SQLAdapter) executePaginatedQuery(
 	return nextCursor, nil
 }
 
+// findFieldByJSONTag looks up a struct field by its json tag name.
+// This is needed because sortKey uses the JSON/column name (e.g. "id")
+// while Go struct fields use PascalCase (e.g. "Id").
+func findFieldByJSONTag(v reflect.Value, tag string) reflect.Value {
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		jsonTag := t.Field(i).Tag.Get("json")
+		if idx := strings.Index(jsonTag, ","); idx != -1 {
+			jsonTag = jsonTag[:idx]
+		}
+		if jsonTag == tag {
+			return v.Field(i)
+		}
+	}
+	return reflect.Value{}
+}
+
 func (s *SQLAdapter) List(dest any, sortKey string, filter map[string]any, limit int, cursor string, params ...map[string]any) (string, error) {
 	sortDirection, err := extractSortDirection(extractParams(params...))
 	if err != nil {