@blotoutio/providers-evo-search-sdk 1.64.2 → 1.65.0

package/core.cjs.js

@@ -634,6 +634,95 @@ const notifyReady = () => {
     notifySubscribers(registry.subscribers, 'notifyReady');
 };
 
+// Resilience wrapper for /search requests. A transient network failure or a
+// hung request must not wedge the UI: add a per-attempt timeout (a hang becomes
+// a rejection), retry transient failures with backoff, and never retry a
+// caller-superseded (aborted) request. Shared by the widget and the headless
+// hook. See callers: search-widget.ts (performAutocomplete) and
+// hooks/use-evo-search.ts.
+const DEFAULTS = {
+    timeoutMs: 7000,
+    retries: 2,
+    backoffMs: [400, 1200],
+};
+// Deterministic HTTP errors (4xx other than 429) will never succeed on
+// retry — only retry timeouts, network errors, 429, and 5xx. Errors without
+// an attached `status` (network/timeout failures) are always retryable.
+const isRetryable = (error) => {
+    const status = error === null || error === void 0 ? void 0 : error.status;
+    return status == null || status === 429 || status >= 500;
+};
+const delay = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal.aborted)
+        return reject(new DOMException('Aborted', 'AbortError'));
+    const t = setTimeout(resolve, ms);
+    signal.addEventListener('abort', () => {
+        clearTimeout(t);
+        reject(new DOMException('Aborted', 'AbortError'));
+    }, { once: true });
+});
+/**
+ * Run `attempt` with a timeout, retrying transient failures. `callerSignal`
+ * supersedes everything: if it aborts, we stop immediately without retrying
+ * (the query changed / the widget cleaned up). A timeout or network error is
+ * retried up to `retries` times; anything left over is rethrown.
+ */
+async function withSearchResilience(attempt, callerSignal, options = {}) {
+    var _a, _b;
+    const { timeoutMs, retries, backoffMs } = { ...DEFAULTS, ...options };
+    let lastError;
+    for (let i = 0; i <= retries; i++) {
+        if (callerSignal.aborted)
+            throw new DOMException('Aborted', 'AbortError');
+        const local = new AbortController();
+        const onCallerAbort = () => local.abort();
+        callerSignal.addEventListener('abort', onCallerAbort, { once: true });
+        // Race the attempt against an explicit timeout that REJECTS. Aborting the
+        // signal alone isn't enough — an attempt that ignores its signal would
+        // otherwise hang forever and never retry. Reject with a TimeoutError (not
+        // an AbortError) so callers surface it instead of treating it as a
+        // caller-cancellation.
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                local.abort(); // still cancel the in-flight request to free the socket
+                reject(new DOMException('Search request timed out', 'TimeoutError'));
+            }, timeoutMs);
+        });
+        try {
+            return await Promise.race([attempt(local.signal), timeout]);
+        }
+        catch (error) {
+            lastError = error;
+            // The caller superseded this request — do not retry, propagate the abort.
+            if (callerSignal.aborted)
+                throw error;
+            // Otherwise it was a timeout or a transient network error: retry if budget remains.
+            if (i < retries && isRetryable(error)) {
+                const wait = (_b = (_a = backoffMs[i]) !== null && _a !== void 0 ? _a : backoffMs[backoffMs.length - 1]) !== null && _b !== void 0 ? _b : 0;
+                // Rejects with an AbortError if the caller aborts mid-backoff —
+                // propagate that cancellation instead of the transient `error` above.
+                await delay(wait, callerSignal);
+                continue;
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+            callerSignal.removeEventListener('abort', onCallerAbort);
+        }
+    }
+    throw lastError;
+}
+
+// Client-side deadlines for the Ask SSE path. `/search` already gets these via
+// withSearchResilience; Ask is the streaming counterpart. The request timeout
+// matches the resilience wrapper's per-attempt budget; the idle timeout catches
+// a stream that stalls mid-flight without a terminal frame and resets on every
+// chunk. Both surface a TimeoutError (not an AbortError) so submitAsk routes
+// them to the search fallback instead of treating them as caller-cancellation.
+const ASK_REQUEST_TIMEOUT_MS = 7000;
+const ASK_SSE_IDLE_TIMEOUT_MS = 10000;
 // Always defer to what the storefront itself is rendering — same source
 // shop-gpt reads from. Two widgets on the same page would otherwise drift:
 // shop-gpt picks Shopify, evo-search would pick its own override and show
@@ -661,15 +750,28 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
     if (!sendTag) {
         throw new Error('sendTag missing');
     }
+    const getChannel = () => { var _a; return (((_a = window[registryKey]) === null || _a === void 0 ? void 0 : _a.ui) ? 'widget' : 'headless'); };
     const getHeaders = () => {
-        var _a;
         const headers = new Headers({ EdgeTagUserId: userId });
         if (sessionId) {
             headers.set('EdgeTagSessionId', sessionId);
         }
-        headers.set('X-EvoSearch-Channel', ((_a = window[registryKey]) === null || _a === void 0 ? void 0 : _a.ui) ? 'widget' : 'headless');
+        headers.set('X-EvoSearch-Channel', getChannel());
         return headers;
     };
+    // Identity for the public read endpoints travels as query params instead of
+    // headers so the GET stays a CORS-simple request — no OPTIONS preflight,
+    // one connection attempt per keystroke instead of two (a hung transport
+    // path then wedges half as often, and withSearchResilience's retry isn't
+    // preceded by a second preflight). /user/* keeps the header form: the
+    // worker's cookie-HMAC auth binds to it, and those routes preflight anyway.
+    const setIdentityParams = (url) => {
+        url.searchParams.set('uid', userId);
+        if (sessionId) {
+            url.searchParams.set('sid', sessionId);
+        }
+        url.searchParams.set('channel', getChannel());
+    };
     // Parsing `baseURL` once at API construction avoids re-parsing the host on
     // every keystroke when `getURL` runs inside the autocomplete hot path.
     const baseOrigin = new URL(baseURL).origin;
@@ -692,10 +794,14 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
         for (const [key, value] of Object.entries(params !== null && params !== void 0 ? params : {})) {
             url.searchParams.set(key, value);
         }
+        const credentialed = needsCredentials(path);
+        if (!credentialed) {
+            setIdentityParams(url);
+        }
         const response = await fetchImpl(url, {
             method: 'GET',
-            headers: getHeaders(),
-            credentials: needsCredentials(path) ? 'include' : 'omit',
+            ...(credentialed ? { headers: getHeaders() } : {}),
+            credentials: credentialed ? 'include' : 'omit',
             signal,
         });
         if (!response.ok) {
@@ -715,17 +821,38 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
         logger.info('EvoSearch API: Fetching ask config');
         return getJSON('/config', 'Config', undefined, signal);
     };
-    // Fire-and-forget isolate warmer: tells the worker to prime its search
-    // index off the request path so the first keystroke doesn't pay the cold
-    // prime. Errors are irrelevant — autocomplete just falls back to priming
-    // inline like before.
+    // Isolate warmer doubling as connection establisher: primes the worker's
+    // search index off the request path AND opens the h2/h3 connection before
+    // the first real keystroke needs it. Runs under the resilience wrapper so a
+    // black-holed connection attempt (hung QUIC/IPv6 path) is aborted and
+    // retried — the retry is what lets the browser fall back to a working
+    // transport while the shopper is still reaching for the search box. Any
+    // HTTP response counts as success: even an error status proves the
+    // connection is established. Never rejects; concurrent triggers (open,
+    // focus, first keystroke, keep-warm tick) coalesce into one attempt.
+    let warmInFlight = null;
+    let warmAbort = null;
     const warm = () => {
-        fetchImpl(getURL('/warm'), {
-            method: 'GET',
-            headers: getHeaders(),
-            credentials: 'omit',
-        }).catch(() => undefined);
+        if (warmInFlight) {
+            return warmInFlight;
+        }
+        const url = getURL('/warm');
+        setIdentityParams(url);
+        warmAbort = new AbortController();
+        warmInFlight = withSearchResilience((signal) => fetchImpl(url, { method: 'GET', credentials: 'omit', signal }), warmAbort.signal)
+            .then(() => undefined)
+            .catch(() => undefined)
+            .finally(() => {
+            warmInFlight = null;
+            warmAbort = null;
+        });
+        return warmInFlight;
     };
