search-domain-validator（搜索域验证器）

Search Domain Name Validator

Overview

This skill enables validation of domain name formats, checking domain availability status, and searching for available domain names based on keywords. It will implement domain validation logic, integrate with domain availability APIs, and provide domain search functionality.

When to Use This Skill

This skill activates automatically when users:

• Need to validate domain name format or syntax
• Want to check if a domain is available for registration
• Need to search for available domain names based on keywords
• Require domain validation in forms or applications
• Need to verify domain name compliance with RFC standards
• Want to implement domain suggestion features

Project Context Discovery

Before providing domain validation guidance, discover the project's context:

1. Scan Project Documentation:

- Check for existing domain validation logic - Review form validation patterns - Look for API integration patterns - Check for environment variable usage

1. Identify Existing Patterns:

- Review validation libraries in use - Check for API client patterns - Review error handling approaches - Check for domain-related utilities

1. Use Project-Specific Skills:

- Check for [project]-domain-validator skill - Review project-specific validation patterns - Follow project's validation standards

Core Capabilities

1. Domain Format Validation

Validate domain names according to RFC 1035 and RFC 1123 standards.

Domain Name Rules:

• Length: 1-253 characters total
• Labels: Up to 63 characters each
• Characters: Letters (a-z, A-Z), digits (0-9), hyphens (-)
• Labels cannot start or end with hyphens
• TLD (top-level domain) required
• Cannot contain consecutive hyphens

Validation Implementation:

// TypeScript/JavaScript domain validation
function isValidDomain(domain: string): boolean {
  if (!domain || domain.length > 253) {
    return false;
  }

  // RFC 1035 compliant regex
  const domainRegex = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i;

  if (!domainRegex.test(domain)) {
    return false;
  }

  // Check label length (max 63 chars)
  const labels = domain.split('.');
  for (const label of labels) {
    if (label.length > 63 || label.length === 0) {
      return false;
    }
    // Labels cannot start or end with hyphen
    if (label.startsWith('-') || label.endsWith('-')) {
      return false;
    }
  }

  return true;
}

Python Validation:

import re

def is_valid_domain(domain: str) -> bool:
    """Validate domain name format according to RFC 1035 and RFC 1123."""
    if not domain or len(domain) > 253:
        return False

    # RFC 1035 compliant regex
    domain_pattern = r'^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$'

    if not re.match(domain_pattern, domain, re.IGNORECASE):
        return False

    # Check label length (max 63 chars)
    labels = domain.split('.')
    for label in labels:
        if len(label) > 63 or len(label) == 0:
            return False
        # Labels cannot start or end with hyphen
        if label.startswith('-') or label.endswith('-'):
            return False

    return True

NestJS Validation:

import { IsString, Matches, MaxLength, ValidateIf } from 'class-validator';

export class DomainDto {
  @IsString()
  @MaxLength(253)
  @Matches(
    /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i,
    {
      message: 'Invalid domain name format',
    }
  )
  domain: string;
}

2. Domain Availability Checking

Check if a domain is available for registration using domain availability APIs.

Common Domain Availability APIs:

• Namecheap API
• GoDaddy API
• Name.com API
• WHOIS lookups (for basic checks)

Namecheap API Integration:

// Namecheap domain availability check
async function checkDomainAvailability(domain: string): Promise<boolean> {
  const apiUser = process.env.NAMECHEAP_API_USER;
  const apiKey = process.env.NAMECHEAP_API_KEY;
  const clientIp = process.env.NAMECHEAP_CLIENT_IP;

  const url = `https://api.namecheap.com/xml.response?ApiUser=${apiUser}&ApiKey=${apiKey}&UserName=${apiUser}&Command=namecheap.domains.check&ClientIp=${clientIp}&DomainList=${domain}`;

  try {
    const response = await fetch(url);
    const xml = await response.text();

    // Parse XML response
    // Available domains return <DomainCheckResult Domain="example.com" Available="true"/>
    return xml.includes('Available="true"');
  } catch (error) {
    console.error('Error checking domain availability:', error);
    throw error;
  }
}

GoDaddy API Integration:

// GoDaddy domain availability check
async function checkGoDaddyAvailability(domain: string): Promise<boolean> {
  const apiKey = process.env.GODADDY_API_KEY;
  const apiSecret = process.env.GODADDY_API_SECRET;

  const url = `https://api.godaddy.com/v1/domains/available?domain=${domain}`;

  try {
    const response = await fetch(url, {
      headers: {
        'Authorization': `sso-key ${apiKey}:${apiSecret}`,
        'Content-Type': 'application/json',
      },
    });

    const data = await response.json();
    return data.available === true;
  } catch (error) {
    console.error('Error checking domain availability:', error);
    throw error;
  }
}

