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

package/core.js

@@ -635,6 +635,95 @@ var ProvidersEvoSearchSdk = (function () {
         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
@@ -662,15 +751,28 @@ var ProvidersEvoSearchSdk = (function () {
         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;
@@ -693,10 +795,14 @@ var ProvidersEvoSearchSdk = (function () {
             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) {
@@ -716,17 +822,38 @@ var ProvidersEvoSearchSdk = (function () {
             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);
@@ -767,50 +894,107 @@ var ProvidersEvoSearchSdk = (function () {
         // 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) => {
@@ -862,6 +1046,7 @@ var ProvidersEvoSearchSdk = (function () {
             trending,
             config,
             warm,
+            cancelWarm,
             user: {
                 recents,
                 deleteRecent,