wineater-bot 4.19.0 → 4.20.0

package/src/services/profile/consent.svelte.ts

@@ -0,0 +1,103 @@
+// Cookie / tracking consent (GDPR, ePrivacy).
+//
+// The store decides whether consent is required: `Stores.requires_cookie_consent`
+// arrives with the store config (true for EU shops). A host page can force it
+// with `window.wineaterData.requireConsent = true`.
+//
+// Until the visitor accepts, the widget creates no identifiers and sends no
+// tracking: no taste-profile uid (localStorage + cookie), no `uniqueUserID`
+// cookie, no /events, no admin-api analytics. Search works as usual, just not
+// personalised. Declining also wipes identifiers created earlier.
+//
+// The choice itself is kept in localStorage — strictly necessary, so it is
+// allowed without consent.
+//
+// Leaf module on purpose: no imports. appStore pushes the store flag here via
+// setStoreConsentPolicy(); importing appStore from here created a cycle
+// (app-store → api → uid → consent → app-store) that crashed the bundle with a
+// TDZ error on load.
+
+export type ConsentChoice = 'granted' | 'denied';
+
+const CONSENT_KEY = 'wineater_consent';
+const IDENTIFIER_KEYS = ['wineater_uid', 'uniqueUserID'];
+
+function readChoice(): ConsentChoice | null {
+    try {
+        const v = window.localStorage.getItem(CONSENT_KEY);
+        return v === 'granted' || v === 'denied' ? v : null;
+    } catch {
+        return null;
+    }
+}
+
+let choice = $state<ConsentChoice | null>(readChoice());
+
+/** null — store config not loaded yet (unknown whether consent is required). */
+let storeRequires = $state<boolean | null>(null);
+
+/** Called by appStore once the store config is applied. */
+export function setStoreConsentPolicy(requiresConsent: boolean): void {
+    storeRequires = requiresConsent;
+}
+
+/** Store (or host page) requires an explicit opt-in before any tracking. */
+export function consentRequired(): boolean {
+    if ((window as any)?.wineaterData?.requireConsent === true) return true;
+    return storeRequires === true;
+}
+
+export function consentChoice(): ConsentChoice | null {
+    return choice;
+}
+
+/** Show the banner: consent needed and the visitor has not chosen yet. */
+export function shouldAskConsent(): boolean {
+    return storeRequires !== null && consentRequired() && choice === null;
+}
+
+/**
+ * Single gate for everything that identifies or tracks the visitor.
+ * Before the store config is loaded we do not know whether consent is
+ * required, so nothing is allowed yet — fail closed.
+ */
+export function trackingAllowed(): boolean {
+    if ((window as any)?.wineaterData?.tracking === false) return false;
+    if (storeRequires === null) return false;
+    if (!consentRequired()) return true;
+    return choice === 'granted';
+}
+
+function wipeIdentifiers(): void {
+    for (const key of IDENTIFIER_KEYS) {
+        try {
+            window.localStorage.removeItem(key);
+        } catch {
+            /* blocked */
+        }
+        try {
+            document.cookie = `${key}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+        } catch {
+            /* blocked */
+        }
+    }
+}
+
+const listeners = new Set<(c: ConsentChoice) => void>();
+
+/** React to a choice (e.g. drop the in-memory uid after "decline"). */
+export function onConsentChange(fn: (c: ConsentChoice) => void): () => void {
+    listeners.add(fn);
+    return () => listeners.delete(fn);
+}
+
+export function setConsent(next: ConsentChoice): void {
+    choice = next;
+    try {
+        window.localStorage.setItem(CONSENT_KEY, next);
+    } catch {
+        /* blocked — choice lives for this page only */
+    }
+    if (next === 'denied') wipeIdentifiers();
+    for (const fn of listeners) fn(next);
+}

package/src/services/profile/events.ts

@@ -0,0 +1,73 @@
+// Implicit-feedback events for the taste profile → POST /events on the main
+// backend (not admin-api: that service is being retired). Events are buffered
+// and flushed every FLUSH_MS or on page hide, in one request, with
+// `keepalive` so the last batch survives navigation to the shop's product page.
+//
+// `search` is deliberately NOT sent from here: the backend records it itself
+// (it has the parsed query). We only send what the backend cannot see.
+
+import { getUid, trackingEnabled } from './uid';
+
+export type FeedbackEventType = 'shown' | 'click' | 'more' | 'similar' | 'add_to_cart' | 'buy_click';
+
+export type FeedbackEvent = {
+    type: FeedbackEventType;
+    query_id?: string;
+    sku_ids?: string[];
+    text?: string;
+    position?: number;
+    meta?: Record<string, unknown>;
+};
+
+const FLUSH_MS = 2000;
+const MAX_BATCH = 100;
+
+type Sender = (batch: { uid: string; events: FeedbackEvent[] }) => Promise<void>;
+
+let sender: Sender | null = null;
+let queue: FeedbackEvent[] = [];
+let timer: ReturnType<typeof setTimeout> | null = null;
+let listenersBound = false;
+
+export function initFeedback(send: Sender): void {
+    sender = send;
+    if (listenersBound || typeof document === 'undefined') return;
+    listenersBound = true;
+    document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') void flushFeedback();
+    });
+    window.addEventListener('pagehide', () => void flushFeedback());
+}
+
+export function trackFeedback(event: FeedbackEvent): void {
+    if (!trackingEnabled() || !sender) return;
+    if (!event.sku_ids?.length && event.type !== 'more') return;
+    queue.push(event);
+    if (queue.length >= MAX_BATCH) {
+        void flushFeedback();
+        return;
+    }
+    if (!timer) timer = setTimeout(() => void flushFeedback(), FLUSH_MS);
+}
+
+export async function flushFeedback(): Promise<void> {
+    if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    }
+    if (!sender || queue.length === 0) return;
+    const uid = getUid();
+    if (!uid) {
+        queue = [];
+        return;
+    }
+    const events = queue.splice(0, MAX_BATCH);
+    try {
+        await sender({ uid, events });
+    } catch (error) {
+        // Feedback is best-effort: never surface it to the visitor, never retry
+        // (a retry storm on a broken endpoint would hurt more than lost events).
+        console.debug('[wineater] feedback flush failed:', (error as Error)?.message);
+    }
+    if (queue.length > 0) void flushFeedback();
+}

package/src/services/profile/uid.ts

@@ -0,0 +1,87 @@
+// Anonymous visitor id for the taste profile (backend: docs/PROFILE.md).
+// UUID v4, persisted in localStorage with a cookie fallback; both can be
+// unavailable (private mode, blocked storage), in which case the id lives for
+// the page only and the backend simply sees a one-off visitor.
+
+import { trackingAllowed, onConsentChange } from './consent.svelte';
+
+const STORAGE_KEY = 'wineater_uid';
+const COOKIE_DAYS = 365;
+
+let memoryUid: string | null = null;
+
+function generateUuidV4(): string {
+    const c = globalThis.crypto as Crypto | undefined;
+    if (c?.randomUUID) return c.randomUUID();
+    const bytes = new Uint8Array(16);
+    if (c?.getRandomValues) c.getRandomValues(bytes);
+    else for (let i = 0; i < 16; i++) bytes[i] = (Math.random() * 256) | 0;
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function readCookie(name: string): string | null {
+    try {
+        const prefix = name + '=';
+        for (const part of document.cookie.split(';')) {
+            const c = part.trim();
+            if (c.startsWith(prefix)) return decodeURIComponent(c.slice(prefix.length));
+        }
+    } catch {
+        /* no document / blocked */
+    }
+    return null;
+}
+
+function writeCookie(name: string, value: string): void {
+    try {
+        const expires = new Date(Date.now() + COOKIE_DAYS * 864e5).toUTCString();
+        document.cookie = `${name}=${encodeURIComponent(value)}; expires=${expires}; path=/; SameSite=Lax; Secure`;
+    } catch {
+        /* blocked */
+    }
+}
+
+/** tracking !== false и, если магазин требует, получено согласие (consent.svelte.ts). */
+export function trackingEnabled(): boolean {
+    return trackingAllowed();
+}
+
+// "Отклонить" стирает id из storage — и из памяти, чтобы текущая страница
+// перестала слать заголовок сразу, а не после перезагрузки.
+onConsentChange((c) => {
+    if (c === 'denied') memoryUid = null;
+});
+
+/** Stable anonymous id; same value for the whole page lifetime even if storage is blocked. */
+export function getUid(): string | null {
+    if (!trackingEnabled()) return null;
+    if (memoryUid) return memoryUid;
+
+    let uid: string | null = null;
+    try {
+        uid = window.localStorage.getItem(STORAGE_KEY);
+    } catch {
+        /* blocked */
+    }
+    if (!uid || !UUID_RE.test(uid)) uid = readCookie(STORAGE_KEY);
+    if (!uid || !UUID_RE.test(uid)) uid = generateUuidV4();
+
+    try {
+        window.localStorage.setItem(STORAGE_KEY, uid);
+    } catch {
+        /* quota / blocked */
+    }
+    if (readCookie(STORAGE_KEY) !== uid) writeCookie(STORAGE_KEY, uid);
+
+    memoryUid = uid;
+    return uid;
+}
+
+export function newQueryId(): string {
+    return generateUuidV4();
+}

package/src/services/store/app-store.svelte.ts

@@ -5,6 +5,7 @@ import type { StoreConfig } from "./types";
 import { deserializeStoreConfig } from "./deserialize";
 import type { ProjectUiConfig } from "../ui-config/types";
 import { getProjectUiConfig } from "../ui-config/get-config";
+import { setStoreConsentPolicy } from "../profile/consent.svelte";
 
 export type AppState = {
     storeConfig: StoreConfig | null;
@@ -56,6 +57,9 @@ export const appStore = {
     getSupportedLanguages(): LanguageCode[] {
         return state.storeConfig?.available_languages ?? ['en'];
     },
+    getConsentRequired(): boolean {
+        return state.storeConfig?.requires_cookie_consent === true;
+    },
     getCurrency(): CurrencyCode {
         return state.storeConfig?.currency ?? 'USD';
     },
@@ -70,13 +74,15 @@ export const appStore = {
             this.setStoreLanguage(state.storeConfig.lang as LanguageCode);
         }
         this.setUiConfig(getProjectUiConfig(state.storeConfig.id));
+        setStoreConsentPolicy(state.storeConfig.requires_cookie_consent);
         state.isConfigLoaded = true;
     },
     // Stale-while-revalidate: a cached config is applied synchronously (first
     // paint without waiting for the network) and refreshed in the background
     // for the next visit. Without a cache we wait for the network as before.
     async initializeStore() {
-        const cacheKey = `${cacheScope}:store-config`;
+        // :v2 — конфиг получил requires_cookie_consent; старый кэш (24 ч) его не знает
+        const cacheKey = `${cacheScope}:store-config:v2`;
         const fetchAndCache = async () => {
             const config = await wineaterApi.getStoreConfig();
             writeCache(cacheKey, config);

package/src/services/store/deserialize.ts

@@ -9,6 +9,7 @@ type RawStoreConfig = {
     open_ai_key: string | null;
     currency: CurrencyCode;
     title: string;
+    requires_cookie_consent?: boolean | null;
 }
 
 export function deserializeStoreConfig(data: RawStoreConfig): StoreConfig {
@@ -19,5 +20,6 @@ export function deserializeStoreConfig(data: RawStoreConfig): StoreConfig {
         open_ai_key: data.open_ai_key ?? null,
         currency: data.currency,
         title: data.title,
+        requires_cookie_consent: data.requires_cookie_consent === true,
     }
 }

package/src/services/store/types.ts

@@ -7,4 +7,6 @@ export type StoreConfig = {
     open_ai_key: string | null;
     currency: CurrencyCode;
     title: string;
+    /** EU shop: no tracking/identifiers until the visitor accepts cookies. */
+    requires_cookie_consent: boolean;
 };