@stacksjs/whois 0.64.6 → 0.66.0

package/src/index.ts

@@ -1,11 +1,12 @@
+import type { SocksClientOptions } from 'socks'
+import type { ProxyData, WhoIsOptions, WhoIsResponse } from './types'
 import Net from 'node:net'
+import { log } from '@stacksjs/logging'
 import fetch from 'node-fetch'
-import type { SocksClientOptions } from 'socks'
 import { SocksClient } from 'socks'
-import PARAMETERS from './parameters'
-import SERVERS from './servers'
-
-const IANA_CHK_URL = 'https://www.iana.org/whois?q='
+import { IANA_CHK_URL, PARAMETERS, SERVERS } from './constants'
+import { ProxyType } from './types'
+import { shallowCopy } from './utils'
 
 /**
  * Find the WhoIs server for the TLD from IANA WhoIs service. The TLD is be searched and the HTML response is parsed to extract the WhoIs server
@@ -13,43 +14,24 @@ const IANA_CHK_URL = 'https://www.iana.org/whois?q='
  * @param tld TLD of the domain
  * @returns WhoIs server which hosts the information for the domains of the TLD
  */
-async function findWhoIsServer(tld: string): Promise<string> {
+export async function findWhoIsServer(tld: string): Promise<string> {
   const chkURL = IANA_CHK_URL + tld
 
   try {
     const res = await fetch(chkURL)
     if (res.ok) {
       const body = await res.text()
-      const server = body.match(/whois:\s+(.*)\s+/)
-      if (server?.[1]) return server[1]
+      const server = body.match(/whois:\s+(\S+)/)
+      if (server?.[1])
+        return server[1]
     }
-  } catch (err) {
+  }
+  catch (err) {
     console.error('Error in getting WhoIs server data from IANA', err)
   }
 
   return ''
 }
-/**
- * Copy an Object with its values
- *
- * @param obj Object which needs to be copied
- * @returns A copy of the object
- */
-function shallowCopy<T>(obj: T): T {
-  if (Array.isArray(obj)) {
-    return obj.slice() as T // Clone the array
-  }
-
-  if (typeof obj === 'object' && obj !== null) {
-    const copy: any = {}
-    for (const key in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, key)) copy[key] = shallowCopy(obj[key])
-    }
-    return copy as T
-  }
-
-  return obj // For primitive values, return as is
-}
 
 /**
  * Get whois server of the tld from servers list
@@ -57,7 +39,9 @@ function shallowCopy<T>(obj: T): T {
  * @param tld TLD of the domain
  * @returns WhoIs server which hosts the information for the domains of the TLD
  */