+    // Closing the widget must kill the chain: a black-holed attempt would
+    // otherwise keep re-establishing connections for the wrapper's full budget
+    // (~23s) after the overlay is gone — exactly the churn warm() exists to
+    // avoid. The next warm() mints a fresh controller.
+    const cancelWarm = () => warmAbort === null || warmAbort === void 0 ? void 0 : warmAbort.abort();
     const recents = (signal) => {
         logger.info('EvoSearch API: Fetching recent searches');
         return getJSON('/user/recents', 'Recents', undefined, signal);
@@ -766,50 +893,107 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
     // reader, the for-await loop drops out, and the iterator returns.
     async function* askStream(query, signal) {
         const url = getURL('/ask');
-        const response = await fetchImpl(url, {
-            method: 'POST',
-            headers: (() => {
-                const h = getHeaders();
-                h.set('Content-Type', 'application/json');
-                return h;
-            })(),
-            body: JSON.stringify({ query }),
-            credentials: 'omit',
-            signal,
-        });
-        if (!response.ok || !response.body) {
-            throw new Error(`Ask failed - ${response.status}`);
+        // One controller drives teardown for the whole stream: the caller's signal,
+        // the initial-request deadline, and the SSE idle timeout all abort through
+        // it, so a stall closes the fetch instead of hanging. `timedOut` lets us
+        // rethrow a TimeoutError rather than the AbortError the abort would raise.
+        const controller = new AbortController();
+        const onCallerAbort = () => controller.abort();
+        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onCallerAbort, { once: true });
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            controller.abort();
         }
-        const reader = response.body
-            .pipeThrough(new TextDecoderStream())
-            .getReader();
-        let buffer = '';
+        let timedOut = false;
+        const initialTimer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, ASK_REQUEST_TIMEOUT_MS);
+        // Outer try guarantees the caller-signal listener is removed on EVERY exit
+        // path. It's `{ once: true }`, so a caller abort auto-removes it — but the
+        // initial-timeout, network-error, and non-ok paths never fire the abort
+        // event, so without this they'd leak a listener on a long-lived shared
+        // signal (one per Ask query).
         try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
+            let response;
+            try {
+                response = await fetchImpl(url, {
+                    method: 'POST',
+                    headers: (() => {
+                        const h = getHeaders();
+                        h.set('Content-Type', 'application/json');
+                        return h;
+                    })(),
+                    body: JSON.stringify({ query }),
+                    credentials: 'omit',
+                    signal: controller.signal,
+                });
+            }
+            catch (error) {
+                if (timedOut) {
+                    throw new DOMException('Ask request timed out', 'TimeoutError');
                 }
-                buffer += value;
-                let boundary = buffer.indexOf('\n\n');
-                while (boundary !== -1) {
-                    const frame = buffer.slice(0, boundary);
-                    buffer = buffer.slice(boundary + 2);
-                    const event = parseSseFrame(frame);
-                    if (event) {
-                        yield event;
+                throw error;
+            }
+            finally {
+                // The idle timeout takes over once the response resolves.
+                clearTimeout(initialTimer);
+            }
+            if (!response.ok || !response.body) {
+                throw new Error(`Ask failed - ${response.status}`);
+            }
+            const reader = response.body
+                .pipeThrough(new TextDecoderStream())
+                .getReader();
+            let buffer = '';
+            try {
+                while (true) {
+                    // Idle timeout, reset every chunk: a stream that stalls mid-flight
+                    // (no terminal frame) rejects here instead of freezing the skeleton.
+                    let idleTimer;
+                    const idle = new Promise((_, reject) => {
+                        idleTimer = setTimeout(() => {
+                            timedOut = true;
+                            controller.abort();
+                            reject(new DOMException('Ask stream stalled', 'TimeoutError'));
+                        }, ASK_SSE_IDLE_TIMEOUT_MS);
+                    });
+                    let result;
+                    try {
+                        result = await Promise.race([reader.read(), idle]);
+                    }
+                    finally {
+                        clearTimeout(idleTimer);
+                    }
+                    const { done, value } = result;
+                    if (done) {
+                        break;
+                    }
+                    buffer += value;
+                    let boundary = buffer.indexOf('\n\n');
+                    while (boundary !== -1) {
+                        const frame = buffer.slice(0, boundary);
+                        buffer = buffer.slice(boundary + 2);
+                        const event = parseSseFrame(frame);
+                        if (event) {
+                            yield event;
+                        }
+                        boundary = buffer.indexOf('\n\n');
                     }
-                    boundary = buffer.indexOf('\n\n');
+                }
+            }
+            finally {
+                try {
+                    // cancel (not releaseLock) — safe with an outstanding read and tears
+                    // down the upstream fetch on a caller-abort or idle timeout.
+                    await reader.cancel();
+                }
+                catch {
+                    // ignore — already closed
                 }
             }
         }
         finally {
-            try {
-                reader.releaseLock();
-            }
-            catch {
-                // ignore
-            }
+            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onCallerAbort);
         }
     }
     const sendEvent = (action, currency, actionData, clickData, beacon) => {
@@ -861,6 +1045,7 @@ const createEvoSearchAPI = ({ fetch: fetchImpl = window.fetch, baseURL, userId,
         trending,
         config,
         warm,
+        cancelWarm,
         user: {
             recents,
             deleteRecent,