pkg/subscraping/sources/onhype/onhype.go (2)

91-113: Unused Result fields Host and Domain are never emitted.

The Result struct defines Host and Domain fields (lines 30-31), and the custom UnmarshalJSON method populates them (lines 275-297), but the Run method only emits Subdomains, Hostname, Forward, and Reverse.

If Host and Domain fields contain useful subdomain data, emit them as well:

 			if record.Reverse != "" {
 				results <- subscraping.Result{Source: s.Name(), Type: subscraping.Subdomain, Value: record.Reverse}
 				s.results++
 			}
+
+			if record.Host != "" {
+				results <- subscraping.Result{Source: s.Name(), Type: subscraping.Subdomain, Value: record.Host}
+				s.results++
+			}
+
+			if record.Domain != "" {
+				results <- subscraping.Result{Source: s.Name(), Type: subscraping.Subdomain, Value: record.Domain}
+				s.results++
+			}
 		}

Alternatively, if these fields are not needed, remove them from the Result struct and the UnmarshalJSON method to reduce complexity.

---

157-228: LGTM with optional refactor suggestion.

The custom UnmarshalJSON for OnypheResponse correctly handles ONYPHE API responses where numeric fields (page, page_size, total, max_page) may be returned as either numbers or strings.

The normalization logic is repetitive. Consider extracting it into a helper function:

func parseIntField(raw json.RawMessage) (int, error) {
	if len(raw) == 0 {
		return 0, nil
	}
	
	// Try direct parse
	if val, err := strconv.Atoi(string(raw)); err == nil {
		return val, nil
	}
	
	// Try unquoted string
	var str string
	if err := json.Unmarshal(raw, &str); err == nil {
		if val, err := strconv.Atoi(str); err == nil {
			return val, nil
		}
	}
	
	return 0, fmt.Errorf("cannot parse int from %s", string(raw))
}

Then use it in UnmarshalJSON:

o.Page, _ = parseIntField(raw.Page)
o.PageSize, _ = parseIntField(raw.PageSize)
o.Total, _ = parseIntField(raw.Total)
o.MaxPage, _ = parseIntField(raw.MaxPage)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

pkg/subscraping/sources/onyphe/onyphe.go (1)

267-273: Address error handling as flagged in previous review.

The previous review flagged ignoring json.Unmarshal errors on lines 268 and 272 as a critical issue. While using the blank identifier _ bypasses the linter, it still silently discards malformed JSON.

For consistency with the error handling pattern used for other fields (Hostname, Host, Domain), consider handling these errors or documenting why they can be safely ignored.

Apply this diff to handle errors consistently:

 	if len(raw.Forward) > 0 {
-		_ = json.Unmarshal(raw.Forward, &r.Forward)
+		var forwardStr string
+		if err := json.Unmarshal(raw.Forward, &forwardStr); err == nil {
+			r.Forward = forwardStr
+		}
 	}

 	if len(raw.Reverse) > 0 {
-		_ = json.Unmarshal(raw.Reverse, &r.Reverse)
+		var reverseStr string
+		if err := json.Unmarshal(raw.Reverse, &reverseStr); err == nil {
+			r.Reverse = reverseStr
+		}
 	}

pkg/subscraping/sources/onyphe/onyphe.go (2)

91-113: Consider deduplication for subdomain results.

The code emits subdomains from multiple fields (Subdomains array, Hostname, Forward, Reverse) without deduplication. If ONYPHE returns the same subdomain in different fields, it will be emitted multiple times, inflating the result count.

Consider adding deduplication logic or verify that the upstream consumer handles duplicates.

Example implementation with a map to track seen subdomains:

+		seen := make(map[string]bool)
+		
 		for _, record := range respOnyphe.Results {
 			for _, subdomain := range record.Subdomains {
-				if subdomain != "" {
+				if subdomain != "" && !seen[subdomain] {
+					seen[subdomain] = true
 					results <- subscraping.Result{Source: s.Name(), Type: subscraping.Subdomain, Value: subdomain}
 					s.results++
 				}
 			}
 
-			if record.Hostname != "" {
+			if record.Hostname != "" && !seen[record.Hostname] {
+				seen[record.Hostname] = true
 				results <- subscraping.Result{Source: s.Name(), Type: subscraping.Subdomain, Value: record.Hostname}
 				s.results++
 			}
 
-			if record.Forward != "" {
+			if record.Forward != "" && !seen[record.Forward] {
+				seen[record.Forward] = true
 				results <- subscraping.Result{Source: s.Name(), Type: subscraping.Subdomain, Value: record.Forward}
 				s.results++
 			}
 
-			if record.Reverse != "" {
+			if record.Reverse != "" && !seen[record.Reverse] {
+				seen[record.Reverse] = true
 				results <- subscraping.Result{Source: s.Name(), Type: subscraping.Subdomain, Value: record.Reverse}
 				s.results++
 			}
 		}

---

166-228: Consider extracting repeated parsing logic.

Lines 175-225 repeat identical parsing logic for four numeric fields. Extract this into a helper function to reduce duplication and improve maintainability.

func parseIntField(raw json.RawMessage) int {
	if len(raw) == 0 {
		return 0
	}
	
	// Try parsing as raw number string
	if val, err := strconv.Atoi(string(raw)); err == nil {
		return val
	}
	
	// Try parsing as JSON-quoted string
	var strVal string
	if err := json.Unmarshal(raw, &strVal); err == nil {
		if val, err := strconv.Atoi(strVal); err == nil {
			return val
		}
	}
	
	return 0
}

func (o *OnypheResponse) UnmarshalJSON(data []byte) error {
	var raw OnypheResponseRaw
	if err := json.Unmarshal(data, &raw); err != nil {
		return err
	}

	o.Error = raw.Error
	o.Results = raw.Results
	o.Page = parseIntField(raw.Page)
	o.PageSize = parseIntField(raw.PageSize)
	o.Total = parseIntField(raw.Total)
	o.MaxPage = parseIntField(raw.MaxPage)

	return nil
}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro