domain-search-mcp 1.0.0

package/tests/unit/tools.test.ts

@@ -0,0 +1,200 @@
+/**
+ * Unit Tests for Tools.
+ */
+
+import {
+  searchDomainSchema,
+  bulkSearchSchema,
+  compareRegistrarsSchema,
+  suggestDomainsSchema,
+  tldInfoSchema,
+  checkSocialsSchema,
+} from '../../src/tools';
+
+describe('searchDomainSchema', () => {
+  it('should accept valid input with domain only', () => {
+    const result = searchDomainSchema.parse({
+      domain_name: 'vibecoding',
+    });
+
+    expect(result.domain_name).toBe('vibecoding');
+    expect(result.tlds).toBeUndefined();
+    expect(result.registrars).toBeUndefined();
+  });
+
+  it('should accept valid input with all fields', () => {
+    const result = searchDomainSchema.parse({
+      domain_name: 'vibecoding',
+      tlds: ['com', 'io', 'dev'],
+      registrars: ['porkbun'],
+    });
+
+    expect(result.domain_name).toBe('vibecoding');
+    expect(result.tlds).toEqual(['com', 'io', 'dev']);
+    expect(result.registrars).toEqual(['porkbun']);
+  });
+
+  it('should reject empty domain name', () => {
+    expect(() =>
+      searchDomainSchema.parse({ domain_name: '' }),
+    ).toThrow();
+  });
+
+  it('should reject domain name too long', () => {
+    expect(() =>
+      searchDomainSchema.parse({ domain_name: 'a'.repeat(64) }),
+    ).toThrow();
+  });
+});
+
+describe('bulkSearchSchema', () => {
+  it('should accept valid input', () => {
+    const result = bulkSearchSchema.parse({
+      domains: ['vibecoding', 'myapp', 'coolstartup'],
+      tld: 'com',
+    });
+
+    expect(result.domains).toHaveLength(3);
+    expect(result.tld).toBe('com');
+  });
+
+  it('should use default TLD', () => {
+    const result = bulkSearchSchema.parse({
+      domains: ['vibecoding'],
+    });
+
+    expect(result.tld).toBe('com');
+  });
+
+  it('should reject empty domains array', () => {
+    expect(() =>
+      bulkSearchSchema.parse({ domains: [] }),
+    ).toThrow();
+  });
+
+  it('should reject too many domains', () => {
+    const domains = Array.from({ length: 101 }, (_, i) => `domain${i}`);
+    expect(() =>
+      bulkSearchSchema.parse({ domains }),
+    ).toThrow();
+  });
+});
+
+describe('compareRegistrarsSchema', () => {
+  it('should accept valid input', () => {
+    const result = compareRegistrarsSchema.parse({
+      domain: 'vibecoding',
+      tld: 'com',
+    });
+
+    expect(result.domain).toBe('vibecoding');
+    expect(result.tld).toBe('com');
+  });
+
+  it('should accept specific registrars', () => {
+    const result = compareRegistrarsSchema.parse({
+      domain: 'vibecoding',
+      tld: 'com',
+      registrars: ['porkbun', 'namecheap'],
+    });
+
+    expect(result.registrars).toEqual(['porkbun', 'namecheap']);
+  });
+});
+
+describe('suggestDomainsSchema', () => {
+  it('should accept valid input', () => {
+    const result = suggestDomainsSchema.parse({
+      base_name: 'vibecoding',
+    });
+
+    expect(result.base_name).toBe('vibecoding');
+    expect(result.tld).toBe('com');
+    expect(result.max_suggestions).toBe(10);
+  });
+
+  it('should accept custom options', () => {
+    const result = suggestDomainsSchema.parse({
+      base_name: 'vibecoding',
+      tld: 'io',
+      variants: ['hyphen', 'prefixes'],
+      max_suggestions: 20,
+    });
+
+    expect(result.tld).toBe('io');
+    expect(result.variants).toEqual(['hyphen', 'prefixes']);
+    expect(result.max_suggestions).toBe(20);
+  });
+
+  it('should reject invalid max_suggestions', () => {
+    expect(() =>
+      suggestDomainsSchema.parse({
+        base_name: 'vibecoding',
+        max_suggestions: 100,
+      }),
+    ).toThrow();
+  });
+});
+
+describe('tldInfoSchema', () => {
+  it('should accept valid TLD', () => {
+    const result = tldInfoSchema.parse({
+      tld: 'com',
+    });
+
+    expect(result.tld).toBe('com');
+    expect(result.detailed).toBe(false);
+  });
+
+  it('should accept detailed flag', () => {
+    const result = tldInfoSchema.parse({
+      tld: 'io',
+      detailed: true,
+    });
+
+    expect(result.detailed).toBe(true);
+  });
+
+  it('should reject TLD too short', () => {
+    expect(() =>
+      tldInfoSchema.parse({ tld: 'a' }),
+    ).toThrow();
+  });
+});
+
+describe('checkSocialsSchema', () => {
+  it('should accept valid input', () => {
+    const result = checkSocialsSchema.parse({
+      name: 'vibecoding',
+    });
+
+    expect(result.name).toBe('vibecoding');
+    expect(result.platforms).toBeUndefined();
+  });
+
+  it('should accept specific platforms', () => {
+    const result = checkSocialsSchema.parse({
+      name: 'vibecoding',
+      platforms: ['github', 'twitter'],
+    });
+
+    expect(result.platforms).toEqual(['github', 'twitter']);
+  });
+
+  it('should reject invalid platform', () => {
+    expect(() =>
+      checkSocialsSchema.parse({
+        name: 'vibecoding',
+        platforms: ['invalid'],
+      }),
+    ).toThrow();
+  });
+
+  it('should reject name too long', () => {
+    expect(() =>
+      checkSocialsSchema.parse({
+        name: 'a'.repeat(31),
+      }),
+    ).toThrow();
+  });
+});

