Method check

server/src/services/property-check.ts:82–189

(domains: string[])

export class PropertyCheckService {
  async check(domains: string[]): Promise<CheckResult> {
    const remove: CheckResultRemove[] = [];
    const modify: CheckResultModify[] = [];
    const assess: CheckResultAssess[] = [];
    const ok: CheckResultOk[] = [];

    // Step 1: normalize all inputs, track modifications, deduplicate
    const canonicalToFirstInput = new Map<string, string>(); // canonical → first input seen
    const toCheck: string[] = [];

    for (const input of domains) {
      if (!input || typeof input !== 'string') continue;

      const { canonical, reason } = normalizeDomain(input);
      if (!canonical) continue;

      if (canonicalToFirstInput.has(canonical)) {
        remove.push({ input, canonical, reason: 'duplicate' });
        continue;
      }

      canonicalToFirstInput.set(canonical, input);

      if (reason !== null) {
        modify.push({ input, canonical, reason });
      }

      toCheck.push(canonical);
    }

    if (toCheck.length === 0) {
      return {
        summary: { total: domains.length, remove: remove.length, modify: modify.length, assess: 0, ok: 0 },
        remove, modify, assess, ok,
      };
    }

    // Step 2: batch check against domain classifications
    const blocked = await domainClassificationsDb.checkDomains(toCheck);
    const afterBlockedCheck: string[] = [];

    for (const canonical of toCheck) {
      const blockedEntry = blocked.get(canonical);
      if (blockedEntry) {
        remove.push({
          input: canonicalToFirstInput.get(canonical) ?? canonical,
          canonical,
          reason: 'blocked',
          domain_type: blockedEntry.domain_type,
          blocked_reason: blockedEntry.reason ?? undefined,
        });
      } else {
        afterBlockedCheck.push(canonical);
      }
    }

    if (afterBlockedCheck.length === 0) {
      return {