660 lines
23 KiB
TypeScript
660 lines
23 KiB
TypeScript
import { domainToASCII } from 'node:url';
|
|
import * as plugins from './smartnetwork.plugins.js';
|
|
import { getLogger } from './logging.js';
|
|
|
|
/** Type alias for a Smartdns client instance */
|
|
type TSmartdnsClient = InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns>;
|
|
/** Type alias for a single DNS record returned by Smartdns */
|
|
type TDnsRecord = Awaited<ReturnType<TSmartdnsClient['getRecordsA']>>[number];
|
|
|
|
/**
|
|
* Unified result from a domain RDAP intelligence lookup.
|
|
*/
|
|
export interface IDomainIntelligenceResult {
|
|
/** Normalized ASCII (punycode) form of the queried domain */
|
|
domain: string | null;
|
|
/** Registry handle / identifier */
|
|
handle: string | null;
|
|
/** EPP status values, e.g. ["active", "client transfer prohibited"] */
|
|
status: string[] | null;
|
|
|
|
// Registration lifecycle (ISO 8601 timestamps from RDAP events)
|
|
registrationDate: string | null;
|
|
expirationDate: string | null;
|
|
lastChangedDate: string | null;
|
|
|
|
// Sponsoring registrar
|
|
registrarName: string | null;
|
|
registrarIanaId: number | null;
|
|
|
|
// Registrant (often redacted under GDPR)
|
|
registrantOrg: string | null;
|
|
registrantCountry: string | null;
|
|
|
|
// Abuse contact (commonly nested under the registrar entity)
|
|
abuseEmail: string | null;
|
|
abusePhone: string | null;
|
|
|
|
// Technical
|
|
nameservers: string[] | null;
|
|
dnssec: boolean | null;
|
|
|
|
/** Which layer populated the nameservers field */
|
|
nameserversSource: 'rdap' | 'dns' | null;
|
|
|
|
// DNS enrichment (from smartdns)
|
|
/** IPv4 A records */
|
|
resolvedIpv4: string[] | null;
|
|
/** IPv6 AAAA records */
|
|
resolvedIpv6: string[] | null;
|
|
/** Parsed MX records with priority and exchange */
|
|
mxRecords: { priority: number | null; exchange: string }[] | null;
|
|
/** TXT records (SPF, DKIM, site verification, etc.) */
|
|
txtRecords: string[] | null;
|
|
/** Raw serialized SOA record value */
|
|
soaRecord: string | null;
|
|
}
|
|
|
|
/**
|
|
* Options for DomainIntelligence
|
|
*/
|
|
export interface IDomainIntelligenceOptions {
|
|
/** Timeout (ms) for RDAP/bootstrap/DNS requests. Default: 5000 */
|
|
timeout?: number;
|
|
/**
|
|
* Optional injected smartdns client. When provided, DomainIntelligence
|
|
* will not create or destroy its own client (the owner — typically
|
|
* SmartNetwork — manages lifecycle). When omitted, a short-lived client
|
|
* is created per DNS-layer query and destroyed in finally.
|
|
*/
|
|
dnsClient?: TSmartdnsClient;
|
|
}
|
|
|
|
// IANA bootstrap for domain RDAP
|
|
const IANA_BOOTSTRAP_DNS_URL = 'https://data.iana.org/rdap/dns.json';
|
|
const DEFAULT_TIMEOUT = 5000;
|
|
|
|
/**
|
|
* Build an empty result object with all fields nulled.
|
|
*/
|
|
function emptyResult(domain: string | null = null): IDomainIntelligenceResult {
|
|
return {
|
|
domain,
|
|
handle: null,
|
|
status: null,
|
|
registrationDate: null,
|
|
expirationDate: null,
|
|
lastChangedDate: null,
|
|
registrarName: null,
|
|
registrarIanaId: null,
|
|
registrantOrg: null,
|
|
registrantCountry: null,
|
|
abuseEmail: null,
|
|
abusePhone: null,
|
|
nameservers: null,
|
|
dnssec: null,
|
|
nameserversSource: null,
|
|
resolvedIpv4: null,
|
|
resolvedIpv6: null,
|
|
mxRecords: null,
|
|
txtRecords: null,
|
|
soaRecord: null,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* DomainIntelligence performs RDAP lookups for domain names using the
|
|
* IANA DNS bootstrap to discover the correct registry RDAP endpoint per TLD.
|
|
*/
|
|
export class DomainIntelligence {
|
|
private readonly logger = getLogger();
|
|
private readonly timeout: number;
|
|
|
|
// Bootstrap cache: tld (lowercased) -> RDAP base URL (without trailing slash)
|
|
private bootstrapEntries: Map<string, string> | null = null;
|
|
private bootstrapPromise: Promise<void> | null = null;
|
|
|
|
// Optional injected smartdns client (shared by SmartNetwork)
|
|
private readonly sharedDnsClient: TSmartdnsClient | null;
|
|
|
|
constructor(options?: IDomainIntelligenceOptions) {
|
|
this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
|
|
this.sharedDnsClient = options?.dnsClient ?? null;
|
|
}
|
|
|
|
/**
|
|
* Get comprehensive domain intelligence. Runs RDAP and DNS lookups in
|
|
* parallel, then merges the results. Returns an all-null result (rather
|
|
* than throwing) for malformed input, unknown TLDs, or total failure.
|
|
*
|
|
* - RDAP provides: registrar, registrant, events (registration/expiration),
|
|
* nameservers (registry/parent), status, DNSSEC, abuse contact
|
|
* - DNS provides: A/AAAA records, MX, TXT, SOA, and a nameservers fallback
|
|
* when RDAP is unavailable (closes the ccTLD gap)
|
|
*/
|
|
public async getIntelligence(domain: string): Promise<IDomainIntelligenceResult> {
|
|
const normalized = this.normalizeDomain(domain);
|
|
if (!normalized) return emptyResult(null);
|
|
|
|
const [rdapSettled, dnsSettled] = await Promise.allSettled([
|
|
this.queryRdapLayer(normalized),
|
|
this.queryDnsLayer(normalized),
|
|
]);
|
|
|
|
const result = emptyResult(normalized);
|
|
|
|
// Merge RDAP fields (if any) — start with the parsed RDAP result as the base
|
|
if (rdapSettled.status === 'fulfilled' && rdapSettled.value) {
|
|
Object.assign(result, rdapSettled.value);
|
|
if (result.nameservers && result.nameservers.length > 0) {
|
|
result.nameserversSource = 'rdap';
|
|
}
|
|
}
|
|
|
|
// Merge DNS fields (if any)
|
|
if (dnsSettled.status === 'fulfilled' && dnsSettled.value) {
|
|
const dns = dnsSettled.value;
|
|
result.resolvedIpv4 = dns.resolvedIpv4;
|
|
result.resolvedIpv6 = dns.resolvedIpv6;
|
|
result.mxRecords = dns.mxRecords;
|
|
result.txtRecords = dns.txtRecords;
|
|
result.soaRecord = dns.soaRecord;
|
|
// Nameserver fallback: only from DNS when RDAP didn't populate it
|
|
if ((!result.nameservers || result.nameservers.length === 0) && dns.nameservers) {
|
|
result.nameservers = dns.nameservers;
|
|
result.nameserversSource = 'dns';
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// ─── RDAP Layer (existing logic, wrapped) ───────────────────────────
|
|
|
|
/**
|
|
* Run the full RDAP lookup flow for a pre-normalized domain: extract TLD,
|
|
* load bootstrap, match registry, query, and parse. Returns the parsed
|
|
* RDAP fields (as a full IDomainIntelligenceResult) or null if any step
|
|
* fails or the TLD has no RDAP support.
|
|
*/
|
|
private async queryRdapLayer(domain: string): Promise<IDomainIntelligenceResult | null> {
|
|
const tld = this.extractTld(domain);
|
|
if (!tld) return null;
|
|
|
|
await this.ensureBootstrap();
|
|
const baseUrl = this.matchTld(tld);
|
|
if (!baseUrl) return null;
|
|
|
|
const rdapData = await this.queryRdap(domain, baseUrl);
|
|
if (!rdapData) return null;
|
|
|
|
return this.parseRdapResponse(domain, rdapData);
|
|
}
|
|
|
|
// ─── Normalization & TLD extraction ─────────────────────────────────
|
|
|
|
/**
|
|
* Normalize a domain to lowercased ASCII punycode form. Returns null for
|
|
* obviously invalid input.
|
|
*/
|
|
private normalizeDomain(input: string): string | null {
|
|
if (typeof input !== 'string') return null;
|
|
let trimmed = input.trim().toLowerCase();
|
|
if (!trimmed) return null;
|
|
// Strip a single trailing dot (FQDN form)
|
|
if (trimmed.endsWith('.')) trimmed = trimmed.slice(0, -1);
|
|
if (!trimmed) return null;
|
|
// Reject inputs that contain whitespace, slashes, or other URL noise
|
|
if (/[\s/\\?#]/.test(trimmed)) return null;
|
|
|
|
// Convert IDN to ASCII (punycode). Returns '' for invalid input.
|
|
const ascii = domainToASCII(trimmed);
|
|
if (!ascii) return null;
|
|
|
|
// Must contain at least one dot to have a TLD
|
|
if (!ascii.includes('.')) return null;
|
|
|
|
return ascii;
|
|
}
|
|
|
|
/**
|
|
* Extract the TLD as the last dot-separated label.
|
|
*/
|
|
private extractTld(domain: string): string | null {
|
|
const idx = domain.lastIndexOf('.');
|
|
if (idx < 0 || idx === domain.length - 1) return null;
|
|
return domain.slice(idx + 1);
|
|
}
|
|
|
|
// ─── Bootstrap Subsystem ────────────────────────────────────────────
|
|
|
|
/**
|
|
* Load and cache the IANA DNS bootstrap file.
|
|
*/
|
|
private async ensureBootstrap(): Promise<void> {
|
|
if (this.bootstrapEntries) return;
|
|
if (this.bootstrapPromise) {
|
|
await this.bootstrapPromise;
|
|
return;
|
|
}
|
|
|
|
this.bootstrapPromise = (async () => {
|
|
try {
|
|
const controller = new AbortController();
|
|
const timeoutId = setTimeout(() => controller.abort(), this.timeout);
|
|
try {
|
|
const response = await fetch(IANA_BOOTSTRAP_DNS_URL, {
|
|
signal: controller.signal,
|
|
headers: { 'User-Agent': '@push.rocks/smartnetwork' },
|
|
});
|
|
if (!response.ok) throw new Error(`HTTP ${response.status}`);
|
|
const data = (await response.json()) as { services: [string[], string[]][] };
|
|
|
|
const entries = new Map<string, string>();
|
|
for (const [tlds, urls] of data.services) {
|
|
const baseUrl = urls[0]; // first URL is preferred
|
|
if (!baseUrl) continue;
|
|
const cleanBase = baseUrl.replace(/\/$/, ''); // strip trailing slash
|
|
for (const tld of tlds) {
|
|
entries.set(tld.toLowerCase(), cleanBase);
|
|
}
|
|
}
|
|
this.bootstrapEntries = entries;
|
|
} finally {
|
|
clearTimeout(timeoutId);
|
|
}
|
|
} catch (err: any) {
|
|
this.logger.debug?.(`Failed to load DNS RDAP bootstrap: ${err.message}`);
|
|
this.bootstrapEntries = new Map(); // empty = all RDAP lookups will skip
|
|
}
|
|
})();
|
|
|
|
await this.bootstrapPromise;
|
|
this.bootstrapPromise = null;
|
|
}
|
|
|
|
/**
|
|
* Find the RDAP base URL for a given TLD via direct lookup.
|
|
*/
|
|
private matchTld(tld: string): string | null {
|
|
if (!this.bootstrapEntries || this.bootstrapEntries.size === 0) return null;
|
|
return this.bootstrapEntries.get(tld.toLowerCase()) ?? null;
|
|
}
|
|
|
|
// ─── RDAP Query ─────────────────────────────────────────────────────
|
|
|
|
/**
|
|
* Perform the RDAP HTTP query for a domain.
|
|
*/
|
|
private async queryRdap(domain: string, baseUrl: string): Promise<any | null> {
|
|
const controller = new AbortController();
|
|
const timeoutId = setTimeout(() => controller.abort(), this.timeout);
|
|
try {
|
|
const response = await fetch(`${baseUrl}/domain/${encodeURIComponent(domain)}`, {
|
|
signal: controller.signal,
|
|
headers: {
|
|
'Accept': 'application/rdap+json',
|
|
'User-Agent': '@push.rocks/smartnetwork',
|
|
},
|
|
});
|
|
if (!response.ok) return null;
|
|
return await response.json();
|
|
} catch (err: any) {
|
|
this.logger.debug?.(`RDAP query failed for ${domain}: ${err.message}`);
|
|
return null;
|
|
} finally {
|
|
clearTimeout(timeoutId);
|
|
}
|
|
}
|
|
|
|
// ─── RDAP Response Parsing ──────────────────────────────────────────
|
|
|
|
private parseRdapResponse(domain: string, data: any): IDomainIntelligenceResult {
|
|
const result = emptyResult(domain);
|
|
|
|
if (typeof data.handle === 'string') result.handle = data.handle;
|
|
|
|
if (Array.isArray(data.status) && data.status.length > 0) {
|
|
result.status = data.status.filter((s: any): s is string => typeof s === 'string');
|
|
}
|
|
|
|
// Events: registration / expiration / last changed
|
|
if (Array.isArray(data.events)) {
|
|
const events = this.extractEvents(data.events);
|
|
result.registrationDate = events.registration;
|
|
result.expirationDate = events.expiration;
|
|
result.lastChangedDate = events.lastChanged;
|
|
}
|
|
|
|
// Registrar (sponsor) and registrant from entities
|
|
if (Array.isArray(data.entities)) {
|
|
const registrar = this.extractRegistrar(data.entities);
|
|
result.registrarName = registrar.name;
|
|
result.registrarIanaId = registrar.ianaId;
|
|
result.abuseEmail = registrar.abuseEmail;
|
|
result.abusePhone = registrar.abusePhone;
|
|
|
|
const registrant = this.extractRegistrant(data.entities);
|
|
result.registrantOrg = registrant.org;
|
|
result.registrantCountry = registrant.country;
|
|
}
|
|
|
|
// Nameservers
|
|
if (Array.isArray(data.nameservers)) {
|
|
result.nameservers = this.extractNameservers(data.nameservers);
|
|
}
|
|
|
|
// DNSSEC: secureDNS.delegationSigned
|
|
if (data.secureDNS && typeof data.secureDNS.delegationSigned === 'boolean') {
|
|
result.dnssec = data.secureDNS.delegationSigned;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Pull registration / expiration / last changed timestamps from an
|
|
* RDAP `events` array.
|
|
*/
|
|
private extractEvents(events: any[]): {
|
|
registration: string | null;
|
|
expiration: string | null;
|
|
lastChanged: string | null;
|
|
} {
|
|
let registration: string | null = null;
|
|
let expiration: string | null = null;
|
|
let lastChanged: string | null = null;
|
|
|
|
for (const ev of events) {
|
|
const action = typeof ev?.eventAction === 'string' ? ev.eventAction.toLowerCase() : '';
|
|
const date = typeof ev?.eventDate === 'string' ? ev.eventDate : null;
|
|
if (!date) continue;
|
|
if (action === 'registration') registration = date;
|
|
else if (action === 'expiration') expiration = date;
|
|
else if (action === 'last changed') lastChanged = date;
|
|
}
|
|
|
|
return { registration, expiration, lastChanged };
|
|
}
|
|
|
|
/**
|
|
* Extract registrar identity (name, IANA ID) and a nested abuse contact.
|
|
*/
|
|
private extractRegistrar(entities: any[]): {
|
|
name: string | null;
|
|
ianaId: number | null;
|
|
abuseEmail: string | null;
|
|
abusePhone: string | null;
|
|
} {
|
|
let name: string | null = null;
|
|
let ianaId: number | null = null;
|
|
let abuseEmail: string | null = null;
|
|
let abusePhone: string | null = null;
|
|
|
|
for (const entity of entities) {
|
|
const roles: string[] = Array.isArray(entity?.roles) ? entity.roles : [];
|
|
if (!roles.includes('registrar')) continue;
|
|
|
|
name = this.extractVcardFn(entity);
|
|
|
|
// IANA Registrar ID lives in publicIds[]
|
|
if (Array.isArray(entity.publicIds)) {
|
|
for (const pid of entity.publicIds) {
|
|
if (pid && typeof pid === 'object' && pid.type === 'IANA Registrar ID') {
|
|
const parsed = parseInt(String(pid.identifier), 10);
|
|
if (!isNaN(parsed)) ianaId = parsed;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Abuse contact: nested entity with role "abuse"
|
|
if (Array.isArray(entity.entities)) {
|
|
for (const sub of entity.entities) {
|
|
const subRoles: string[] = Array.isArray(sub?.roles) ? sub.roles : [];
|
|
if (subRoles.includes('abuse')) {
|
|
if (!abuseEmail) abuseEmail = this.extractVcardEmail(sub);
|
|
if (!abusePhone) abusePhone = this.extractVcardTel(sub);
|
|
}
|
|
}
|
|
}
|
|
|
|
break; // first registrar wins
|
|
}
|
|
|
|
return { name, ianaId, abuseEmail, abusePhone };
|
|
}
|
|
|
|
/**
|
|
* Extract registrant org/country from entities array.
|
|
*/
|
|
private extractRegistrant(entities: any[]): {
|
|
org: string | null;
|
|
country: string | null;
|
|
} {
|
|
for (const entity of entities) {
|
|
const roles: string[] = Array.isArray(entity?.roles) ? entity.roles : [];
|
|
if (!roles.includes('registrant')) continue;
|
|
const org = this.extractVcardFn(entity);
|
|
const country = this.extractVcardCountry(entity);
|
|
return { org, country };
|
|
}
|
|
return { org: null, country: null };
|
|
}
|
|
|
|
/**
|
|
* Map an RDAP nameservers[] array to a list of lowercased ldhName strings.
|
|
*/
|
|
private extractNameservers(nameservers: any[]): string[] | null {
|
|
const out: string[] = [];
|
|
for (const ns of nameservers) {
|
|
const ldh = ns?.ldhName;
|
|
if (typeof ldh === 'string' && ldh.length > 0) {
|
|
out.push(ldh.toLowerCase());
|
|
}
|
|
}
|
|
return out.length > 0 ? out : null;
|
|
}
|
|
|
|
// ─── DNS Layer ──────────────────────────────────────────────────────
|
|
|
|
/**
|
|
* Run DNS record lookups for the given domain using smartdns. Queries
|
|
* NS/A/AAAA/MX/TXT/SOA in parallel via Promise.allSettled — failures in
|
|
* one record type do not affect the others. Returns an object with each
|
|
* field either populated or null.
|
|
*
|
|
* If a shared dnsClient was injected via constructor options, it is
|
|
* reused and NOT destroyed (ownership stays with the injector). Otherwise
|
|
* a short-lived client is created and destroyed in finally.
|
|
*/
|
|
private async queryDnsLayer(domain: string): Promise<{
|
|
nameservers: string[] | null;
|
|
resolvedIpv4: string[] | null;
|
|
resolvedIpv6: string[] | null;
|
|
mxRecords: { priority: number | null; exchange: string }[] | null;
|
|
txtRecords: string[] | null;
|
|
soaRecord: string | null;
|
|
} | null> {
|
|
const external = this.sharedDnsClient !== null;
|
|
let dnsClient: TSmartdnsClient | null = this.sharedDnsClient;
|
|
try {
|
|
if (!dnsClient) {
|
|
dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
|
|
strategy: 'prefer-system',
|
|
allowDohFallback: true,
|
|
timeoutMs: this.timeout,
|
|
});
|
|
}
|
|
|
|
const [nsRes, aRes, aaaaRes, mxRes, txtRes, soaRes] = await Promise.allSettled([
|
|
dnsClient.getNameServers(domain),
|
|
dnsClient.getRecordsA(domain),
|
|
dnsClient.getRecordsAAAA(domain),
|
|
dnsClient.getRecords(domain, 'MX'),
|
|
dnsClient.getRecordsTxt(domain),
|
|
// 'SOA' is in smartdns's runtime dnsTypeMap but missing from the
|
|
// TDnsRecordType union in @tsclass/tsclass — cast to bypass the
|
|
// stale type definition.
|
|
dnsClient.getRecords(domain, 'SOA' as any),
|
|
]);
|
|
|
|
return {
|
|
nameservers: this.parseNsResult(nsRes),
|
|
resolvedIpv4: this.dnsValuesOrNull(aRes),
|
|
resolvedIpv6: this.dnsValuesOrNull(aaaaRes),
|
|
mxRecords: this.parseMxRecords(mxRes),
|
|
txtRecords: this.dnsValuesOrNull(txtRes),
|
|
soaRecord: this.dnsFirstValueOrNull(soaRes),
|
|
};
|
|
} catch (err: any) {
|
|
this.logger.debug?.(`DNS layer failed for ${domain}: ${err.message}`);
|
|
return null;
|
|
} finally {
|
|
// Only destroy clients we created ourselves; leave injected ones alone.
|
|
if (!external && dnsClient) {
|
|
dnsClient.destroy();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extract normalized nameserver hostnames from a getNameServers() result.
|
|
*/
|
|
private parseNsResult(res: PromiseSettledResult<string[]>): string[] | null {
|
|
if (res.status !== 'fulfilled' || !Array.isArray(res.value) || res.value.length === 0) {
|
|
return null;
|
|
}
|
|
const out = res.value
|
|
.map((ns) => (typeof ns === 'string' ? ns.toLowerCase().replace(/\.$/, '') : ''))
|
|
.filter((ns) => ns.length > 0);
|
|
return out.length > 0 ? out : null;
|
|
}
|
|
|
|
/**
|
|
* Extract `value` strings from a settled DNS lookup result.
|
|
*/
|
|
private dnsValuesOrNull(res: PromiseSettledResult<TDnsRecord[]>): string[] | null {
|
|
if (res.status !== 'fulfilled' || !Array.isArray(res.value) || res.value.length === 0) {
|
|
return null;
|
|
}
|
|
const values = res.value
|
|
.map((r) => r.value)
|
|
.filter((v): v is string => typeof v === 'string' && v.length > 0);
|
|
return values.length > 0 ? values : null;
|
|
}
|
|
|
|
/**
|
|
* First non-empty value from a settled DNS lookup result.
|
|
*/
|
|
private dnsFirstValueOrNull(res: PromiseSettledResult<TDnsRecord[]>): string | null {
|
|
const values = this.dnsValuesOrNull(res);
|
|
return values?.[0] ?? null;
|
|
}
|
|
|
|
/**
|
|
* Parse MX records into {priority, exchange} pairs. smartdns returns MX
|
|
* values as serialized strings (typically "10 mail.example.com"). We
|
|
* best-effort parse the priority; if parsing fails we store the whole
|
|
* value as the exchange with priority=null so the result is still useful.
|
|
*/
|
|
private parseMxRecords(
|
|
res: PromiseSettledResult<TDnsRecord[]>,
|
|
): { priority: number | null; exchange: string }[] | null {
|
|
if (res.status !== 'fulfilled' || !Array.isArray(res.value) || res.value.length === 0) {
|
|
return null;
|
|
}
|
|
const out: { priority: number | null; exchange: string }[] = [];
|
|
for (const r of res.value) {
|
|
if (typeof r.value !== 'string' || !r.value.trim()) continue;
|
|
const match = r.value.trim().match(/^(\d+)\s+(.+?)\.?$/);
|
|
if (match) {
|
|
out.push({ priority: parseInt(match[1], 10), exchange: match[2].toLowerCase() });
|
|
} else {
|
|
out.push({ priority: null, exchange: r.value.toLowerCase().replace(/\.$/, '') });
|
|
}
|
|
}
|
|
return out.length > 0 ? out : null;
|
|
}
|
|
|
|
// ─── vCard helpers (duplicated from IpIntelligence) ─────────────────
|
|
|
|
/**
|
|
* Extract the 'fn' (formatted name) from an entity's vcardArray
|
|
*/
|
|
private extractVcardFn(entity: any): string | null {
|
|
if (!entity?.vcardArray || !Array.isArray(entity.vcardArray)) return null;
|
|
const properties = entity.vcardArray[1];
|
|
if (!Array.isArray(properties)) return null;
|
|
|
|
for (const prop of properties) {
|
|
if (Array.isArray(prop) && prop[0] === 'fn') {
|
|
return prop[3] || null;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Extract email from an entity's vcardArray
|
|
*/
|
|
private extractVcardEmail(entity: any): string | null {
|
|
if (!entity?.vcardArray || !Array.isArray(entity.vcardArray)) return null;
|
|
const properties = entity.vcardArray[1];
|
|
if (!Array.isArray(properties)) return null;
|
|
|
|
for (const prop of properties) {
|
|
if (Array.isArray(prop) && prop[0] === 'email') {
|
|
return prop[3] || null;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Extract telephone number from an entity's vcardArray
|
|
*/
|
|
private extractVcardTel(entity: any): string | null {
|
|
if (!entity?.vcardArray || !Array.isArray(entity.vcardArray)) return null;
|
|
const properties = entity.vcardArray[1];
|
|
if (!Array.isArray(properties)) return null;
|
|
|
|
for (const prop of properties) {
|
|
if (Array.isArray(prop) && prop[0] === 'tel') {
|
|
// tel value can be a string or a uri like "tel:+1.5555555555"
|
|
const value = prop[3];
|
|
if (typeof value === 'string') {
|
|
return value.startsWith('tel:') ? value.slice(4) : value;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Extract country from an entity's vcardArray address field
|
|
*/
|
|
private extractVcardCountry(entity: any): string | null {
|
|
if (!entity?.vcardArray || !Array.isArray(entity.vcardArray)) return null;
|
|
const properties = entity.vcardArray[1];
|
|
if (!Array.isArray(properties)) return null;
|
|
|
|
for (const prop of properties) {
|
|
if (Array.isArray(prop) && prop[0] === 'adr') {
|
|
// The label parameter often contains the full address with country at the end
|
|
const label = prop[1]?.label;
|
|
if (typeof label === 'string') {
|
|
const lines = label.split('\n');
|
|
const lastLine = lines[lines.length - 1]?.trim();
|
|
if (lastLine && lastLine.length > 1) return lastLine;
|
|
}
|
|
// Also check the structured value (7-element array, last element is country)
|
|
const value = prop[3];
|
|
if (Array.isArray(value) && value.length >= 7 && value[6]) {
|
|
return value[6];
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|