cdp-edge 2.0.2 → 2.0.4

package/server-edge-tracker/modules/db.js

@@ -0,0 +1,531 @@
+/**
+ * CDP Edge — Camada D1 (Database)
+ * Todas as operações de escrita/leitura no banco D1.
+ * Bindings: env.DB, env.GEO_CACHE, env.AUDIT_LOGS
+ */
+
+import { sha256, normalizePhone, normalizeCity } from './utils.js';
+
+// ── saveLead — inserir evento de conversão ────────────────────────────────────
+export async function saveLead(env, eventName, payload, request, platform = 'website') {
+  if (!env.DB) return;
+  try {
+    const {
+      email, phone, firstName, lastName,
+      city, state, country,
+      fbp, fbc, userId,
+      utmSource, utmMedium, utmCampaign, utmContent, utmTerm,
+      pageUrl, value, currency, eventId, botScore,
+      engagementScore, intentionLevel, utmRestored,
+    } = payload;
+
+    await env.DB.prepare(`
+      INSERT INTO leads (
+        event_name, event_id, email, phone, first_name, last_name,
+        city, state, country, fbp, fbc, user_id,
+        utm_source, utm_medium, utm_campaign, utm_content, utm_term,
+        page_url, value, currency, ip_address, platform, bot_score,
+        engagement_score, intention_level, utm_restored, created_at
+      ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,datetime('now'))
+    `).bind(
+      eventName,
+      eventId       || null,
+      email         || null,
+      normalizePhone(phone) || null,
+      firstName     || null,
+      lastName      || null,
+      city          || null,
+      state         || null,
+      (country      || request.cf?.country || null),
+      fbp           || null,
+      fbc           || null,
+      userId        || null,
+      utmSource     || null,
+      utmMedium     || null,
+      utmCampaign   || null,
+      utmContent    || null,
+      utmTerm       || null,
+      pageUrl       || null,
+      value !== undefined ? parseFloat(value) : null,
+      currency      || 'BRL',
+      request.headers.get('CF-Connecting-IP') || null,
+      platform,
+      botScore      || 0,
+      engagementScore !== undefined ? parseFloat(engagementScore) : null,
+      intentionLevel || null,
+      utmRestored ? 1 : 0,
+    ).run();
+  } catch (err) {
+    console.error('D1 saveLead error:', err.message);
+  }
+}
+
+// ── calculateCohortLabel ──────────────────────────────────────────────────────
+export function calculateCohortLabel(score, eventName) {
+  if (eventName === 'Purchase') return 'buyer_lookalike';
+  if (score >= 80)  return 'high_intent';
+  if (score >= 30)  return 'nurture';
+  return 'lost';
+}
+
+// ── upsertProfile — acumula cookies/scores entre visitas ─────────────────────
+export async function upsertProfile(env, eventName, payload, request) {
+  if (!env.DB || !payload.userId) return;
+  try {
+    const {
+      userId, email, phone,
+      fbp, fbc, ttp, gclid, ttclid, gaClientId,
+      city, state, country,
+      engagementScore, userScore,
+    } = payload;
+
+    const scoreMap = { PageView: 5, ViewContent: 10, ScrollDepth: 3, TimeOnPage: 5, Lead: 30, InitiateCheckout: 50, Purchase: 100 };
+    const eventScore = scoreMap[eventName] || 2;
+
+    const behaviorBonus = userScore
+      ? Math.round((Math.min(userScore, 100) / 100) * 20)
+      : (engagementScore ? Math.round((Math.min(engagementScore, 5) / 5) * 10) : 0);
+
+    const totalDelta = eventScore + behaviorBonus;
+
+    await env.DB.prepare(`
+      INSERT INTO user_profiles
+        (user_id, email, phone, fbp, fbc, ttp, gclid, ttclid, ga_client_id,
+         city, state, country, score, cohort_label, created_at, updated_at)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,datetime('now'),datetime('now'))
+      ON CONFLICT(user_id) DO UPDATE SET
+        email        = COALESCE(excluded.email,        user_profiles.email),
+        phone        = COALESCE(excluded.phone,        user_profiles.phone),
+        fbp          = COALESCE(excluded.fbp,          user_profiles.fbp),
+        fbc          = COALESCE(excluded.fbc,          user_profiles.fbc),
+        ttp          = COALESCE(excluded.ttp,          user_profiles.ttp),
+        gclid        = COALESCE(excluded.gclid,        user_profiles.gclid),
+        ttclid       = COALESCE(excluded.ttclid,       user_profiles.ttclid),
+        ga_client_id = COALESCE(excluded.ga_client_id, user_profiles.ga_client_id),
+        city         = COALESCE(excluded.city,         user_profiles.city),
+        state        = COALESCE(excluded.state,        user_profiles.state),
+        country      = COALESCE(excluded.country,      user_profiles.country),
+        score        = user_profiles.score + excluded.score,
+        cohort_label = excluded.cohort_label,
+        updated_at   = datetime('now')
+    `).bind(
+      userId,
+      email              || null,
+      normalizePhone(phone) || null,
+      fbp                || null,
+      fbc                || null,
+      ttp                || null,
+      gclid              || null,
+      ttclid             || null,
+      gaClientId         || null,
+      city               || null,
+      state              || null,
+      (country           || request.cf?.country || null),
+      totalDelta,
+      calculateCohortLabel(totalDelta, eventName),
+    ).run();
+  } catch (err) {
+    console.error('D1 upsertProfile error:', err.message);
+  }
+}
+
+// ── resolveDeviceGraph — Cross-Device Identity ────────────────────────────────
+export async function resolveDeviceGraph(DB, currentUserId, email, phone) {
+  if (!DB || !currentUserId) return;
+  if (!email && !phone) return;
+
+  try {
+    const conditions = [];
+    const bindings   = [];
+
+    if (email) {
+      conditions.push('email = ?');
+      bindings.push(email.toLowerCase().trim());
+    }
+    if (phone) {
+      const digits = String(phone).replace(/\D/g, '');
+      if (digits.length >= 10) {
+        conditions.push('phone LIKE ?');
+        bindings.push(`%${digits.slice(-10)}`);
+      }
+    }
+
+    if (conditions.length === 0) return;
+
+    bindings.push(currentUserId);
+    const rows = await DB.prepare(`
+      SELECT user_id, email, phone, created_at
+      FROM user_profiles
+      WHERE (${conditions.join(' OR ')})
+        AND user_id != ?
+      ORDER BY created_at ASC
+      LIMIT 5
+    `).bind(...bindings).all();
+
+    if (!rows.results || rows.results.length === 0) return;
+
+    for (const match of rows.results) {
+      const emailMatch = email && match.email &&
+        email.toLowerCase().trim() === match.email.toLowerCase().trim();
+      const phoneMatch = phone && match.phone && (() => {
+        const a = String(phone).replace(/\D/g, '');
+        const b = String(match.phone).replace(/\D/g, '');
+        return a.slice(-10) === b.slice(-10) && a.length >= 10;
+      })();
+
+      if (!emailMatch && !phoneMatch) continue;
+
+      const matchType       = emailMatch && phoneMatch ? 'email+phone' : (emailMatch ? 'email' : 'phone');
+      const matchConfidence = emailMatch && phoneMatch ? 0.99 : (emailMatch ? 0.95 : 0.85);
+      const primary   = match.user_id;
+      const secondary = currentUserId;
+
+      await DB.prepare(`
+        INSERT OR IGNORE INTO device_graph
+          (primary_user_id, secondary_user_id, match_type, match_confidence)
+        VALUES (?, ?, ?, ?)
+      `).bind(primary, secondary, matchType, matchConfidence).run();
+
+      console.log(`[DeviceGraph] Linked ${secondary} → ${primary} via ${matchType} (confidence: ${matchConfidence})`);
+    }
+  } catch (err) {
+    console.error('resolveDeviceGraph error:', err.message);
+  }
+}
+
+// ── fireAutomation — dispara regras de automação (WA/Email) ──────────────────
+export async function fireAutomation(env, eventName, leadId, payload) {
+  if (!env.DB) return;
+
+  try {
+    const { results: rules } = await env.DB
+      .prepare(
+        `SELECT id, channel, subject_template, message_template
+         FROM automation_rules
+         WHERE trigger_event = ?1 AND is_active = 1`
+      )
+      .bind(eventName)
+      .all();
+
+    if (!rules || rules.length === 0) return;
+
+    const vars = {
+      name:      String(payload.firstName || payload.name || ''),
+      email:     String(payload.email     || ''),
+      phone:     String(payload.phone     || ''),
+      campaign:  String(payload.utm_campaign || payload.utmCampaign || ''),
+      intention: String(payload.intentionLevel || payload.intention_level || ''),
+    };
+
+    const interpolate = (tpl) =>
+      tpl.replace(/\{\{(\w+)\}\}/g, (_, k) => vars[k] ?? '');
+
+    for (const rule of rules) {
+      const message = interpolate(rule.message_template);
+      const subject = rule.subject_template ? interpolate(rule.subject_template) : null;
+
+      try {
+        if (rule.channel === 'whatsapp' && payload.phone && env.WHATSAPP_ACCESS_TOKEN && env.WHATSAPP_PHONE_NUMBER_ID) {
+          const digits  = String(payload.phone).replace(/\D/g, '');
+          const e164    = digits.startsWith('55') ? `+${digits}` : `+55${digits}`;
+          const waRes   = await fetch(
+            `https://graph.facebook.com/v22.0/${env.WHATSAPP_PHONE_NUMBER_ID}/messages`,
+            {
+              method: 'POST',
+              headers: { 'Authorization': `Bearer ${env.WHATSAPP_ACCESS_TOKEN}`, 'Content-Type': 'application/json' },
+              body: JSON.stringify({ messaging_product: 'whatsapp', recipient_type: 'individual', to: e164, type: 'text', text: { body: message } }),
+            }
+          );
+          const waData  = await waRes.json();
+          const status  = waRes.ok ? 'sent' : 'failed';
+          const meta    = waRes.ok ? (waData.messages?.[0]?.id ?? null) : JSON.stringify(waData);
+          await env.DB.prepare(
+            `INSERT INTO messaging_history (lead_id, channel, recipient, subject, content, status, meta) VALUES (?1,?2,?3,?4,?5,?6,?7)`
+          ).bind(leadId, 'whatsapp', e164, null, message, status, meta).run();
+
+        } else if (rule.channel === 'email' && payload.email && env.RESEND_API_KEY) {
+          const resendRes  = await fetch('https://api.resend.com/emails', {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${env.RESEND_API_KEY}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              from:    env.RESEND_FROM_EMAIL || 'noreply@cdp-edge.app',
+              to:      [payload.email],
+              subject: subject || `Olá, ${vars.name || 'você'}!`,
+              html:    `<p>${message.replace(/\n/g, '<br>')}</p>`,
+            }),
+          });
+          const resendData = await resendRes.json();
+          const status     = resendRes.ok ? 'sent' : 'failed';
+          const meta       = resendRes.ok ? (resendData.id ?? null) : JSON.stringify(resendData);
+          await env.DB.prepare(
+            `INSERT INTO messaging_history (lead_id, channel, recipient, subject, content, status, meta) VALUES (?1,?2,?3,?4,?5,?6,?7)`
+          ).bind(leadId, 'email', payload.email, subject, message, status, meta).run();
+        }
+      } catch (err) {
+        console.error(`[Automation] rule ${rule.id} error:`, err.message);
+      }
+    }
+  } catch (err) {
+    console.error('[Automation] fireAutomation error:', err.message);
+  }
+}
+
+// ── getProfileByEmail ─────────────────────────────────────────────────────────
+export async function getProfileByEmail(env, email) {
+  if (!env.DB || !email) return null;
+  try {
+    return await env.DB.prepare(
+      'SELECT * FROM user_profiles WHERE email = ? ORDER BY updated_at DESC LIMIT 1'
+    ).bind(email.toLowerCase().trim()).first();
+  } catch {
+    return null;
+  }
+}
+
+// ── enrichGeoFromEdge — enriquece payload com dados de geolocalização ─────────
+export async function enrichGeoFromEdge(request, env, payload) {
+  const cf = request.cf || {};
+  const ip = request.headers.get('CF-Connecting-IP') || '';
+
+  let geoData = null;
+  if (env.GEO_CACHE && ip) {
+    try {
+      const cached = await env.GEO_CACHE.get(`geo:${ip}`, 'json');
+      if (cached) geoData = cached;
+    } catch {}
+  }
+
+  if (!geoData) {
+    geoData = {
+      country:    cf.country          || null,
+      continent:  cf.continent        || null,
+      asn:        cf.asn              || null,
+      asOrg:      cf.asOrganization   || null,
+      colo:       cf.colo             || null,
+      city:       cf.city             || null,
+      region:     cf.region           || null,
+      regionCode: cf.regionCode       || null,
+      postalCode: cf.postalCode       || null,
+      latitude:   cf.latitude         || null,
+      longitude:  cf.longitude        || null,
+      timezone:   cf.timezone         || null,
+      metroCode:  cf.metroCode        || null,
+    };
+
+    if (env.GEO_CACHE && ip && geoData.country) {
+      try {
+        await env.GEO_CACHE.put(`geo:${ip}`, JSON.stringify(geoData), { expirationTtl: 3600 });
+      } catch {}
+    }
+  }
+
+  payload.country = payload.country || geoData.country;
+  payload.city    = payload.city    || geoData.city;
+  payload.state   = payload.state   || geoData.regionCode;
+  payload.zip     = payload.zip     || geoData.postalCode;
+  payload.geo     = geoData;
+
+  return geoData;
+}
+
+// ── writeAuditLog — grava evento no R2 ───────────────────────────────────────
+export async function writeAuditLog(env, eventName, payload, geoData) {
+  if (!env.AUDIT_LOGS) return;
+  try {
+    const now = new Date();
+    const y   = now.getUTCFullYear();
+    const m   = String(now.getUTCMonth() + 1).padStart(2, '0');
+    const d   = String(now.getUTCDate()).padStart(2, '0');
+    const key = `logs/${y}/${m}/${d}/${now.getTime()}_${eventName}.json`;
+
+    const log = {
+      timestamp: now.toISOString(),
+      event:     eventName,
+      userId:    payload.userId    || null,
+      eventId:   payload.eventId   || null,
+      value:     payload.value     || null,
+      currency:  payload.currency  || null,
+      ltvClass:  payload.ltvClass  || null,
+      utm: {
+        source:   payload.utmSource   || null,
+        medium:   payload.utmMedium   || null,
+        campaign: payload.utmCampaign || null,
+        content:  payload.utmContent  || null,
+        term:     payload.utmTerm     || null,
+        restored: payload.utmRestored || false,
+      },
+      geo: geoData || null,
+    };
+
+    await env.AUDIT_LOGS.put(key, JSON.stringify(log), {
+      httpMetadata: { contentType: 'application/json' },
+    });
+  } catch (err) {
+    console.error('[R2 Audit] Error:', err.message);
+  }
+}
+
+// ── generateEdgeFingerprint ───────────────────────────────────────────────────
+export async function generateEdgeFingerprint(request) {
+  const asn  = String(request.cf?.asn || '0');
+  const lang = (request.headers.get('Accept-Language') || 'unknown').split(',')[0].trim();
+  const ua   = request.headers.get('User-Agent') || '';
+
+  const uaBase = ua
+    .toLowerCase()
+    .replace(/[\d.]+/g, '')
+    .replace(/[^a-z\s]/g, ' ')
+    .split(' ')
+    .filter(w => w.length > 3)
+    .slice(0, 4)
+    .join(' ')
+    .trim();
+
+  const raw = `${asn}|${lang}|${uaBase}`;
+  return sha256(raw);
+}
+
+// ── saveEdgeFingerprint ───────────────────────────────────────────────────────
+export async function saveEdgeFingerprint(DB, fingerprint, userId, payload) {
+  if (!DB || !fingerprint) return;
+  const { utmSource, utmMedium, utmCampaign, utmContent, utmTerm } = payload;
+  if (!utmSource) return;
+
+  try {
+    await DB.prepare(`
+      INSERT INTO edge_fingerprints (fingerprint, user_id, utm_source, utm_medium, utm_campaign, utm_content, utm_term)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).bind(
+      fingerprint,
+      userId      || null,
+      utmSource   || null,
+      utmMedium   || null,
+      utmCampaign || null,
+      utmContent  || null,
+      utmTerm     || null,
+    ).run();
+  } catch (err) {
+    console.error('saveEdgeFingerprint error:', err.message);
+  }
+}
+
+// ── resurrectUTM ──────────────────────────────────────────────────────────────
+export async function resurrectUTM(DB, fingerprint) {
+  if (!DB || !fingerprint) return null;
+  try {
+    return await DB.prepare(`
+      SELECT utm_source, utm_medium, utm_campaign, utm_content, utm_term
+      FROM edge_fingerprints
+      WHERE fingerprint = ?
+        AND utm_source IS NOT NULL
+        AND created_at > datetime('now', '-48 hours')
+      ORDER BY created_at DESC
+      LIMIT 1
+    `).bind(fingerprint).first();
+  } catch {
+    return null;
+  }
+}
+
+// ── upsertLtvProfile — persiste LTV no perfil ────────────────────────────────
+export async function upsertLtvProfile(env, userId, ltv) {
+  if (!env.DB || !userId) return;
+  try {
+    await env.DB.prepare(`
+      UPDATE user_profiles
+      SET predicted_ltv_class = ?,
+          predicted_ltv_value = ?,
+          updated_at          = datetime('now')
+      WHERE user_id = ?
+    `).bind(ltv.class, ltv.value, userId).run();
+  } catch (err) {
+    console.error('upsertLtvProfile error:', err.message);
+  }
+}
+
+// ── Feedback Loop — Log de falhas e métricas de saúde ────────────────────────
+
+export async function logApiFailure(DB, platform, eventName, errorCode, errorMessage, eventId, rawPayload) {
+  try {
+    await DB.prepare(`
+      INSERT INTO api_failures (platform, event_name, error_code, error_message, event_id, raw_payload, retry_count, final_status)
+      VALUES (?, ?, ?, ?, ?, ?, 0, 'failed')
+    `).bind(platform, eventName, String(errorCode), errorMessage, eventId, rawPayload).run();
+  } catch (err) {
+    console.error('Failed to log API failure:', err.message);
+  }
+}
+
+export async function getHealthMetrics(DB, platform, hours = 24) {
+  try {
+    const failures = await DB.prepare(`
+      SELECT COUNT(*) as count, error_code
+      FROM api_failures
+      WHERE platform = ? AND created_at > datetime('now', '-${hours} hours')
+      GROUP BY error_code
+    `).bind(platform).all();
+
+    const totalSent = await DB.prepare(`
+      SELECT COUNT(*) as count
+      FROM leads
+      WHERE platform = ? AND created_at > datetime('now', '-${hours} hours')
+    `).bind(platform).first();
+
+    const totalFailed = failures.results?.reduce((sum, f) => sum + f.count, 0) || 0;
+    const successRate = totalSent?.count > 0
+      ? ((totalSent.count - totalFailed) / totalSent.count) * 100
+      : 100;
+
+    return {
+      platform,
+      hours,
+      events_sent: totalSent?.count || 0,
+      events_failed: totalFailed,
+      success_rate: successRate,
+      errors_detected: (failures.results || []).map(f => ({ code: f.error_code, count: f.count })),
+      issues: totalFailed > (totalSent?.count || 0) * 0.1 ? ['high_error_rate'] : [],
+    };
+  } catch (err) {
+    console.error('Failed to get health metrics:', err.message);
+    return { platform, hours, events_sent: 0, events_failed: 0, success_rate: 0, errors_detected: [], issues: ['metrics_unavailable'] };
+  }
+}
+
+export async function generateDailyReport(DB) {
+  const platforms = ['meta', 'ga4', 'tiktok', 'pinterest', 'reddit'];
+  const today = new Date().toISOString().split('T')[0];
+  const reports = [];
+
+  for (const platform of platforms) {
+    const metrics = await getHealthMetrics(DB, platform, 24);
+
+    try {
+      await DB.prepare(`
+        INSERT INTO health_reports (report_date, platform, events_sent, events_failed, success_rate, errors_detected, issues_detected)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).bind(
+        today, platform,
+        metrics.events_sent, metrics.events_failed, metrics.success_rate,
+        JSON.stringify(metrics.errors_detected), JSON.stringify(metrics.issues)
+      ).run();
+      reports.push({ platform, status: 'ok' });
+    } catch (err) {
+      console.error(`Failed to generate report for ${platform}:`, err.message);
+      reports.push({ platform, status: 'failed' });
+    }
+  }
+
+  return reports;
+}
+
+export async function logIntelligence(DB, runType, platform, checkType, status, currentValue, expectedValue, message, alertSent = false) {
+  if (!DB) return;
+  try {
+    await DB.prepare(`
+      INSERT INTO intelligence_logs (run_type, platform, check_type, status, current_value, expected_value, message, alert_sent)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).bind(runType, platform, checkType, status, String(currentValue ?? ''), String(expectedValue ?? ''), message, alertSent ? 1 : 0).run();
+  } catch (err) {
+    console.error('logIntelligence error:', err.message);
+  }
+}

package/server-edge-tracker/modules/dispatch/ga4.js

@@ -0,0 +1,65 @@
+/**
+ * CDP Edge — GA4 Measurement Protocol
+ * Envia eventos server-side para o GA4 via Measurement Protocol.
+ */
+
+import { normalizePhone } from '../utils.js';
+import { logApiFailure } from '../db.js';
+
+export async function sendGA4Mp(env, ga4EventName, payload, ctx) {
+  if (!env.GA4_API_SECRET) return { skipped: 'GA4_API_SECRET not set' };
+
+  const {
+    clientId, sessionId,
+    value, currency, contentName,
+    email, phone, firstName,
+    orderId,
+  } = payload;
+
+  if (!clientId) return { skipped: 'no clientId' };
+
+  const eventParams = {
+    ...(value       !== undefined && { value: parseFloat(value) }),
+    ...(currency    && { currency: String(currency).toUpperCase() }),
+    ...(contentName && { content_name: contentName }),
+    ...(orderId     && { transaction_id: orderId }),
+    ...(email       && { user_data_email_address: email.toLowerCase().trim() }),
+    ...(phone       && { user_data_phone_number: normalizePhone(phone) }),
+    ...(firstName   && { user_data_first_name: firstName.toLowerCase().trim() }),
+    ...(sessionId   && { session_id: sessionId }),
+    engagement_time_msec: 100,
+  };
+
+  const body = {
+    client_id: clientId,
+    events: [{ name: ga4EventName, params: eventParams }],
+  };
+
+  const url = `https://www.google-analytics.com/mp/collect`
+            + `?measurement_id=${env.GA4_MEASUREMENT_ID}`
+            + `&api_secret=${env.GA4_API_SECRET}`;
+
+  try {
+    const res = await fetch(url, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify(body),
+    });
+
+    if (res.status !== 204) {
+      if (env.DB && ctx) {
+        ctx.waitUntil(logApiFailure(env.DB, 'ga4', ga4EventName, String(res.status), 'GA4 returned non-204 status', null, JSON.stringify(body)));
+      }
+    }
+
+    return res.status === 204 ? { ok: true } : { status: res.status };
+  } catch (err) {
+    console.error('GA4 MP fetch failed:', err.message);
+
+    if (env.DB && ctx) {
+      ctx.waitUntil(logApiFailure(env.DB, 'ga4', ga4EventName, 'FETCH_ERROR', err.message, null, JSON.stringify(body)));
+    }
+
+    return { error: err.message };
+  }
+}

package/server-edge-tracker/modules/dispatch/meta.js

@@ -0,0 +1,103 @@
+/**
+ * CDP Edge — Meta Conversions API v22.0
+ * Envia eventos server-side para a Meta CAPI.
+ */
+
+import { sha256, normalizePhone, normalizeCity } from '../utils.js';
+import { logApiFailure } from '../db.js';
+
+export async function sendMetaCapi(env, eventName, payload, request, ctx) {
+  const {
+    email, phone, firstName, lastName,
+    city, state, country,
+    zip, dob,
+    fbp, fbc, userId,
+    eventId, pageUrl,
+    value, currency,
+    contentIds, contentName, contentType, numItems,
+  } = payload;
+
+  const phoneNorm   = normalizePhone(phone);
+  const countryCode = (country || request.cf?.country || 'br').toLowerCase();
+  const stateCode   = state ? String(state).toLowerCase() : undefined;
+  const cityNorm    = normalizeCity(city);
+
+  const userData = {
+    ...(email      && { em:       await sha256(email) }),
+    ...(phoneNorm  && { ph:       await sha256(phoneNorm) }),
+    ...(firstName  && { fn:       await sha256(firstName) }),
+    ...(lastName   && { ln:       await sha256(lastName) }),
+    ...(cityNorm   && { ct:       await sha256(cityNorm) }),
+    ...(stateCode  && { st:       await sha256(stateCode) }),
+    ...(countryCode && { country: await sha256(countryCode) }),
+    ...(userId     && { external_id: await sha256(String(userId)) }),
+    ...(zip        && { zp:         await sha256(zip) }),
+    ...(dob        && { db:         await sha256(dob) }),
+    ...(fbp        && { fbp }),
+    ...(fbc        && { fbc }),
+    client_ip_address: request.headers.get('CF-Connecting-IP')
+                    || request.headers.get('X-Forwarded-For')
+                    || '',
+    client_user_agent: request.headers.get('User-Agent') || '',
+  };
+
+  const customData = {
+    ...(value       !== undefined && { value: parseFloat(value) }),
+    ...(currency    && { currency: String(currency).toUpperCase() }),
+    ...(contentIds  && contentIds.length > 0 && { content_ids: contentIds }),
+    ...(contentName && { content_name: contentName }),
+    ...(contentType && { content_type: contentType }),
+    ...(numItems    && { num_items: parseInt(numItems) }),
+  };
+
+  const eventPayload = {
+    event_name:       eventName,
+    event_time:       Math.floor(Date.now() / 1000),
+    event_id:         eventId || `cdp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    event_source_url: pageUrl || `https://${env.SITE_DOMAIN}`,
+    action_source:    'website',
+    user_data:        userData,
+    ...(Object.keys(customData).length > 0 && { custom_data: customData }),
+  };
+
+  const requestBody = {
+    data:         [eventPayload],
+    access_token: env.META_ACCESS_TOKEN,
+  };
+
+  if (env.META_TEST_CODE) {
+    requestBody.test_event_code = env.META_TEST_CODE;
+  }
+
+  const endpoint = `https://graph.facebook.com/v22.0/${env.META_PIXEL_ID}/events`;
+
+  try {
+    const res = await fetch(endpoint, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body:    JSON.stringify(requestBody),
+    });
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      const errorCode    = data.error?.code || String(res.status);
+      const errorMessage = data.error?.message || data.error?.error_user_msg || 'Unknown error';
+      console.error('Meta CAPI error:', res.status, errorMessage);
+
+      if (env.DB && ctx) {
+        ctx.waitUntil(logApiFailure(env.DB, 'meta', eventName, errorCode, errorMessage, eventPayload.event_id, JSON.stringify(requestBody)));
+      }
+    }
+
+    return data;
+  } catch (err) {
+    console.error('Meta CAPI fetch failed:', err.message);
+
+    if (env.DB && ctx) {
+      ctx.waitUntil(logApiFailure(env.DB, 'meta', eventName, 'FETCH_ERROR', err.message, eventPayload.event_id, JSON.stringify(requestBody)));
+    }
+
+    return { error: err.message };
+  }
+}