-function getWhoIsServer(tld: keyof typeof SERVERS): string | undefined {
+export function getWhoIsServer(tld: keyof typeof SERVERS): string | undefined {
+  if (tld === 'com')
+    return 'whois.verisign-grs.com'
   return SERVERS[tld]
 }
 
@@ -69,134 +53,23 @@ function getWhoIsServer(tld: keyof typeof SERVERS): string | undefined {
  * @param domain Domain name
  * @returns TLD
  */
-function getTLD(domain: string): keyof typeof SERVERS {
-  let tld: keyof typeof SERVERS | null = null
-  let domainStr = domain
-
-  while (true) {
-    const domainData = domainStr.split('.')
-    if (domainData.length < 2) break
-
-    const tldCheck = domainData.slice(1).join('.') as keyof typeof SERVERS
-    const server = SERVERS[tldCheck]
-    if (server) {
-      tld = tldCheck
-      break
+export function getTLD(domain: string): keyof typeof SERVERS {
+  const domainParts = domain.split('.')
+  for (let i = domainParts.length - 1; i > 0; i--) {
+    const possibleTLD = domainParts.slice(i).join('.') as keyof typeof SERVERS
+    if (SERVERS[possibleTLD]) {
+      return possibleTLD
     }
-    domainStr = tldCheck
   }
-
-  if (tld) return tld
-
-  console.debug('TLD is not found in server list. Returning last element after split as TLD!')
-
-  const domainData = domain.split('.')
-  return domainData[domainData.length - 1] as keyof typeof SERVERS
+  // If no match found in SERVERS, return the last part
+  return domainParts[domainParts.length - 1] as keyof typeof SERVERS
 }
 
 // get whois query parameters if exist on parameters.json for whois server
-function getParameters(server: string): string | undefined {
+export function getParameters(server: string): string | undefined {
   return (PARAMETERS as { [key: string]: string })[server]
 }
 
-/**
- * Type of the proxy. Either SOCKS4 or SOCKS5
- * @enum
- */
-export enum ProxyType {
-  /**
-   * SOCKS4 type of proxy
-   */
-  SOCKS4 = 0,
-  /**
-   * SOCKS5 type of proxy
-   */
-  SOCKS5 = 1,
-}
-
-/**
- * Proxy related data
- * @interface
- *
- */
-export interface ProxyData {
-  /**
-   * Proxy IP
-   */
-  ip: string
-  /**
-   * Proxy port
-   */
-  port: number
-  /**
-   * Username to connect to the proxy
-   */
-  username?: string | null
-  /**
-   * Password to connect to the proxy
-   */
-  password?: string | null
-  /**
-   * {@link ProxyType}
-   */
-  type: ProxyType
-}
-
-/**
- * WhoIs options
- * @interface
- */
-export interface WhoIsOptions {
-  /**
-   * TLD of the domain. If the {@link tld} is not provided (or null), then it will be automatically determined as to the given domain name
-   */
-  tld?: string | null
-  /**
-   * The encoding type used for WhoIs server and response. By default UTF-8 is used.
-   */
-  encoding?: string | null
-
-  /** {@link ProxyData} */
-  proxy?: ProxyData | null
-  /**
-   * The WhoIs server to collect data from. If not provided, the server will automatically determined using the {@link tld}
-   */
-  server?: string | null
-  /**
-   * The port of the WhoIs server. By default, port 43 is used.
-   */
-  serverPort?: number | null
-  /**
-   * Which data needs to be extracted/parsed from the WhoIs response.
-   * An object can be passed which contains keys of the fields of the WhoIs response.
-   * A copy of the provided object will be returned with the values filled for the provided keys.
-   *
-   * The keys can have default value of empty string. However, if the WhoIs response has multiple values for the same field (eg: 'Domain Status'),
-   * then all the values can be collected by providing a default value of an Array([]).
-   *
-   * Following example shows an object used to collect 'Domain Name', 'Domain Status' (multiple values) and 'Registrar' from WhoIs response
-   *
-   * @example {'Domain Name': '', 'Domain Status': [], 'Registrar': ''}
-   */
-  parseData?: object | null
-}
-
-/**
- * Response returned from whois function. Contains the raw text from WhoIs server and parsed/fornatted WhoIs data (if parsed is true)
- *
- * @interface
- */
-export interface WhoIsResponse {
-  /**
-   * Raw text response from WhoIs server
-   */
-  _raw: string
-  /**
-   * Parsed/Formatted key-value pairs of the response (if parsed is true)
-   */
-  parsedData: any | null
-}
-
 /**
  * Parse collected raw WhoIs data
  *
@@ -220,22 +93,26 @@ export class WhoIsParser {
       if (letter === '\n' || (lastLetter === ':' && letter === ' ')) {
         if (lastStr.trim() in outputData) {
           lastField = lastStr.trim()
-        } else if (lastField !== null) {
+        }
+        else if (lastField !== null) {
           const x = lastStr.trim()
           if (x !== '') {
             const obj = outputData[lastField]
-            if (Array.isArray(obj)) obj.push(x)
+            if (Array.isArray(obj))
+              obj.push(x)
             else outputData[lastField] = x
 
             lastField = null
           }
         }
         lastStr = ''
-      } else if (letter !== ':') {
+      }
+      else if (letter !== ':') {
         lastStr = lastStr + letter
       }
       lastLetter = letter as string
-      if (lastStr === 'Record maintained by' || lastStr === '>>>') break
+      if (lastStr === 'Record maintained by' || lastStr === '>>>')
+        break
     }
 
     return outputData
@@ -256,7 +133,7 @@ export class WhoIsParser {
         'Updated Date': '',
         'Registry Expiry Date': '',
         'Domain Status': [],
-        Registrar: '',
+        'Registrar': '',
       }
     }
 
@@ -293,7 +170,8 @@ export async function tcpWhois(
     return new Promise((resolve, reject) => {
       try {
         socket.connect({ port, host: server }, () => {
-          if (queryOptions !== '') socket.write(encoder.encode(`${queryOptions} ${domain}\r\n`))
+          if (queryOptions !== '')
+            socket.write(encoder.encode(`${queryOptions} ${domain}\r\n`))
           else socket.write(encoder.encode(`${domain}\r\n`))
         })
 
@@ -304,7 +182,8 @@ export async function tcpWhois(
         socket.on('error', (error) => {
           reject(error)
         })
-      } catch (e) {
+      }
+      catch (e) {
         reject(e)
       }
     })
@@ -334,12 +213,15 @@ export async function tcpWhois(
     SocksClient.createConnection(options, (err, info) => {
       if (err) {
         reject(err)
-      } else {
-        if (!info) reject(new Error('No socket info received!'))
+      }
+      else {
+        if (!info)
+          reject(new Error('No socket info received!'))
 
         if (queryOptions !== '') {
           info?.socket.write(encoder.encode(`${queryOptions} ${domain}\r\n`))
-        } else {
+        }
+        else {
           info?.socket.write(encoder.encode(`${domain}\r\n`))
         }
 
@@ -354,7 +236,7 @@ export async function tcpWhois(
 }
 
 /**
- * Collect WhoIs data for the mentioned {@link domain}. Parse the reveived response if {@link parse} is true, accordingly.
+ * Collect WhoIs data for the mentioned {@link domain}. Parse the received response if {@link parse} is true, accordingly.
  *
  * @param domain Domain name
  * @param parse Whether the raw text needs to be parsed/formatted or not
@@ -375,7 +257,8 @@ export async function whois(
   if (!options) {
     tld = getTLD(domain)
     proxy = null
-  } else {
+  }
+  else {
     tld = options.tld ? options.tld : getTLD(domain)
     encoding = options.encoding ? options.encoding : 'utf-8'
     proxy = options.proxy ? options.proxy : null
@@ -386,16 +269,16 @@ export async function whois(
   if (server === '') {
     let serverData = getWhoIsServer(tld as keyof typeof SERVERS)
     if (!serverData) {
-      console.debug(`No WhoIs server found for TLD: ${tld}! Attempting IANA WhoIs database for server!`)
+      log.debug(`No WhoIs server found for TLD: ${tld}! Attempting IANA WhoIs database for server!`)
       serverData = await findWhoIsServer(tld)
       if (!serverData) {
-        console.debug('WhoIs server could not be found!')
+        log.debug('WhoIs server could not be found!')
         return {
           _raw: '',
           parsedData: null,
         }
       }
-      console.debug(`WhoIs sever found for ${tld}: ${server}`)
+      log.debug(`WhoIs sever found for ${tld}: ${server}`)
     }
 
     server = serverData
@@ -405,7 +288,9 @@ export async function whois(
   const queryOptions = qOptions || ''
 
   try {
+    log.debug(`Attempting WHOIS lookup for ${domain} on server ${server}`)
     const rawData = await tcpWhois(domain, queryOptions, server, port, encoding, proxy)
+    log.debug(`Raw WHOIS data received:`, rawData)
     if (!parse) {
       const parsedData = WhoIsParser.parseData(rawData, null)
       return {
@@ -415,7 +300,8 @@ export async function whois(
     }
 
     let outputData: any | null = null
-    if (options?.parseData) outputData = shallowCopy(options.parseData)
+    if (options?.parseData)
+      outputData = shallowCopy(options.parseData)
 
     try {
       const parsedData = WhoIsParser.parseData(rawData, outputData)
@@ -423,14 +309,17 @@ export async function whois(
         _raw: rawData,
         parsedData,
       }
-    } catch (err) {
+    }
+    catch (err) {
       console.error('Error in parsing WhoIs data!', err)
       return {
         _raw: rawData,
         parsedData: null,
       }
     }
-  } catch (err) {
+  }
+  catch (err: any) {
+    log.debug(`Error in WHOIS lookup for ${domain} on server ${server}`, err)
     return {
       _raw: '',
       parsedData: null,
@@ -439,6 +328,7 @@ export async function whois(
 }
 
 export function lookup(domain: string, options: WhoIsOptions | null = null): Promise<WhoIsResponse> {
+  log.debug(`Lookup called for ${domain}`)
   return whois(domain, true, options)
 }
 
@@ -464,7 +354,8 @@ export async function batchWhois(
   let response: WhoIsResponse[] = []
 
   if (parallel) {
-    if (threads > domains.length) threads = domains.length
+    if (threads > domains.length)
+      threads = domains.length
 
     for (let i = 0; i < domains.length; i += threads) {
       const batch = domains.slice(i, i + threads)
@@ -474,7 +365,8 @@ export async function batchWhois(
         }),
       )
     }
-  } else {
+  }
+  else {
     for (let i = 0; i < domains.length; i++) {
       const res = await whois(domains[i] as string, parse, options)
       response.push(res)
@@ -483,3 +375,9 @@ export async function batchWhois(
 
   return response
 }
+
+export * from './constants'
+export * from './types'
+
+export { SocksClient } from 'socks'
+export type { SocksClientOptions } from 'socks'

package/src/types.ts

@@ -0,0 +1,97 @@
+/**
+ * Response returned from whois function. Contains the raw text from WhoIs server and parsed/fornatted WhoIs data (if parsed is true)
+ *
+ * @interface
+ */
+export interface WhoIsResponse {
+  /**
+   * Raw text response from WhoIs server
+   */
+  _raw: string
+  /**
+   * Parsed/Formatted key-value pairs of the response (if parsed is true)
+   */
+  parsedData: any | null
+}
+
+/**
+ * Type of the proxy. Either SOCKS4 or SOCKS5
+ * @enum
+ */
+export enum ProxyType {
+  /**
+   * SOCKS4 type of proxy
+   */
+  SOCKS4 = 0,
+  /**
+   * SOCKS5 type of proxy
+   */
+  SOCKS5 = 1,
+}
+
+/**
+ * Proxy related data
+ * @interface
+ *
+ */
+export interface ProxyData {
+  /**
+   * Proxy IP
+   */
+  ip: string
+  /**
+   * Proxy port
+   */
+  port: number
+  /**
+   * Username to connect to the proxy
+   */
+  username?: string | null
+  /**
+   * Password to connect to the proxy
+   */
+  password?: string | null
+  /**
+   * {@link ProxyType}
+   */
+  type: ProxyType
+}
+
+/**
+ * WhoIs options
+ * @interface
+ */
+export interface WhoIsOptions {
+  /**
+   * TLD of the domain. If the {@link tld} is not provided (or null), then it will be automatically determined as to the given domain name
+   */
+  tld?: string | null
+  /**
+   * The encoding type used for WhoIs server and response. By default UTF-8 is used.
+   */
+  encoding?: string | null
+
+  /** {@link ProxyData} */
+  proxy?: ProxyData | null
+  /**
+   * The WhoIs server to collect data from. If not provided, the server will automatically determined using the {@link tld}
+   */
+  server?: string | null
+  /**
+   * The port of the WhoIs server. By default, port 43 is used.
+   */
+  serverPort?: number | null
+  /**
+   * Which data needs to be extracted/parsed from the WhoIs response.
+   * An object can be passed which contains keys of the fields of the WhoIs response.
+   * A copy of the provided object will be returned with the values filled for the provided keys.
+   *
+   * The keys can have default value of empty string. However, if the WhoIs response has multiple values for the same field (eg: 'Domain Status'),
+   * then all the values can be collected by providing a default value of an Array([]).
+   *
+   * Following example shows an object used to collect 'Domain Name', 'Domain Status' (multiple values) and 'Registrar' from WhoIs response
+   *
+   * @example {'Domain Name': '', 'Domain Status': [], 'Registrar': ''}
+   */
+  parseData?: object | null
+}

package/src/utils.ts

@@ -0,0 +1,22 @@
+/**
+ * Copy an Object with its values
+ *
+ * @param obj Object which needs to be copied
+ * @returns A copy of the object
+ */
+export function shallowCopy<T>(obj: T): T {
+  if (Array.isArray(obj)) {
+    return obj.slice() as T // Clone the array
+  }
+
+  if (typeof obj === 'object' && obj !== null) {
+    const copy: any = {}
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key))
+        copy[key] = shallowCopy(obj[key])
+    }
+    return copy as T
+  }
+
+  return obj // For primitive values, return as is
+}

package/src/parameters.ts

@@ -1,4 +0,0 @@
-export default {
-  'whois.denic.de': '-T dn,ace',
-  'whois.nic.fr': '-V Md5.2',
-}