Add domain only tests

pkg/analyzer/analyzer.go

@@ -108,3 +108,14 @@ func (a *APIAdapter) AnalyzeEmailBytes(rawEmail []byte, testID uuid.UUID) ([]byt
 
 	return reportJSON, nil
 }
+
+// AnalyzeDomain performs DNS analysis for a domain and returns the results
+func (a *APIAdapter) AnalyzeDomain(domain string) (*api.DNSResults, int, string) {
+	// Perform DNS analysis
+	dnsResults := a.analyzer.generator.dnsAnalyzer.AnalyzeDomainOnly(domain)
+
+	// Calculate score
+	score, grade := a.analyzer.generator.dnsAnalyzer.CalculateDomainOnlyScore(dnsResults)
+
+	return dnsResults, score, grade
+}

pkg/analyzer/dns.go

@@ -124,6 +124,70 @@ func (d *DNSAnalyzer) AnalyzeDNS(email *EmailMessage, authResults *api.Authentic
 	return results
 }
 
+// AnalyzeDomainOnly performs DNS validation for a domain without email context
+// This is useful for checking domain configuration without sending an actual email
+func (d *DNSAnalyzer) AnalyzeDomainOnly(domain string) *api.DNSResults {
+	results := &api.DNSResults{
+		FromDomain: domain,
+	}
+
+	// Check MX records
+	results.FromMxRecords = d.checkMXRecords(domain)
+
+	// Check SPF records
+	results.SpfRecords = d.checkSPFRecords(domain)
+
+	// Check DMARC record
+	results.DmarcRecord = d.checkDMARCRecord(domain)
+
+	// Check BIMI record with default selector
+	results.BimiRecord = d.checkBIMIRecord(domain, "default")
+
+	return results
+}
+
+// CalculateDomainOnlyScore calculates the DNS score for domain-only tests
+// Returns a score from 0-100 where higher is better
+// This version excludes PTR and DKIM checks since they require email context
+func (d *DNSAnalyzer) CalculateDomainOnlyScore(results *api.DNSResults) (int, string) {
+	if results == nil {
+		return 0, ""
+	}
+
+	score := 0
+
+	// MX Records: 30 points (only one domain to check)
+	mxScore := d.calculateMXScore(results)
+	// Since calculateMXScore checks both From and RP domains,
+	// and we only have From domain, we use the full score
+	score += 30 * mxScore / 100
+
+	// SPF Records: 30 points
+	score += 30 * d.calculateSPFScore(results) / 100
+
+	// DMARC Record: 40 points
+	score += 40 * d.calculateDMARCScore(results) / 100
+
+	// BIMI Record: only bonus
+	if results.BimiRecord != nil && results.BimiRecord.Valid {
+		if score >= 100 {
+			return 100, "A+"
+		}
+	}
+
+	// Ensure score doesn't exceed maximum
+	if score > 100 {
+		score = 100
+	}
+
+	// Ensure score is non-negative
+	if score < 0 {
+		score = 0
+	}
+
+	return score, ScoreToGradeKind(score)
+}
+
 // CalculateDNSScore calculates the DNS score from records results
 // Returns a score from 0-100 where higher is better
 // senderIP is the original sender IP address used for FCrDNS verification

pkg/analyzer/scoring.go

@@ -45,6 +45,26 @@ func ScoreToGrade(score int) string {
 	}
 }
 
+// ScoreToGradeKind converts a percentage score (0-100) to a letter grade, be kind in gradation
+func ScoreToGradeKind(score int) string {
+	switch {
+	case score > 100:
+		return "A+"
+	case score >= 90:
+		return "A"
+	case score >= 80:
+		return "B"
+	case score >= 60:
+		return "C"
+	case score >= 45:
+		return "D"
+	case score >= 30:
+		return "E"
+	default:
+		return "F"
+	}
+}
+
 // ScoreToReportGrade converts a percentage score to an api.ReportGrade
 func ScoreToReportGrade(score int) api.ReportGrade {
 	return api.ReportGrade(ScoreToGrade(score))