cdp-edge 2.2.4 → 2.3.0

package/server-edge-tracker/modules/{db.js → db.ts}

@@ -5,9 +5,49 @@
  */
 
 import { sha256, normalizePhone, normalizeCity } from './utils.js';
+import { Env, TrackPayload } from '../types.js';
+import { D1Database } from '@cloudflare/workers-types';
+
+// ── Tipos ───────────────────────────────────────────────────────────────────────
+export interface GeoData {
+  country: string | null;
+  continent: string | null;
+  asn: string | null;
+  asOrg: string | null;
+  colo: string | null;
+  city: string | null;
+  region: string | null;
+  regionCode: string | null;
+  postalCode: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  timezone: string | null;
+  metroCode: string | null;
+}
+
+export interface LtvResult {
+  value: number;
+  class: string;
+  score?: number;
+}
+
+export interface HealthMetrics {
+  platform: string;
+  hours: number;
+  events_sent: number;
+  events_failed: number;
+  success_rate: number;
+  errors_detected: Array<{ code: string; count: number }>;
+  issues: string[];
+}
+
+export interface DailyReport {
+  platform: string;
+  status: string;
+}
 
 // ── saveLead — inserir evento de conversão ────────────────────────────────────
-export async function saveLead(env, eventName, payload, request, platform = 'website') {
+export async function saveLead(env: Env, eventName: string, payload: TrackPayload, request: Request, platform: string = 'website'): Promise<void> {
   if (!env.DB) return;
   try {
     const {
@@ -36,7 +76,7 @@ export async function saveLead(env, eventName, payload, request, platform = 'web
       lastName      || null,
       city          || null,
       state         || null,
-      (country      || request.cf?.country || null),
+      (country      || (request as any).cf?.country || null),
       fbp           || null,
       fbc           || null,
       userId        || null,
@@ -46,22 +86,22 @@ export async function saveLead(env, eventName, payload, request, platform = 'web
       utmContent    || null,
       utmTerm       || null,
       pageUrl       || null,
-      value !== undefined ? parseFloat(value) : null,
+      value !== undefined ? parseFloat(String(value)) : null,
       currency      || 'BRL',
       request.headers.get('CF-Connecting-IP') || null,
       platform,
       botScore      || 0,
-      engagementScore !== undefined ? parseFloat(engagementScore) : null,
+      engagementScore !== undefined ? parseFloat(String(engagementScore)) : null,
       intentionLevel || null,
       utmRestored ? 1 : 0,
     ).run();
-  } catch (err) {
-    console.error('D1 saveLead error:', err.message);
+  } catch (err: any) {
+    console.error('D1 saveLead error:', err?.message || String(err));
   }
 }
 
 // ── calculateCohortLabel ──────────────────────────────────────────────────────
-export function calculateCohortLabel(score, eventName) {
+export function calculateCohortLabel(score: number, eventName: string): string {
   if (eventName === 'Purchase') return 'buyer_lookalike';
   if (score >= 80)  return 'high_intent';
   if (score >= 30)  return 'nurture';
@@ -69,7 +109,7 @@ export function calculateCohortLabel(score, eventName) {
 }
 
 // ── upsertProfile — acumula cookies/scores entre visitas ─────────────────────
-export async function upsertProfile(env, eventName, payload, request) {
+export async function upsertProfile(env: Env, eventName: string, payload: TrackPayload, request: Request): Promise<void> {
   if (!env.DB || !payload.userId) return;
   try {
     const {
@@ -79,7 +119,7 @@ export async function upsertProfile(env, eventName, payload, request) {
       engagementScore, userScore,
     } = payload;
 
-    const scoreMap = { PageView: 5, ViewContent: 10, ScrollDepth: 3, TimeOnPage: 5, Lead: 30, InitiateCheckout: 50, Purchase: 100 };
+    const scoreMap: Record<string, number> = { PageView: 5, ViewContent: 10, ScrollDepth: 3, TimeOnPage: 5, Lead: 30, InitiateCheckout: 50, Purchase: 100 };
     const eventScore = scoreMap[eventName] || 2;
 
     const behaviorBonus = userScore
@@ -120,23 +160,23 @@ export async function upsertProfile(env, eventName, payload, request) {
       gaClientId         || null,
       city               || null,
       state              || null,
-      (country           || request.cf?.country || null),
+      (country           || (request as any).cf?.country || null),
       totalDelta,
       calculateCohortLabel(totalDelta, eventName),
     ).run();
-  } catch (err) {
-    console.error('D1 upsertProfile error:', err.message);
+  } catch (err: any) {
+    console.error('D1 upsertProfile error:', err?.message || String(err));
   }
 }
 
 // ── resolveDeviceGraph — Cross-Device Identity ────────────────────────────────
-export async function resolveDeviceGraph(DB, currentUserId, email, phone) {
+export async function resolveDeviceGraph(DB: D1Database, currentUserId: string, email?: string | null, phone?: string | null): Promise<void> {
   if (!DB || !currentUserId) return;
   if (!email && !phone) return;
 
   try {
-    const conditions = [];
-    const bindings   = [];
+    const conditions: string[] = [];
+    const bindings: (string | number)[]   = [];
 
     if (email) {
       conditions.push('email = ?');
@@ -166,7 +206,7 @@ export async function resolveDeviceGraph(DB, currentUserId, email, phone) {
 
     for (const match of rows.results) {
       const emailMatch = email && match.email &&
-        email.toLowerCase().trim() === match.email.toLowerCase().trim();
+        email.toLowerCase().trim() === (match.email as string).toLowerCase().trim();
       const phoneMatch = phone && match.phone && (() => {
         const a = String(phone).replace(/\D/g, '');
         const b = String(match.phone).replace(/\D/g, '');
@@ -177,7 +217,7 @@ export async function resolveDeviceGraph(DB, currentUserId, email, phone) {
 
       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 primary   = match.user_id as string;
       const secondary = currentUserId;
 
       await DB.prepare(`
@@ -188,13 +228,13 @@ export async function resolveDeviceGraph(DB, currentUserId, email, phone) {
 
       console.log(`[DeviceGraph] Linked ${secondary} → ${primary} via ${matchType} (confidence: ${matchConfidence})`);
     }
-  } catch (err) {
-    console.error('resolveDeviceGraph error:', err.message);
+  } catch (err: any) {
+    console.error('resolveDeviceGraph error:', err?.message || String(err));
   }
 }
 
 // ── fireAutomation — dispara regras de automação (WA/Email) ──────────────────
-export async function fireAutomation(env, eventName, leadId, payload) {
+export async function fireAutomation(env: Env, eventName: string, leadId: number | null, payload: TrackPayload): Promise<void> {
   if (!env.DB) return;
 
   try {
@@ -209,20 +249,20 @@ export async function fireAutomation(env, eventName, leadId, payload) {
 
     if (!rules || rules.length === 0) return;
 
-    const vars = {
-      name:      String(payload.firstName || payload.name || ''),
+    const vars: Record<string, string> = {
+      name:      String(payload.firstName || (payload as any).name || ''),
       email:     String(payload.email     || ''),
       phone:     String(payload.phone     || ''),
-      campaign:  String(payload.utm_campaign || payload.utmCampaign || ''),
+      campaign:  String(payload.utmCampaign || payload.utm_campaign || ''),
       intention: String(payload.intentionLevel || payload.intention_level || ''),
     };
 
-    const interpolate = (tpl) =>
+    const interpolate = (tpl: string) =>
       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;
+      const message = interpolate(rule.message_template as string);
+      const subject = rule.subject_template ? interpolate(rule.subject_template as string) : null;
 
       try {
         if (rule.channel === 'whatsapp' && payload.phone && env.WHATSAPP_ACCESS_TOKEN && env.WHATSAPP_PHONE_NUMBER_ID) {
@@ -238,7 +278,7 @@ export async function fireAutomation(env, eventName, leadId, payload) {
           );
           const waData  = await waRes.json();
           const status  = waRes.ok ? 'sent' : 'failed';
-          const meta    = waRes.ok ? (waData.messages?.[0]?.id ?? null) : JSON.stringify(waData);
+          const meta    = waRes.ok ? ((waData as any).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();
@@ -256,22 +296,22 @@ export async function fireAutomation(env, eventName, leadId, payload) {
           });
           const resendData = await resendRes.json();
           const status     = resendRes.ok ? 'sent' : 'failed';
-          const meta       = resendRes.ok ? (resendData.id ?? null) : JSON.stringify(resendData);
+          const meta       = resendRes.ok ? ((resendData as any).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: any) {
+        console.error(`[Automation] rule ${(rule as any).id} error:`, err?.message || String(err));
       }
     }
-  } catch (err) {
-    console.error('[Automation] fireAutomation error:', err.message);
+  } catch (err: any) {
+    console.error('[Automation] fireAutomation error:', err?.message || String(err));
   }
 }
 
 // ── getProfileByEmail ─────────────────────────────────────────────────────────
-export async function getProfileByEmail(env, email) {
+export async function getProfileByEmail(env: Env, email: string): Promise<any | null> {
   if (!env.DB || !email) return null;
   try {
     return await env.DB.prepare(
@@ -283,14 +323,14 @@ export async function getProfileByEmail(env, email) {
 }
 
 // ── enrichGeoFromEdge — enriquece payload com dados de geolocalização ─────────
-export async function enrichGeoFromEdge(request, env, payload) {
-  const cf = request.cf || {};
+export async function enrichGeoFromEdge(request: Request, env: Env, payload: TrackPayload): Promise<GeoData> {
+  const cf = (request as any).cf || {};
   const ip = request.headers.get('CF-Connecting-IP') || '';
 
-  let geoData = null;
+  let geoData: GeoData | null = null;
   if (env.GEO_CACHE && ip) {
     try {
-      const cached = await env.GEO_CACHE.get(`geo:${ip}`, 'json');
+      const cached = await env.GEO_CACHE.get(`geo:${ip}`, 'json') as GeoData | null;
       if (cached) geoData = cached;
     } catch {}
   }
@@ -323,13 +363,13 @@ export async function enrichGeoFromEdge(request, env, payload) {
   payload.city    = payload.city    || geoData.city;
   payload.state   = payload.state   || geoData.regionCode;
   payload.zip     = payload.zip     || geoData.postalCode;
-  payload.geo     = geoData;
+  (payload as any).geo     = geoData;
 
   return geoData;
 }
 
 // ── writeAuditLog — grava evento no R2 ───────────────────────────────────────
-export async function writeAuditLog(env, eventName, payload, geoData) {
+export async function writeAuditLog(env: Env, eventName: string, payload: TrackPayload, geoData: GeoData | null): Promise<void> {
   if (!env.AUDIT_LOGS) return;
   try {
     const now = new Date();
@@ -360,14 +400,14 @@ export async function writeAuditLog(env, eventName, payload, geoData) {
     await env.AUDIT_LOGS.put(key, JSON.stringify(log), {
       httpMetadata: { contentType: 'application/json' },
     });
-  } catch (err) {
-    console.error('[R2 Audit] Error:', err.message);
+  } catch (err: any) {
+    console.error('[R2 Audit] Error:', err?.message || String(err));
   }
 }
 
 // ── generateEdgeFingerprint ───────────────────────────────────────────────────
-export async function generateEdgeFingerprint(request) {
-  const asn  = String(request.cf?.asn || '0');
+export async function generateEdgeFingerprint(request: Request): Promise<string | undefined> {
+  const asn  = String((request as any).cf?.asn || '0');
   const lang = (request.headers.get('Accept-Language') || 'unknown').split(',')[0].trim();
   const ua   = request.headers.get('User-Agent') || '';
 
@@ -386,7 +426,7 @@ export async function generateEdgeFingerprint(request) {
 }
 
 // ── saveEdgeFingerprint ───────────────────────────────────────────────────────
-export async function saveEdgeFingerprint(DB, fingerprint, userId, payload) {
+export async function saveEdgeFingerprint(DB: D1Database, fingerprint: string | undefined, userId: string | undefined, payload: TrackPayload): Promise<void> {
   if (!DB || !fingerprint) return;
   const { utmSource, utmMedium, utmCampaign, utmContent, utmTerm } = payload;
   if (!utmSource) return;
@@ -404,13 +444,13 @@ export async function saveEdgeFingerprint(DB, fingerprint, userId, payload) {
       utmContent  || null,
       utmTerm     || null,
     ).run();
-  } catch (err) {
-    console.error('saveEdgeFingerprint error:', err.message);
+  } catch (err: any) {
+    console.error('saveEdgeFingerprint error:', err?.message || String(err));
   }
 }
 
 // ── resurrectUTM ──────────────────────────────────────────────────────────────
-export async function resurrectUTM(DB, fingerprint) {
+export async function resurrectUTM(DB: D1Database, fingerprint: string | undefined): Promise<any | null> {
   if (!DB || !fingerprint) return null;
   try {
     return await DB.prepare(`
@@ -428,7 +468,7 @@ export async function resurrectUTM(DB, fingerprint) {
 }
 
 // ── upsertLtvProfile — persiste LTV no perfil ────────────────────────────────
-export async function upsertLtvProfile(env, userId, ltv) {
+export async function upsertLtvProfile(env: Env, userId: string, ltv: LtvResult): Promise<void> {
   if (!env.DB || !userId) return;
   try {
     await env.DB.prepare(`
@@ -438,15 +478,15 @@ export async function upsertLtvProfile(env, userId, ltv) {
           updated_at          = datetime('now')
       WHERE user_id = ?
     `).bind(ltv.class, ltv.value, userId).run();
-  } catch (err) {
-    console.error('upsertLtvProfile error:', err.message);
+  } catch (err: any) {
+    console.error('upsertLtvProfile error:', err?.message || String(err));
   }
 }
 
 // ── recordLtvFeedback — fecha o ciclo preditivo com valor real de compra ─────
 // Chamado em background quando um Purchase chega com payload.value > 0.
 // Atualiza user_profiles + ltv_ab_assignments + ltv_ab_variations em cascata.
-export async function recordLtvFeedback(env, userId, realValue) {
+export async function recordLtvFeedback(env: Env, userId: string, realValue: number): Promise<void> {
   if (!env.DB || !userId || !realValue || realValue <= 0) return;
 
   try {
@@ -458,7 +498,7 @@ export async function recordLtvFeedback(env, userId, realValue) {
     // accuracy = 1 - |pred-real|/real  (0–1, mesmo padrão do A/B test accuracy_score)
     const predictedValue = profile?.predicted_ltv_value;
     const ltv_accuracy = (predictedValue !== null && predictedValue !== undefined)
-      ? Math.max(0, Math.round((1 - Math.abs(predictedValue - realValue) / Math.max(realValue, 1)) * 100) / 100)
+      ? Math.max(0, Math.round((1 - Math.abs(Number(predictedValue) - realValue) / Math.max(realValue, 1)) * 100) / 100)
       : null;
 
     // 2. Grava valor real + accuracy no perfil
@@ -491,10 +531,10 @@ export async function recordLtvFeedback(env, userId, realValue) {
           real_revenue = ?,
           converted_at = datetime('now')
       WHERE id = ?
-    `).bind(realValue, assignment.id).run();
+    `).bind(realValue, (assignment as any).id).run();
 
     // 3b. Atualiza métricas acumuladas da variação (running average — safe para concorrência D1)
-    const predLtv  = assignment.predicted_ltv || 0;
+    const predLtv  = (assignment as any).predicted_ltv || 0;
     const indivAcc = Math.max(0, 1 - Math.abs(predLtv - realValue) / Math.max(realValue, 1));
 
     await env.DB.prepare(`
@@ -507,27 +547,27 @@ export async function recordLtvFeedback(env, userId, realValue) {
             4
           )
       WHERE id = ?
-    `).bind(realValue, realValue, indivAcc, assignment.variation_id).run();
+    `).bind(realValue, realValue, indivAcc, (assignment as any).variation_id).run();
 
-  } catch (err) {
-    console.error('[LTV-Feedback] recordLtvFeedback error:', err.message);
+  } catch (err: any) {
+    console.error('[LTV-Feedback] recordLtvFeedback error:', err?.message || String(err));
   }
 }
 
 // ── Feedback Loop — Log de falhas e métricas de saúde ────────────────────────
 
-export async function logApiFailure(DB, platform, eventName, errorCode, errorMessage, eventId, rawPayload) {
+export async function logApiFailure(DB: D1Database, platform: string, eventName: string, errorCode: string | number, errorMessage: string, eventId: string, rawPayload: string): Promise<void> {
   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);
+  } catch (err: any) {
+    console.error('Failed to log API failure:', err?.message || String(err));
   }
 }
 
-export async function getHealthMetrics(DB, platform, hours = 24) {
+export async function getHealthMetrics(DB: D1Database, platform: string, hours: number = 24): Promise<HealthMetrics> {
   try {
     const failures = await DB.prepare(`
       SELECT COUNT(*) as count, error_code
@@ -542,30 +582,30 @@ export async function getHealthMetrics(DB, platform, hours = 24) {
       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
+    const totalFailed = failures.results?.reduce((sum: number, f: any) => sum + f.count, 0) || 0;
+    const successRate = (totalSent as any)?.count > 0
+      ? (((totalSent as any).count - totalFailed) / (totalSent as any).count) * 100
       : 100;
 
     return {
       platform,
       hours,
-      events_sent: totalSent?.count || 0,
+      events_sent: (totalSent as any)?.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'] : [],
+      errors_detected: (failures.results || []).map((f: any) => ({ code: f.error_code, count: f.count })),
+      issues: totalFailed > ((totalSent as any)?.count || 0) * 0.1 ? ['high_error_rate'] : [],
     };
-  } catch (err) {
-    console.error('Failed to get health metrics:', err.message);
+  } catch (err: any) {
+    console.error('Failed to get health metrics:', err?.message || String(err));
     return { platform, hours, events_sent: 0, events_failed: 0, success_rate: 0, errors_detected: [], issues: ['metrics_unavailable'] };
   }
 }
 
-export async function generateDailyReport(DB) {
+export async function generateDailyReport(DB: D1Database): Promise<DailyReport[]> {
   const platforms = ['meta', 'ga4', 'tiktok', 'pinterest', 'reddit'];
   const today = new Date().toISOString().split('T')[0];
-  const reports = [];
+  const reports: DailyReport[] = [];
 
   for (const platform of platforms) {
     const metrics = await getHealthMetrics(DB, platform, 24);
@@ -580,8 +620,8 @@ export async function generateDailyReport(DB) {
         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);
+    } catch (err: any) {
+      console.error(`Failed to generate report for ${platform}:`, err?.message || String(err));
       reports.push({ platform, status: 'failed' });
     }
   }
@@ -589,14 +629,14 @@ export async function generateDailyReport(DB) {
   return reports;
 }
 
-export async function logIntelligence(DB, runType, platform, checkType, status, currentValue, expectedValue, message, alertSent = false) {
+export async function logIntelligence(DB: D1Database, runType: string, platform: string, checkType: string, status: string, currentValue: any, expectedValue: any, message: string, alertSent: boolean = false): Promise<void> {
   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);
+  } catch (err: any) {
+    console.error('logIntelligence error:', err?.message || String(err));
   }
 }

package/server-edge-tracker/modules/dispatch/{ga4.js → ga4.ts}

@@ -5,12 +5,14 @@
 
 import { normalizePhone } from '../utils.js';
 import { logApiFailure } from '../db.js';
+import { Env, TrackPayload } from '../../types.js';
+import { ExecutionContext } from '@cloudflare/workers-types';
 
-export async function sendGA4Mp(env, ga4EventName, payload, ctx) {
+export async function sendGA4Mp(env: Env, ga4EventName: string, payload: TrackPayload, ctx: ExecutionContext | null): Promise<{ ok?: boolean; status?: number; skipped?: string; error?: string }> {
   if (!env.GA4_API_SECRET) return { skipped: 'GA4_API_SECRET not set' };
 
   const {
-    clientId, sessionId,
+    gaClientId: clientId, sessionId,
     value, currency, contentName,
     email, phone, firstName,
     orderId,
@@ -18,13 +20,13 @@ export async function sendGA4Mp(env, ga4EventName, payload, ctx) {
 
   if (!clientId) return { skipped: 'no clientId' };
 
-  const eventParams = {
-    ...(value       !== undefined && { value: parseFloat(value) }),
+  const eventParams: Record<string, string | number> = {
+    ...(value       !== undefined && { value: parseFloat(String(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) }),
+    ...(phone       && { user_data_phone_number: normalizePhone(phone) || '' }),
     ...(firstName   && { user_data_first_name: firstName.toLowerCase().trim() }),
     ...(sessionId   && { session_id: sessionId }),
     engagement_time_msec: 100,
@@ -48,18 +50,18 @@ export async function sendGA4Mp(env, ga4EventName, payload, ctx) {
 
     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)));
+        ctx.waitUntil(logApiFailure(env.DB, 'ga4', ga4EventName, String(res.status), 'GA4 returned non-204 status', '', JSON.stringify(body)));
       }
     }
 
     return res.status === 204 ? { ok: true } : { status: res.status };
-  } catch (err) {
-    console.error('GA4 MP fetch failed:', err.message);
+  } catch (err: any) {
+    console.error('GA4 MP fetch failed:', err?.message || String(err));
 
     if (env.DB && ctx) {
-      ctx.waitUntil(logApiFailure(env.DB, 'ga4', ga4EventName, 'FETCH_ERROR', err.message, null, JSON.stringify(body)));
+      ctx.waitUntil(logApiFailure(env.DB, 'ga4', ga4EventName, 'FETCH_ERROR', err?.message || String(err), '', JSON.stringify(body)));
     }
 
-    return { error: err.message };
+    return { error: err?.message || String(err) };
   }
 }

package/server-edge-tracker/modules/dispatch/{meta.js → meta.ts}

@@ -6,12 +6,19 @@
 import { sha256, normalizePhone, normalizeCity } from '../utils.js';
 import { logApiFailure } from '../db.js';
 import { logMatchQuality, autoEnrichPayload } from '../ml/matchquality.js';
+import { Env, TrackPayload } from '../../types.js';
+import { ExecutionContext } from '@cloudflare/workers-types';
 
-export async function sendMetaCapi(env, eventName, payload, request, ctx) {
+interface EnrichedPayload {
+  payload: TrackPayload;
+  recovered: { email: boolean; utm: boolean };
+}
+
+export async function sendMetaCapi(env: Env, eventName: string, payload: TrackPayload, request: Request | null, ctx: ExecutionContext | null): Promise<any> {
   // Auto-enriquecer payload com dados do Identity Graph antes do envio
   let recovered = { email: false, utm: false };
   if (env.DB && payload) {
-    const enriched  = await autoEnrichPayload(env, payload);
+    const enriched  = await autoEnrichPayload(env, payload) as EnrichedPayload;
     payload         = enriched.payload;
     recovered       = enriched.recovered;
   }
@@ -25,41 +32,41 @@ export async function sendMetaCapi(env, eventName, payload, request, ctx) {
     value, currency,
     contentIds, contentName, contentType, numItems,
     // Dual-layer context — funil avançado + imóveis
-    funnel_stage, distance_bucket, intent_score, intent_bucket,
+    funnel_stage, distanceBucket: distance_bucket, intentScoreNum: intent_score, intent_bucket,
     ltvScore, ltvClass, metaSignal, metaSignalBucket: metaSignalBucketVal,
   } = payload;
 
   const phoneNorm   = normalizePhone(phone);
-  const countryCode = (country || request.cf?.country || 'br').toLowerCase();
+  const countryCode = (country || (request as any)?.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) }),
+  const userData: Record<string, string> = {
+    ...(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_ip_address: request?.headers.get('CF-Connecting-IP')
+                    || request?.headers.get('X-Forwarded-For')
                     || '',
-    client_user_agent: request.headers.get('User-Agent') || '',
+    client_user_agent: request?.headers.get('User-Agent') || '',
   };
 
-  const customData = {
-    ...(value       !== undefined && { value: parseFloat(value) }),
+  const customData: Record<string, string | number | string[]> = {
+    ...(value       !== undefined && { value: parseFloat(String(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) }),
+    ...(numItems    && { num_items: parseInt(String(numItems)) }),
     // Contexto de funil e proximidade — enriquece matching e otimização Meta
     ...(funnel_stage    && { funnel_stage }),
     ...(distance_bucket && { distance_bucket }),
@@ -81,7 +88,7 @@ export async function sendMetaCapi(env, eventName, payload, request, ctx) {
     ...(Object.keys(customData).length > 0 && { custom_data: customData }),
   };
 
-  const requestBody = {
+  const requestBody: Record<string, any> = {
     data:         [eventPayload],
     access_token: env.META_ACCESS_TOKEN,
   };
@@ -109,8 +116,8 @@ export async function sendMetaCapi(env, eventName, payload, request, ctx) {
     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';
+      const errorCode    = (data as any).error?.code || String(res.status);
+      const errorMessage = (data as any).error?.message || (data as any).error?.error_user_msg || 'Unknown error';
       console.error('Meta CAPI error:', res.status, errorMessage);
 
       if (env.DB && ctx) {
@@ -119,13 +126,13 @@ export async function sendMetaCapi(env, eventName, payload, request, ctx) {
     }
 
     return data;
-  } catch (err) {
-    console.error('Meta CAPI fetch failed:', err.message);
+  } catch (err: any) {
+    console.error('Meta CAPI fetch failed:', err?.message || String(err));
 
     if (env.DB && ctx) {
-      ctx.waitUntil(logApiFailure(env.DB, 'meta', eventName, 'FETCH_ERROR', err.message, eventPayload.event_id, JSON.stringify(requestBody)));
+      ctx.waitUntil(logApiFailure(env.DB, 'meta', eventName, 'FETCH_ERROR', err?.message || String(err), eventPayload.event_id, JSON.stringify(requestBody)));
     }
 
-    return { error: err.message };
+    return { error: err?.message || String(err) };
   }
 }