search-domain-validator

仓库: shipshitdev/library
安装量: 73
排名: #10620

安装

npx skills add https://github.com/shipshitdev/library --skill search-domain-validator

Search Domain Name Validator Overview

This skill enables Claude to validate domain name formats, check domain availability status, and search for available domain names based on keywords. Claude will use this skill to 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:

Scan Project Documentation:

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

Identify Existing Patterns:

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

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?$/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?$/i, { message: 'Invalid domain name format', } ) domain: string; }

  1. 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 { 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 { 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 { 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}`);
}

} }

  1. 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 { 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.

← 返回排行榜