NestJS Service Example:

import { Injectable } from '@nestjs/common';
import { HttpService } from '@nestjs/axios';
import { firstValueFrom } from 'rxjs';

@Injectable()
export class DomainService {
  constructor(private httpService: HttpService) {}

  async checkAvailability(domain: string): Promise<boolean> {
    const apiKey = process.env.DOMAIN_API_KEY;
    const apiSecret = process.env.DOMAIN_API_SECRET;

    try {
      const response = await firstValueFrom(
        this.httpService.get(`https://api.example.com/domains/check`, {
          params: { domain },
          headers: {
            'Authorization': `Bearer ${apiKey}`,
          },
        })
      );

      return response.data.available;
    } catch (error) {
      throw new Error(`Failed to check domain availability: ${error.message}`);
    }
  }
}

3. Domain Search Functionality

Search for available domain names based on keywords, generating suggestions and alternatives.

Domain Suggestion Algorithm:

function generateDomainSuggestions(keyword: string, tlds: string[] = ['com', 'io', 'net', 'org']): string[] {
  const suggestions: string[] = [];
  const sanitized = keyword.toLowerCase().replace(/[^a-z0-9-]/g, '');

  // Direct combinations
  for (const tld of tlds) {
    suggestions.push(`${sanitized}.${tld}`);
  }

  // Common prefixes
  const prefixes = ['get', 'try', 'use', 'my', 'the'];
  for (const prefix of prefixes) {
    for (const tld of tlds) {
      suggestions.push(`${prefix}${sanitized}.${tld}`);
    }
  }

  // Common suffixes
  const suffixes = ['app', 'hub', 'ly', 'fy', 'io'];
  for (const suffix of suffixes) {
    for (const tld of tlds) {
      suggestions.push(`${sanitized}${suffix}.${tld}`);
    }
  }

  return suggestions;
}

Batch Availability Check:

async function searchAvailableDomains(keyword: string): Promise<string[]> {
  const suggestions = generateDomainSuggestions(keyword);
  const availableDomains: string[] = [];

  // Check availability for all suggestions (with rate limiting)
  for (const domain of suggestions) {
    try {
      const isAvailable = await checkDomainAvailability(domain);
      if (isAvailable) {
        availableDomains.push(domain);
      }
      // Rate limiting delay
      await new Promise(resolve => setTimeout(resolve, 100));
    } catch (error) {
      console.error(`Error checking ${domain}:`, error);
    }
  }

  return availableDomains;
}

Best Practices

Validation

• Always validate domain format before checking availability
• Handle edge cases (internationalized domain names, subdomains)
• Provide clear error messages for invalid domains
• Consider validating TLD separately if needed

API Integration

• Store API credentials in environment variables
• Implement rate limiting to avoid API throttling
• Handle API errors gracefully
• Cache availability results when appropriate
• Use appropriate timeouts for API calls

User Experience

• Provide real-time validation feedback
• Show domain suggestions as user types
• Display availability status clearly
• Offer alternative TLD suggestions
• Handle loading states during availability checks

Security

• Never expose API keys in client-side code
• Validate and sanitize all user input
• Implement proper error handling
• Use HTTPS for all API communications
• Follow API provider's security guidelines

Example User Requests

Example 1: "Validate this domain: example.com"

• Use format validation to check if the domain follows RFC standards
• Return validation result with specific error details if invalid

Example 2: "Check if example.com is available"

• Validate domain format first
• Call domain availability API
• Return availability status

Example 3: "Search for available domains with keyword 'techstartup'"

• Generate domain suggestions based on keyword
• Check availability for each suggestion
• Return list of available domains with pricing if available

Example 4: "Implement domain validation in this form"

• Add domain validation to form component
• Integrate real-time validation
• Provide user feedback for invalid domains

Common Domain TLDs

Generic TLDs:

• .com,.net,.org,.info,.biz

New gTLDs:

• .app,.dev,.io,.ai,.tech,.online,.xyz

Country Code TLDs:

• .us,.uk,.ca,.au,.de,.fr,.jp

When implementing domain search, consider including popular TLDs relevant to the user's context or industry.