@bytebrand/export-cars 1.26.27 → 1.26.29

package/src/services/feed-guard.ts

@@ -0,0 +1,219 @@
+import { promises as fs } from 'fs';
+import { basename, dirname, join } from 'path';
+
+/**
+ * Shared fail-closed guard for partner feed exporters (ADV-335). Opt-in per exporter; today only
+ * the OpenAI exporter uses it. Built for the 24.09 failure: base export wiped resources/cars-export,
+ * failed on the CBD outage, and every downstream feed was published empty.
+ *
+ * - checkSource: before any output is touched — the base export snapshot must exist, be complete
+ *   (chunk files cars.0..n-1 without gaps) and be fresh enough.
+ * - checkCounts: after the new file was written to a temp path — source and published counts must
+ *   not be below an absolute minimum or drop by more than maxDropPercent against the last good run.
+ *   A real stock drop is accepted by re-running once with acceptDrop.
+ * - publish: temp file -> final path by rename (same directory, atomic), previous file kept as
+ *   `<name>.prev`, last good counts written to the state dir. A blocked run leaves the last good
+ *   file in place, so the partner keeps reading it; how long that is acceptable is maxStaleHours.
+ * - lock: one run per state dir.
+ */
+export interface FeedGuardOptions {
+  // state dir of this feed (last-good.json, lock); one per export type and mode
+  stateDir: string;
+  // fail when the source snapshot has fewer cars than this
+  minSourceItems: number;
+  // fail when the published in_stock count is below this
+  minPublishedItems: number;
+  // fail when source or published count is more than this % below the last good run
+  maxDropPercent: number;
+  // fail when the newest base export chunk is older than this
+  maxSourceAgeHours: number;
+  // the last good file is reported STALE after this many hours without a successful run
+  maxStaleHours: number;
+  // one-off override for a real stock drop (Cronicle param); does not override the minimums
+  acceptDrop: boolean;
+  // a lock file older than this is treated as left over by a crashed run
+  lockStaleHours?: number;
+}
+
+export interface SourceSnapshot {
+  files: number;
+  missingChunks: number[];
+  newestMtime: Date | null;
+  oldestMtime: Date | null;
+}
+
+export interface FeedCounts {
+  sourceItems: number;
+  publishedItems: number;
+}
+
+export interface LastGood extends FeedCounts {
+  publishedAt: string;
+  file: string;
+  runId?: string;
+}
+
+export class FeedGuardError extends Error {
+  constructor(readonly code: string, message: string) {
+    super(`[feed-guard:${code}] ${message}`);
+  }
+}
+
+const HOUR_MS = 60 * 60 * 1000;
+
+// Reads the base export snapshot: `<baseFileName>.<n>.json` chunk files (FsCarsLoader order).
+export const inspectSourceSnapshot = async (directory: string, baseFileName: string): Promise<SourceSnapshot> => {
+  let names: string[];
+  try {
+    names = await fs.readdir(directory);
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return { files: 0, missingChunks: [], newestMtime: null, oldestMtime: null };
+    }
+    throw error;
+  }
+  const pattern = new RegExp(`^${baseFileName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.(\\d+)\\.json$`);
+  const chunks = names.map(name => ({ name, match: pattern.exec(name) })).filter(entry => entry.match);
+  const ids = new Set(chunks.map(entry => Number(entry.match[1])));
+  const maxId = ids.size ? Math.max(...ids) : -1;
+  const missingChunks: number[] = [];
+  for (let id = 0; id <= maxId; id += 1) {
+    if (!ids.has(id)) {
+      missingChunks.push(id);
+    }
+  }
+  let newest: number = null;
+  let oldest: number = null;
+  for (const { name } of chunks) {
+    const { mtimeMs } = await fs.stat(join(directory, name));
+    newest = newest === null ? mtimeMs : Math.max(newest, mtimeMs);
+    oldest = oldest === null ? mtimeMs : Math.min(oldest, mtimeMs);
+  }
+  return {
+    files: chunks.length,
+    missingChunks,
+    newestMtime: newest === null ? null : new Date(newest),
+    oldestMtime: oldest === null ? null : new Date(oldest),
+  };
+};
+
+const dropPercent = (current: number, previous: number): number =>
+  previous > 0 ? ((previous - current) / previous) * 100 : 0;
+
+export class FeedGuard {
+  private lockFile: string;
+
+  constructor(private readonly options: FeedGuardOptions) { }
+
+  private get lastGoodFile(): string {
+    return join(this.options.stateDir, 'last-good.json');
+  }
+
+  async readLastGood(): Promise<LastGood | null> {
+    try {
+      return JSON.parse(await fs.readFile(this.lastGoodFile, 'utf8')) as LastGood;
+    } catch (error) {
+      if (error?.code === 'ENOENT') {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  async acquireLock(runId: string, now: Date): Promise<void> {
+    await fs.mkdir(this.options.stateDir, { recursive: true });
+    const lockFile = join(this.options.stateDir, 'run.lock');
+    const staleMs = (this.options.lockStaleHours ?? 6) * HOUR_MS;
+    try {
+      await fs.writeFile(lockFile, JSON.stringify({ runId, startedAt: now.toISOString() }), { flag: 'wx' });
+    } catch (error) {
+      if (error?.code !== 'EEXIST') {
+        throw error;
+      }
+      const { mtimeMs } = await fs.stat(lockFile);
+      if (now.getTime() - mtimeMs < staleMs) {
+        throw new FeedGuardError('locked', `another run holds ${lockFile} (since ${new Date(mtimeMs).toISOString()})`);
+      }
+      console.log(`feed-guard: removing stale lock ${lockFile} (${new Date(mtimeMs).toISOString()})`);
+      await fs.writeFile(lockFile, JSON.stringify({ runId, startedAt: now.toISOString() }));
+    }
+    this.lockFile = lockFile;
+  }
+
+  async releaseLock(): Promise<void> {
+    if (this.lockFile) {
+      await fs.rm(this.lockFile, { force: true });
+      this.lockFile = null;
+    }
+  }
+
+  checkSource(snapshot: SourceSnapshot, now: Date): void {
+    if (!snapshot.files) {
+      throw new FeedGuardError('source_empty', 'base export snapshot has no chunk files');
+    }
+    if (snapshot.missingChunks.length) {
+      throw new FeedGuardError('source_partial', `base export snapshot misses chunk(s) ${snapshot.missingChunks.slice(0, 10).join(', ')}`);
+    }
+    const ageHours = (now.getTime() - snapshot.newestMtime.getTime()) / HOUR_MS;
+    if (ageHours > this.options.maxSourceAgeHours) {
+      throw new FeedGuardError(
+        'source_stale',
+        `newest base export chunk is ${ageHours.toFixed(1)} h old (max ${this.options.maxSourceAgeHours} h)`,
+      );
+    }
+  }
+
+  checkCounts(counts: FeedCounts, lastGood: LastGood | null): void {
+    if (counts.sourceItems < this.options.minSourceItems) {
+      throw new FeedGuardError('source_too_small', `${counts.sourceItems} source cars < minimum ${this.options.minSourceItems}`);
+    }
+    if (counts.publishedItems < this.options.minPublishedItems) {
+      throw new FeedGuardError(
+        'published_too_small',
+        `${counts.publishedItems} in_stock items < minimum ${this.options.minPublishedItems}`,
+      );
+    }
+    if (!lastGood || this.options.acceptDrop) {
+      return;
+    }
+    const sourceDrop = dropPercent(counts.sourceItems, lastGood.sourceItems);
+    const publishedDrop = dropPercent(counts.publishedItems, lastGood.publishedItems);
+    if (sourceDrop > this.options.maxDropPercent || publishedDrop > this.options.maxDropPercent) {
+      throw new FeedGuardError(
+        'count_drop',
+        `source ${lastGood.sourceItems} -> ${counts.sourceItems} (-${sourceDrop.toFixed(1)}%), ` +
+        `in_stock ${lastGood.publishedItems} -> ${counts.publishedItems} (-${publishedDrop.toFixed(1)}%), ` +
+        `max ${this.options.maxDropPercent}% — re-run with acceptDrop if the stock really dropped`,
+      );
+    }
+  }
+
+  staleHours(lastGood: LastGood | null, now: Date): number | null {
+    return lastGood ? (now.getTime() - Date.parse(lastGood.publishedAt)) / HOUR_MS : null;
+  }
+
+  isStale(lastGood: LastGood | null, now: Date): boolean {
+    const hours = this.staleHours(lastGood, now);
+    return hours !== null && hours > this.options.maxStaleHours;
+  }
+
+  // tmpFile must sit next to finalFile so the rename stays on one filesystem (atomic).
+  async publish(tmpFile: string, finalFile: string, counts: FeedCounts, now: Date, runId?: string): Promise<LastGood> {
+    if (dirname(tmpFile) !== dirname(finalFile)) {
+      throw new Error(`feed-guard: ${basename(tmpFile)} must be in the directory of ${finalFile}`);
+    }
+    try {
+      await fs.copyFile(finalFile, `${finalFile}.prev`);
+    } catch (error) {
+      if (error?.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+    await fs.rename(tmpFile, finalFile);
+    const lastGood: LastGood = { ...counts, publishedAt: now.toISOString(), file: finalFile, runId };
+    await fs.mkdir(this.options.stateDir, { recursive: true });
+    await fs.writeFile(`${this.lastGoodFile}.tmp`, JSON.stringify(lastGood, null, 2), 'utf8');
+    await fs.rename(`${this.lastGoodFile}.tmp`, this.lastGoodFile);
+    return lastGood;
+  }
+}

package/src/services/feed-items-bigquery.writer.ts

@@ -1,101 +1,101 @@
-import { join } from 'path';
-import { BigQueryLogger } from '@bytebrand/bigquery-logger';
-import { FeedItemsBigQueryTarget } from '../interfaces/params.interface';
-import { FeedItemRow } from '../transformers/google-feed-item-row';
-
-const BATCH_SIZE = 500;
-// After this many failed batches the writer gives up for the run (missing table, bad credentials).
-const MAX_FAILED_BATCHES = 3;
-const CLOSE_TIMEOUT_MS = 60000;
-
-class FeedItemsBigQueryLogger extends BigQueryLogger {
-  async insertRows(rows: FeedItemRow[]): Promise<void> {
-    await this.client
-      .dataset(this.options.BigQueryDataset)
-      .table(this.options.BigQueryLogTable)
-      .insert(rows, { skipInvalidRows: true, ignoreUnknownValues: true });
-  }
-}
-
-// Audit trail of the feed items: rows are buffered and inserted in batches of 500 in the background,
-// one batch at a time. Errors are logged and swallowed — the feed export must never fail because of
-// BigQuery.
-export class FeedItemsBigQueryWriter {
-  private logger: FeedItemsBigQueryLogger;
-  private buffer: FeedItemRow[] = [];
-  private queue: Promise<void> = Promise.resolve();
-  private failedBatches = 0;
-  private insertedRows = 0;
-
-  constructor(private target: FeedItemsBigQueryTarget) {
-    try {
-      const credentials = require(join(process.cwd(), 'credentials/google-cloud-project-id.json'));
-      this.logger = new FeedItemsBigQueryLogger(credentials, {
-        BigQueryProject: target.project,
-        BigQueryDataset: target.dataset,
-        BigQueryLogTable: target.table,
-      });
-    } catch (e) {
-      // First line only: a missing credentials file comes with the whole require stack.
-      console.log(`Feed items BigQuery disabled: ${String(e?.message || e).split('\n')[0]}`);
-    }
-  }
-
-  add(row: FeedItemRow): void {
-    if (!this.enabled) return;
-    this.buffer.push(row);
-    if (this.buffer.length >= BATCH_SIZE) this.flush();
-  }
-
-  // Waits for the pending batches, but never longer than CLOSE_TIMEOUT_MS: a hanging BigQuery
-  // must not hold up the feed export (the XML is already written at this point).
-  async close(): Promise<void> {
-    this.flush();
-    let timer: NodeJS.Timeout | undefined;
-    const timeout = new Promise<'timeout'>((resolve) => {
-      timer = setTimeout(() => resolve('timeout'), CLOSE_TIMEOUT_MS);
-    });
-    const outcome = await Promise.race([this.queue.then(() => 'done' as const), timeout]);
-    if (timer) clearTimeout(timer);
-    if (outcome === 'timeout') console.error(`Feed items BigQuery: gave up waiting after ${CLOSE_TIMEOUT_MS} ms`);
-    if (this.logger) {
-      console.log(`Feed items BigQuery: ${this.insertedRows} rows to ${this.tableName}, ${this.failedBatches} failed batches`);
-    }
-  }
-
-  private get enabled(): boolean {
-    return !!this.logger && this.failedBatches < MAX_FAILED_BATCHES;
-  }
-
-  private get tableName(): string {
-    return `${this.target.project}.${this.target.dataset}.${this.target.table}`;
-  }
-
-  private flush(): void {
-    if (!this.buffer.length) return;
-    const rows = this.buffer;
-    this.buffer = [];
-    this.queue = this.queue.then(() => this.insert(rows));
-  }
-
-  private async insert(rows: FeedItemRow[]): Promise<void> {
-    if (!this.enabled) return;
-    try {
-      await this.logger.insertRows(rows);
-      this.insertedRows += rows.length;
-    } catch (e) {
-      // PartialFailureError: the valid rows went in (skipInvalidRows), `errors` lists the rejected
-      // ones; the first is enough to see the cause.
-      const rejected: any[] = e?.name === 'PartialFailureError' && Array.isArray(e.errors) ? e.errors : null;
-      const firstRowError = rejected?.[0]?.errors?.[0];
-      const detail = firstRowError ? ` (${firstRowError.reason}: ${firstRowError.message})` : '';
-      if (rejected) {
-        this.insertedRows += rows.length - rejected.length;
-        console.log(`Feed items BigQuery rejected ${rejected.length} of ${rows.length} rows${detail}`);
-      } else {
-        this.failedBatches++;
-        console.log(`Feed items BigQuery insert of ${rows.length} rows failed: ${e?.message || e}`);
-      }
-    }
-  }
-}
+import { join } from 'path';
+import { BigQueryLogger } from '@bytebrand/bigquery-logger';
+import { FeedItemsBigQueryTarget } from '../interfaces/params.interface';
+import { FeedItemRow } from '../transformers/google-feed-item-row';
+
+const BATCH_SIZE = 500;
+// After this many failed batches the writer gives up for the run (missing table, bad credentials).
+const MAX_FAILED_BATCHES = 3;
+const CLOSE_TIMEOUT_MS = 60000;
+
+class FeedItemsBigQueryLogger extends BigQueryLogger {
+  async insertRows(rows: FeedItemRow[]): Promise<void> {
+    await this.client
+      .dataset(this.options.BigQueryDataset)
+      .table(this.options.BigQueryLogTable)
+      .insert(rows, { skipInvalidRows: true, ignoreUnknownValues: true });
+  }
+}
+
+// Audit trail of the feed items: rows are buffered and inserted in batches of 500 in the background,
+// one batch at a time. Errors are logged and swallowed — the feed export must never fail because of
+// BigQuery.
+export class FeedItemsBigQueryWriter {
+  private logger: FeedItemsBigQueryLogger;
+  private buffer: FeedItemRow[] = [];
+  private queue: Promise<void> = Promise.resolve();
+  private failedBatches = 0;
+  private insertedRows = 0;
+
+  constructor(private target: FeedItemsBigQueryTarget) {
+    try {
+      const credentials = require(join(process.cwd(), 'credentials/google-cloud-project-id.json'));
+      this.logger = new FeedItemsBigQueryLogger(credentials, {
+        BigQueryProject: target.project,
+        BigQueryDataset: target.dataset,
+        BigQueryLogTable: target.table,
+      });
+    } catch (e) {
+      // First line only: a missing credentials file comes with the whole require stack.
+      console.log(`Feed items BigQuery disabled: ${String(e?.message || e).split('\n')[0]}`);
+    }
+  }
+
+  add(row: FeedItemRow): void {
+    if (!this.enabled) return;
+    this.buffer.push(row);
+    if (this.buffer.length >= BATCH_SIZE) this.flush();
+  }
+
+  // Waits for the pending batches, but never longer than CLOSE_TIMEOUT_MS: a hanging BigQuery
+  // must not hold up the feed export (the XML is already written at this point).
+  async close(): Promise<void> {
+    this.flush();
+    let timer: NodeJS.Timeout | undefined;
+    const timeout = new Promise<'timeout'>((resolve) => {
+      timer = setTimeout(() => resolve('timeout'), CLOSE_TIMEOUT_MS);
+    });
+    const outcome = await Promise.race([this.queue.then(() => 'done' as const), timeout]);
+    if (timer) clearTimeout(timer);
+    if (outcome === 'timeout') console.error(`Feed items BigQuery: gave up waiting after ${CLOSE_TIMEOUT_MS} ms`);
+    if (this.logger) {
+      console.log(`Feed items BigQuery: ${this.insertedRows} rows to ${this.tableName}, ${this.failedBatches} failed batches`);
+    }
+  }
+
+  private get enabled(): boolean {
+    return !!this.logger && this.failedBatches < MAX_FAILED_BATCHES;
+  }
+
+  private get tableName(): string {
+    return `${this.target.project}.${this.target.dataset}.${this.target.table}`;
+  }
+
+  private flush(): void {
+    if (!this.buffer.length) return;
+    const rows = this.buffer;
+    this.buffer = [];
+    this.queue = this.queue.then(() => this.insert(rows));
+  }
+
+  private async insert(rows: FeedItemRow[]): Promise<void> {
+    if (!this.enabled) return;
+    try {
+      await this.logger.insertRows(rows);
+      this.insertedRows += rows.length;
+    } catch (e) {
+      // PartialFailureError: the valid rows went in (skipInvalidRows), `errors` lists the rejected
+      // ones; the first is enough to see the cause.
+      const rejected: any[] = e?.name === 'PartialFailureError' && Array.isArray(e.errors) ? e.errors : null;
+      const firstRowError = rejected?.[0]?.errors?.[0];
+      const detail = firstRowError ? ` (${firstRowError.reason}: ${firstRowError.message})` : '';
+      if (rejected) {
+        this.insertedRows += rows.length - rejected.length;
+        console.log(`Feed items BigQuery rejected ${rejected.length} of ${rows.length} rows${detail}`);
+      } else {
+        this.failedBatches++;
+        console.log(`Feed items BigQuery insert of ${rows.length} rows failed: ${e?.message || e}`);
+      }
+    }
+  }
+}

package/src/services/image-url-validator.service.ts

@@ -0,0 +1,181 @@
+import axios, { AxiosResponse } from 'axios';
+import Bottleneck from 'bottleneck';
+
+export enum ImageUrlRejectReason {
+  invalidUrl = 'invalid_url',
+  notHttps = 'not_https',
+  credentials = 'credentials_in_url',
+  placeholder = 'placeholder',
+  httpStatus = 'http_status',
+  wrongMime = 'wrong_mime',
+  tooManyRedirects = 'too_many_redirects',
+  timeout = 'timeout',
+  networkError = 'network_error',
+  budgetExhausted = 'budget_exhausted',
+}
+
+export interface ImageUrlCheck {
+  url: string;
+  ok: boolean;
+  reason?: ImageUrlRejectReason;
+  status?: number;
+  contentType?: string;
+  finalUrl?: string;
+}
+
+export interface ImageUrlValidatorOptions {
+  // MIME types a partner is known to accept. OpenAI documents JPEG/PNG only as examples, so WebP
+  // (which our CDN negotiates for browsers) is rejected unless a partner explicitly allows it.
+  allowedMimeTypes?: string[];
+  requireHttps?: boolean;
+  timeoutMs?: number;
+  maxRedirects?: number;
+  concurrency?: number;
+  // Upper bound of HTTP probes per validator instance (one export run). Unlimited by default.
+  maxProbes?: number;
+  // e.g. the partner crawler's UA, to see what the crawler would get
+  userAgent?: string;
+}
+
+// auto.de "no image" assets (ImagesService.DEFAULT_IMAGES) — never a valid vehicle photo, and
+// images.auto.de answers them with 404 + an image/jpeg body anyway.
+const PLACEHOLDER_PATTERN = /\/carimage\/noimage\//i;
+
+/**
+ * Budgeted, cached HTTP check of image URLs before they go into a partner feed (ADV-336).
+ * HEAD first, GET (body discarded) when HEAD is not supported. A URL is valid only with a final
+ * 200 and an allowed image MIME type — images.auto.de answers unknown images with 404 AND an
+ * image/jpeg placeholder body, so the Content-Type alone proves nothing. One instance = one run:
+ * each URL is probed at most once, results and per-reason counters are kept for the run log.
+ */
+export class ImageUrlValidator {
+  private readonly options: Required<ImageUrlValidatorOptions>;
+  private readonly limiter: Bottleneck;
+  private readonly cache = new Map<string, Promise<ImageUrlCheck>>();
+  private readonly counters: Record<string, number> = {};
+  private probes = 0;
+
+  constructor(options: ImageUrlValidatorOptions = {}) {
+    this.options = {
+      allowedMimeTypes: ['image/jpeg', 'image/png'],
+      requireHttps: true,
+      timeoutMs: 5000,
+      maxRedirects: 3,
+      concurrency: 8,
+      maxProbes: Infinity,
+      userAgent: undefined,
+      ...options,
+    };
+    this.limiter = new Bottleneck({ maxConcurrent: this.options.concurrency });
+  }
+
+  validate(url: string): Promise<ImageUrlCheck> {
+    if (!this.cache.has(url)) {
+      this.cache.set(url, this.check(url).then((result) => {
+        const key = result.ok ? 'ok' : result.reason;
+        this.counters[key] = (this.counters[key] ?? 0) + 1;
+        return result;
+      }));
+    }
+    return this.cache.get(url);
+  }
+
+  validateAll(urls: string[]): Promise<ImageUrlCheck[]> {
+    return Promise.all(urls.map(url => this.validate(url)));
+  }
+
+  // Per-reason counts of the distinct URLs checked so far (cache hits are not counted twice).
+  get stats(): Record<string, number> {
+    return { ...this.counters };
+  }
+
+  private async check(url: string): Promise<ImageUrlCheck> {
+    const rejected = this.checkStatically(url);
+    if (rejected) {
+      return rejected;
+    }
+    if (this.probes >= this.options.maxProbes) {
+      return { url, ok: false, reason: ImageUrlRejectReason.budgetExhausted };
+    }
+    this.probes++;
+
+    try {
+      let response = await this.limiter.schedule(() => this.request('HEAD', url));
+      if (response.status === 405 || response.status === 501) {
+        response = await this.limiter.schedule(() => this.request('GET', url));
+      }
+      return this.checkResponse(url, response);
+    } catch (error) {
+      return { url, ok: false, reason: this.mapError(error) };
+    }
+  }
+
+  private checkStatically(url: string): ImageUrlCheck | null {
+    let parsed: URL;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return { url, ok: false, reason: ImageUrlRejectReason.invalidUrl };
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+      return { url, ok: false, reason: ImageUrlRejectReason.invalidUrl };
+    }
+    if (this.options.requireHttps && parsed.protocol !== 'https:') {
+      return { url, ok: false, reason: ImageUrlRejectReason.notHttps };
+    }
+    if (parsed.username || parsed.password) {
+      return { url, ok: false, reason: ImageUrlRejectReason.credentials };
+    }
+    if (PLACEHOLDER_PATTERN.test(parsed.pathname)) {
+      return { url, ok: false, reason: ImageUrlRejectReason.placeholder };
+    }
+    return null;
+  }
+
+  private request(method: 'HEAD' | 'GET', url: string): Promise<AxiosResponse> {
+    return axios.request({
+      method,
+      url,
+      timeout: this.options.timeoutMs,
+      maxRedirects: this.options.maxRedirects,
+      // body is never needed — the stream is destroyed right after the headers arrive
+      responseType: 'stream',
+      headers: this.options.userAgent ? { 'User-Agent': this.options.userAgent } : undefined,
+      validateStatus: () => true,
+    }).then((response) => {
+      response.data?.destroy?.();
+      return response;
+    });
+  }
+
+  private checkResponse(url: string, response: AxiosResponse): ImageUrlCheck {
+    const status = response.status;
+    const contentType = String(response.headers?.['content-type'] ?? '').split(';')[0].trim().toLowerCase();
+    const finalUrl: string = response.request?.res?.responseUrl ?? url;
+    const result = { url, status, contentType, finalUrl };
+
+    if (status !== 200) {
+      return { ...result, ok: false, reason: ImageUrlRejectReason.httpStatus };
+    }
+    if (this.options.requireHttps && !finalUrl.startsWith('https:')) {
+      return { ...result, ok: false, reason: ImageUrlRejectReason.notHttps };
+    }
+    if (PLACEHOLDER_PATTERN.test(finalUrl)) {
+      return { ...result, ok: false, reason: ImageUrlRejectReason.placeholder };
+    }
+    if (!this.options.allowedMimeTypes.includes(contentType)) {
+      return { ...result, ok: false, reason: ImageUrlRejectReason.wrongMime };
+    }
+    return { ...result, ok: true };
+  }
+
+  private mapError(error: any): ImageUrlRejectReason {
+    if (error?.code === 'ERR_FR_TOO_MANY_REDIRECTS') {
+      return ImageUrlRejectReason.tooManyRedirects;
+    }
+    if (error?.code === 'ECONNABORTED' || error?.code === 'ETIMEDOUT' || /timeout/i.test(error?.message ?? '')) {
+      return ImageUrlRejectReason.timeout;
+    }
+    return ImageUrlRejectReason.networkError;
+  }
+}