search-domain-validator

What this skill does

# 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

2. **Identify Existing Patterns:**
   - Review validation libraries in use
   - Check for API client patterns
   - Review error handling approaches
   - Check for domain-related utilities

3. **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
// 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:**

```python
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:**

```typescript
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:**

```typescript
// 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:**

```typescript
// 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:**

```typescript
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:**

```typescript
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:**

```typescript
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;
}
```