From shipshitdev-library
Validates domain names per RFC 1035/1123 standards, checks availability via APIs, and searches available domains by keywords. Provides JS/TS and Python code examples for forms and apps.
npx claudepluginhub shipshitdev/skillsThis skill uses the workspace's default tool permissions.
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.
Provides UI/UX resources: 50+ styles, color palettes, font pairings, guidelines, charts for web/mobile across React, Next.js, Vue, Svelte, Tailwind, React Native, Flutter. Aids planning, building, reviewing interfaces.
Fetches up-to-date documentation from Context7 for libraries and frameworks like React, Next.js, Prisma. Use for setup questions, API references, and code examples.
Analyzes competition with Porter's Five Forces, Blue Ocean Strategy, and positioning maps to identify differentiation opportunities and market positioning for startups and pitches.
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.
This skill activates automatically when users:
Before providing domain validation guidance, discover the project's context:
Scan Project Documentation:
Identify Existing Patterns:
Use Project-Specific Skills:
[project]-domain-validator skillValidate domain names according to RFC 1035 and RFC 1123 standards.
Domain Name Rules:
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;
}
Check if a domain is available for registration using domain availability APIs.
Common Domain Availability APIs:
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}`);
}
}
}
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;
}
Example 1: "Validate this domain: example.com"
Example 2: "Check if example.com is available"
Example 3: "Search for available domains with keyword 'techstartup'"
Example 4: "Implement domain validation in this form"
Generic TLDs:
New gTLDs:
Country Code TLDs:
When implementing domain search, consider including popular TLDs relevant to the user's context or industry.