package/tests/unit/validators.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Unit Tests for Domain Validators.
+ */
+
+import {
+  validateDomainName,
+  validateTld,
+  validateTlds,
+  parseDomain,
+  isFullDomain,
+  buildDomain,
+} from '../../src/utils/validators';
+import { InvalidDomainError, UnsupportedTldError } from '../../src/utils/errors';
+
+describe('validateDomainName', () => {
+  it('should accept valid domain names', () => {
+    expect(validateDomainName('vibecoding')).toBe('vibecoding');
+    expect(validateDomainName('my-app')).toBe('my-app');
+    expect(validateDomainName('test123')).toBe('test123');
+    expect(validateDomainName('a')).toBe('a');
+  });
+
+  it('should normalize to lowercase', () => {
+    expect(validateDomainName('VibeCoding')).toBe('vibecoding');
+    expect(validateDomainName('MyApp')).toBe('myapp');
+  });
+
+  it('should trim whitespace', () => {
+    expect(validateDomainName('  vibecoding  ')).toBe('vibecoding');
+  });
+
+  it('should reject empty names', () => {
+    expect(() => validateDomainName('')).toThrow(InvalidDomainError);
+    expect(() => validateDomainName('   ')).toThrow(InvalidDomainError);
+  });
+
+  it('should reject names starting with hyphen', () => {
+    expect(() => validateDomainName('-invalid')).toThrow(InvalidDomainError);
+  });
+
+  it('should reject names ending with hyphen', () => {
+    expect(() => validateDomainName('invalid-')).toThrow(InvalidDomainError);
+  });
+
+  it('should reject names with invalid characters', () => {
+    expect(() => validateDomainName('my_app')).toThrow(InvalidDomainError);
+    expect(() => validateDomainName('my.app')).toThrow(InvalidDomainError);
+    expect(() => validateDomainName('my app')).toThrow(InvalidDomainError);
+    expect(() => validateDomainName('my@app')).toThrow(InvalidDomainError);
+  });
+
+  it('should reject names that are too long', () => {
+    const longName = 'a'.repeat(64);
+    expect(() => validateDomainName(longName)).toThrow(InvalidDomainError);
+  });
+
+  it('should accept maximum length names', () => {
+    const maxName = 'a'.repeat(63);
+    expect(validateDomainName(maxName)).toBe(maxName);
+  });
+});
+
+describe('validateTld', () => {
+  it('should accept valid TLDs', () => {
+    expect(validateTld('com')).toBe('com');
+    expect(validateTld('io')).toBe('io');
+    expect(validateTld('dev')).toBe('dev');
+  });
+
+  it('should normalize to lowercase', () => {
+    expect(validateTld('COM')).toBe('com');
+    expect(validateTld('IO')).toBe('io');
+  });
+
+  it('should remove leading dot', () => {
+    expect(validateTld('.com')).toBe('com');
+    expect(validateTld('.io')).toBe('io');
+  });
+
+  it('should reject empty TLDs', () => {
+    expect(() => validateTld('')).toThrow(UnsupportedTldError);
+  });
+
+  it('should reject denied TLDs', () => {
+    expect(() => validateTld('localhost')).toThrow(UnsupportedTldError);
+    expect(() => validateTld('internal')).toThrow(UnsupportedTldError);
+  });
+});
+
+describe('validateTlds', () => {
+  it('should return defaults for empty array', () => {
+    expect(validateTlds([])).toEqual(['com', 'io', 'dev']);
+  });
+
+  it('should validate and normalize array of TLDs', () => {
+    expect(validateTlds(['com', 'IO', '.dev'])).toEqual(['com', 'io', 'dev']);
+  });
+});
+
+describe('parseDomain', () => {
+  it('should parse full domain names', () => {
+    expect(parseDomain('vibecoding.com')).toEqual({
+      name: 'vibecoding',
+      tld: 'com',
+    });
+    expect(parseDomain('my-app.io')).toEqual({
+      name: 'my-app',
+      tld: 'io',
+    });
+  });
+
+  it('should normalize the parsed result', () => {
+    expect(parseDomain('VibeCoding.COM')).toEqual({
+      name: 'vibecoding',
+      tld: 'com',
+    });
+  });
+
+  it('should reject domains without TLD', () => {
+    expect(() => parseDomain('vibecoding')).toThrow(InvalidDomainError);
+  });
+});
+
+describe('isFullDomain', () => {
+  it('should detect full domains', () => {
+    expect(isFullDomain('vibecoding.com')).toBe(true);
+    expect(isFullDomain('my-app.io')).toBe(true);
+  });
+
+  it('should detect partial domains', () => {
+    expect(isFullDomain('vibecoding')).toBe(false);
+    expect(isFullDomain('myapp')).toBe(false);
+  });
+});
+
+describe('buildDomain', () => {
+  it('should build full domain from parts', () => {
+    expect(buildDomain('vibecoding', 'com')).toBe('vibecoding.com');
+    expect(buildDomain('my-app', 'io')).toBe('my-app.io');
+  });
+
+  it('should validate parts during build', () => {
+    expect(() => buildDomain('-invalid', 'com')).toThrow(InvalidDomainError);
+    expect(() => buildDomain('valid', 'localhost')).toThrow(UnsupportedTldError);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "exactOptionalPropertyTypes": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}