cdp-edge 1.5.0

package/templates/pagina-obrigado.md

@@ -0,0 +1,55 @@
+# Modelo: Página de Obrigado (Cloudflare Native)
+
+Este modelo é destinado à página final do funil de vendas. O foco principal é a **deduplicação inteligente** e a garantia de que o evento de conversão foi registrado corretamente no banco de dados e nas APIs.
+
+---
+
+## 🏗️ ARQUITETURA TÉCNICA (Quantum Tier)
+
+O rastreamento na página de obrigado segue dois caminhos:
+1. **Obrigado de Lead**: Disparo direto via `cdpTrack.track()` se o lead ainda não foi marcado no servidor.
+2. **Obrigado de Venda**: O evento de compra (`Purchase`) deve ser evitado se houver integração via Webhook, disparando apenas um `ViewContent` para análise de navegação.
+
+---
+
+## 🛠️ PASSO 1: CONFIGURAÇÃO DO SITE
+
+### 1.1 Obrigado de Lead (Formulário)
+```javascript
+<script>
+// Dispara apenas se o lead ainda não foi marcado no Worker
+cdpTrack.track('Lead_Success', { 
+  source: 'thank_you_page' 
+});
+</script>
+```
+
+### 1.2 Obrigado de Venda (Purchase)
+> [!IMPORTANT]
+> Caso utilize **Webhooks (Ticto/Hotmart/Kiwify)**, a página de obrigado **NÃO** deve disparar o evento `Purchase`. O Worker fará o envio via servidor para evitar duplicidade e garantir 100% de atribuição.
+
+```javascript
+<script>
+// Dispara evento de visualização para análise de funil
+cdpTrack.track('ViewContent', { 
+  content_name: 'Success_Page',
+  content_category: 'Sales'
+});
+</script>
+```
+
+---
+
+## 🖥️ PASSO 2: SERVIDOR (CLOUDFLARE WORKER)
+
+O Worker realiza a verificação de duplicidade:
+- **D1 Cross-Check**: Verifica se o `transaction_id` já existe no banco antes de enviar para Meta CAPI (v22.0) e TikTok (v1.3).
+- **Match Quality**: Recupera os identificadores originais do banco de dados para enriquecer o evento.
+
+---
+
+## ✅ VALIDAÇÃO TÉCNICA
+
+- **Deduplicação**: Verifique se não há disparos duplos de `Purchase` (um pelo site e outro pelo webhook).
+- **Persistência**: O evento de sucesso deve estar registrado no log de eventos do D1.
+- **Match Quality**: Conferir se os dados de atribuição (`fbp`, `fbc`) estão sendo enviados corretamente nas chamadas de servidor.

package/templates/pinterest/conversions-api-template.js

@@ -0,0 +1,144 @@
+/**
+ * Pinterest Conversions API Server Template — CDP Edge Quantum Tier
+ *
+ * Este template contém a função de envio para a Conversions API do Pinterest
+ * Uso: Incluir no worker.js gerado pelo Server Tracking Agent
+ */
+
+/**
+ * Função principal de envio para Pinterest Conversions API
+ * @param {Object} env - Variáveis de ambiente do Cloudflare Worker
+ * @param {Object} eventData - Dados do evento a ser enviado
+ * @returns {Promise<Object>} - Resposta da API
+ */
+export async function sendPinterestApi(env, eventData) {
+  const {
+    email, phone, userId, clientIp, userAgent, pageUrl,
+    eventId, value, currency, orderId, productName, productId
+  } = eventData;
+
+  // Verificar se as credenciais estão configuradas
+  if (!env.PINTEREST_ACCESS_TOKEN || !env.PINTEREST_AD_ACCOUNT_ID) {
+    console.warn('Pinterest Conversions API: Credenciais não configuradas');
+    return { success: false, error: 'MISSING_CREDENTIALS' };
+  }
+
+  // Função de hash SHA-256
+  async function sha256(str) {
+    if (!str) return undefined;
+    const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(str.toLowerCase().trim()));
+    return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+  }
+
+  // Normalizar evento — Pinterest usa nomes específicos
+  const pinterestEventMap = {
+    'PageView':          'pagevisit',
+    'Lead':              'lead',
+    'Purchase':          'checkout',
+    'AddToCart':         'addtocart',
+    'InitiateCheckout':  'checkout',
+    'ViewContent':       'pagevisit',
+    'CompleteRegistration': 'signup',
+    'Search':            'search',
+  };
+  const pinterestEvent = pinterestEventMap[eventName] || 'custom';
+
+  // User data com hashing
+  const userData = {};
+  if (email)    userData.em  = [await sha256(email)];
+  if (phone)    userData.ph  = [await sha256(phone.replace(/\D/g, ''))];
+  if (userId)   userData.external_id = [await sha256(userId)];
+  if (clientIp) userData.client_ip_address = clientIp;   // sem hash
+  if (userAgent) userData.client_user_agent = userAgent;  // sem hash
+
+  // Payload da Conversions API
+  const payload = {
+    data: [{
+      event_name:    pinterestEvent,
+      action_source: 'web',
+      event_time:    Math.floor(Date.now() / 1000),
+      event_id:      eventId,    // deduplicação com browser tag
+      event_source_url: pageUrl || '',
+      user_data:     userData,
+      custom_data: {
+        currency:  currency || 'BRL',
+        value:     value ? String(value) : '0',
+        order_id:  orderId  || undefined,
+        content_ids:    productId ? [productId] : undefined,
+        content_name:   productName || undefined,
+        content_type:   'product',
+      },
+      // Para lead: adicionar lead_type
+      ...(eventName === 'Lead' ? { custom_data: { ...{}, lead_type: 'Newsletter' } } : {}),
+    }],
+  };
+
+  try {
+    const resp = await fetch(
+      `https://api.pinterest.com/v5/ad_accounts/${env.PINTEREST_AD_ACCOUNT_ID}/events`,
+      {
+        method:  'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${env.PINTEREST_ACCESS_TOKEN}`,
+        },
+        body: JSON.stringify(payload),
+      }
+    );
+
+    const result = await resp.json();
+
+    // Resposta de sucesso: { num_events_received: 1, num_events_processed: 1 }
+    if (result.num_events_received === 1 && result.num_events_processed === 1) {
+      return { success: true, result };
+    } else {
+      return { success: false, error: 'API_ERROR', result };
+    }
+
+  } catch (error) {
+    console.error('Pinterest Conversions API Error:', error);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Função de Enhanced Match — re-inicializa o pixel com dados hasheados
+ * @param {string} email - Email do usuário (opcional)
+ * @param {string} phone - Telefone do usuário (opcional)
+ */
+export async function reinitPinterestWithEnhancedMatch(email, phone) {
+  if (!email && !phone) return;
+
+  const hashedEmail = email ? await sha256Email(email) : '';
+  const hashedPhone = phone ? await sha256Phone(phone.replace(/\D/g, '')) : '';
+
+  // Re-load com dados hasheados para Enhanced Match
+  if (typeof pintrk !== 'undefined') {
+    pintrk('load', '{PINTEREST_TAG_ID}', {
+      em: hashedEmail,
+      ph: hashedPhone
+    });
+  }
+}
+
+/**
+ * Funções de hash para Enhanced Match no browser
+ */
+export async function sha256Email(str) {
+  if (!str) return '';
+  const normalized = str.toLowerCase().trim();
+  const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(normalized));
+  return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
+export async function sha256Phone(str) {
+  if (!str) return '';
+  const normalized = str.replace(/\D/g, '').toLowerCase().trim();
+  const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(normalized));
+  return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
+export default {
+  sendPinterestApi,
+  reinitPinterestWithEnhancedMatch
+};

package/templates/pinterest/event-mappings.json

@@ -0,0 +1,48 @@
+{
+  "platform": "pinterest",
+  "version": "v5",
+  "event_mappings": {
+    "pixel_to_native": {
+      "PageView": "pagevisit",
+      "Lead": "lead",
+      "Purchase": "checkout",
+      "AddToCart": "addtocart",
+      "InitiateCheckout": "checkout",
+      "ViewContent": "pagevisit",
+      "CompleteRegistration": "signup",
+      "Search": "search"
+    },
+    "native_names": {
+      "pagevisit": "Visualização de página",
+      "lead": "Formulário de lead",
+      "checkout": "Compra confirmada",
+      "addtocart": "Adicionar ao carrinho",
+      "signup": "Cadastro",
+      "search": "Busca"
+    }
+  },
+  "required_parameters": {
+    "pagevisit": ["line_items"],
+    "lead": ["lead_type"],
+    "addtocart": ["value", "currency", "line_items"],
+    "checkout": ["value", "currency", "order_id", "line_items"],
+    "signup": ["lead_type"],
+    "search": ["search_query"],
+    "watchvideo": []
+  },
+  "optional_parameters": {
+    "pagevisit": ["custom_data"],
+    "lead": ["custom_data"],
+    "addtocart": ["custom_data"],
+    "checkout": ["custom_data"],
+    "signup": ["custom_data"],
+    "search": ["custom_data"]
+  },
+  "enhanced_match_fields": {
+    "email": "em",
+    "phone": "ph",
+    "external_id": "external_id",
+    "client_ip_address": "client_ip_address",
+    "client_user_agent": "client_user_agent"
+  }
+}

package/templates/pinterest/tag-template.js

@@ -0,0 +1,28 @@
+/**
+ * Pinterest Pixel Browser Template — CDP Edge Quantum Tier
+ *
+ * Este template contém o código de inicialização do Pinterest Pixel
+ * Uso: Incluir no tracking.js gerado pelo Browser Tracking Agent
+ */
+
+export const PINTEREST_TAG_TEMPLATE = `
+<!-- Pinterest Pixel Base Code -->
+<script>
+  !function(e){if(!window.pintrk){window.pintrk=function(){
+  window.pintrk.queue.push(Array.prototype.slice.call(arguments))};
+  var n=window.pintrk;n.queue=[],n.version="3.0";
+  var t=document.createElement("script");
+  t.async=!0,t.src=e;
+  var r=document.getElementsByTagName("script")[0];
+  r.parentNode.insertBefore(t,r)}}("https://s.pinimg.com/ct/core.js");
+
+  pintrk('load', '{PINTEREST_TAG_ID}', {
+    em: '<user_email_if_known>'  // Enhanced Match — enviar email quando disponível
+  });
+  pintrk('page');
+</script>
+<noscript>
+  <img height="1" width="1" style="display:none;"
+    src="https://ct.pinterest.com/v3/?event=init&tid={PINTEREST_TAG_ID}&pd[em]=<hashed_email>&noscript=1" />
+</noscript>
+`;

package/templates/quiz-funnel.md

@@ -0,0 +1,68 @@
+# Modelo: Quiz Funnel (Cloudflare Native)
+
+Este modelo é destinado a funis de quiz, onde o usuário responde a uma série de perguntas antes de ser redirecionado para a oferta final. O rastreamento foca na progressão do usuário e na captura de dados intermediários.
+
+---
+
+## 🏗️ ARQUITETURA TÉCNICA (Quantum Tier)
+
+O rastreamento segue a lógica de micro-eventos:
+1. **Página**: Dispara um evento a cada resposta dada no quiz via `cdpTrack.track()`.
+2. **Servidor (Worker)**: Recebe e armazena o progresso no banco D1.
+3. **Database (D1)**: Mantém o histórico de respostas vinculado ao `track_user_id`.
+
+---
+
+## 📘 EVENTOS PRINCIPAIS
+
+| Evento | Gatilho | Dados Enviados |
+|---|---|---|
+| **QuizStart** | Início do quiz | `quiz_name`, `source` |
+| **QuizAnswer** | Resposta a uma pergunta | `question`, `answer`, `step` |
+| **QuizComplete** | Finalização do quiz | `result`, `completion_time` |
+
+---
+
+## 🛠️ PASSO 1: CONFIGURAÇÃO DO SITE
+
+### 1.1 Rastreamento de Respostas
+Integre este código na lógica de clique do seu quiz.
+
+```javascript
+// Exemplo de captura de resposta
+function onResponder(pergunta, resposta, etapa) {
+  cdpTrack.track('QuizAnswer', {
+    question: pergunta,
+    answer: resposta,
+    step: etapa,
+    event_id: cdpTrack.generateId()
+  });
+}
+```
+
+### 1.2 Finalização do Quiz
+Disparar ao chegar no resultado final ou na página de captura pós-quiz.
+
+```javascript
+cdpTrack.track('QuizComplete', {
+  result: 'Perfil_A',
+  event_id: cdpTrack.generateId()
+});
+```
+
+---
+
+## ⚡ PASSO 2: SERVIDOR (CLOUDFLARE WORKER)
+
+O Worker realiza:
+- **Agregação**: O `user_id` permite que todas as respostas sejam vinculadas a um único perfil no banco D1.
+- **Enriquecimento**: Se o usuário deixar o e-mail no final, todas as respostas anteriores são associadas ao e-mail para a CAPI.
+- **API Dispatch**: Envio de eventos customizados para Meta e TikTok para otimização de público.
+
+---
+
+## ✅ VALIDAÇÃO TÉCNICA
+
+- **Persistência**: Verifique no banco D1 se a jornada do usuário está sendo gravada passo a passo.
+- **Deduplicação**: O `event_id` único por resposta evita contagens duplicadas.
+- **Match Quality**: A vinculação tardia do e-mail com as respostas iniciais aumenta a precisão da atribuição.

package/templates/reddit/conversions-api-template.js

@@ -0,0 +1,205 @@
+/**
+ * Reddit Conversions API Server Template — CDP Edge Quantum Tier
+ *
+ * Este template contém a função de envio para a Conversions API do Reddit
+ * Uso: Incluir no worker.js gerado pelo Server Tracking Agent
+ */
+
+/**
+ * Função principal de envio para Reddit Conversions API
+ * @param {Object} env - Variáveis de ambiente do Cloudflare Worker
+ * @param {Object} eventData - Dados do evento a ser enviado
+ * @returns {Promise<Object>} - Resposta da API
+ */
+export async function sendRedditApi(env, eventData) {
+  const { email, phone, userId, clientIp, userAgent, pageUrl,
+          eventId, value, currency, itemCount, transactionId } = eventData;
+
+  // Verificar se as credenciais estão configuradas
+  if (!env.REDDIT_ACCESS_TOKEN || !env.REDDIT_AD_ACCOUNT_ID) {
+    console.warn('Reddit Conversions API: Credenciais não configuradas');
+    return { success: false, error: 'MISSING_CREDENTIALS' };
+  }
+
+  // Função de hash SHA-256
+  async function sha256(str) {
+    if (!str) return undefined;
+    const buf = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(str.toLowerCase().trim()));
+    return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2,'0')).join('');
+  }
+
+  // Mapeamento de eventos CDP Edge → Reddit
+  const redditEventMap = {
+    'PageView':             'PageVisit',
+    'ViewContent':          'ViewContent',
+    'Lead':                 'Lead',
+    'Purchase':             'Purchase',
+    'AddToCart':            'AddToCart',
+    'CompleteRegistration': 'SignUp',
+    'Search':               'Search',
+    'InitiateCheckout':     'Purchase',     // com conversionType BEGIN_CHECKOUT
+  };
+  const redditEvent = redditEventMap[eventName] || 'Custom';
+
+  // user object com SHA256
+  const user = {};
+  if (email)  user.email         = { value: await sha256(email) };
+  if (phone)  user.phoneNumber  = { value: await sha256(phone.replace(/\D/g,'')) };
+  if (userId) user.externalId   = { value: await sha256(userId) };
+  if (clientIp)  user.ipAddress = { value: clientIp };   // sem hash
+  if (userAgent) user.userAgent = { value: userAgent };  // sem hash
+
+  const event = {
+    event_at:      new Date().toISOString(),
+    event_type:    { tracking_type: redditEvent },
+    click_id:      '', // Reddit click ID (rdt_cid) — se disponível da URL
+    event_metadata: {
+      currency:       currency || 'BRL',
+      value_decimal:  String(value || 0),  // string com decimal
+      item_count:     String(itemCount || 1),
+      transaction_id: transactionId || eventId,
+      conversion_id:  eventId,             // deduplicação
+    },
+    user,
+  };
+
+  // Adicionar conversionType para InitiateCheckout
+  if (eventName === 'InitiateCheckout') {
+    event.event_type.conversion_type = 'BEGIN_CHECKOUT';
+  }
+
+  const payload = { events: [event] };
+
+  try {
+    const resp = await fetch(
+      `https://ads-api.reddit.com/api/v2.0/conversions/events/${env.REDDIT_AD_ACCOUNT_ID}`,
+      {
+        method:  'POST',
+        headers: {
+          'Content-Type':  'application/json',
+          'Authorization': `Bearer ${env.REDDIT_ACCESS_TOKEN}`,
+        },
+        body: JSON.stringify(payload),
+      }
+    );
+
+    // Resposta de sucesso: { status: 200, message: "Success" }
+    if (resp.ok) {
+      const result = await resp.json();
+      return { success: true, result };
+    } else {
+      return { success: false, error: `HTTP ${resp.status}` };
+    }
+
+  } catch (error) {
+    console.error('Reddit Conversions API Error:', error);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Função de Advanced Matching — re-inicializa o pixel com dados hasheados
+ * @param {Object} userData - Dados do usuário (email, phone, externalId)
+ */
+export function reinitRedditWithUserData(userData) {
+  const matchData = {};
+  if (userData.email)     matchData.email       = userData.email;     // pixel faz hash
+  if (userData.phone)     matchData.phoneNumber = userData.phone;     // pixel faz hash
+  if (userData.externalId) matchData.externalId = userData.externalId;
+
+  rdt('init', '{REDDIT_PIXEL_ID}', matchData);
+}
+
+/**
+ * Funções de tracking de eventos (browser + server)
+ * Uso: Chamadas do tracking.js para eventos Reddit
+ */
+
+/**
+ * Track de Lead
+ * @param {Object} data - Dados do formulário
+ */
+export async function trackRedditLead(data = {}) {
+  const eventId = generateEventId(); // reutilizar a função do tracking.js
+
+  // Browser: Reddit Pixel
+  if (typeof rdt !== 'undefined') {
+    if (data.email || data.phone) reinitRedditWithUserData(data);
+    rdt('track', 'Lead', { transactionId: eventId });
+  }
+
+  // Servidor: Conversions API
+  await sendToServer('Lead', { ...data, eventId, redditEventId: eventId });
+}
+
+/**
+ * Track de Purchase
+ * @param {Object} data - Dados da compra
+ */
+export async function trackRedditPurchase(data = {}) {
+  const eventId = generateEventId();
+
+  if (typeof rdt !== 'undefined')
+    rdt('track', 'Purchase', {
+      value:         data.value || 0,
+      currency:      data.currency || 'BRL',
+      itemCount:     data.itemCount ||1,
+      transactionId: data.transactionId || eventId,
+    });
+
+  await sendToServer('Purchase', { ...data, eventId, redditEventId: eventId });
+}
+
+/**
+ * Track de InitiateCheckout
+ * @param {Object} data - Dados do checkout iniciado
+ */
+export async function trackRedditInitiateCheckout(data = {}) {
+  const eventId = generateEventId();
+
+  if (typeof rdt !== 'undefined')
+    rdt('track', 'Purchase', {
+      conversionType: 'BEGIN_CHECKOUT',
+      value:    data.value || 0,
+      currency: data.currency || 'BRL',
+      transactionId: eventId,
+    });
+
+  await sendToServer('InitiateCheckout', { ...data, eventId });
+}
+
+/**
+ * Gerador de Event ID único
+ * Reutiliza a função do tracking.js ou gera novo
+ */
+function generateEventId() {
+  return crypto.randomUUID ? crypto.randomUUID() :
+    Date.now().toString(36) + Math.random().toString(36).slice(2);
+}
+
+/**
+ * Enviar dados para servidor via fetch
+ * @param {string} eventName - Nome do evento
+ * @param {Object} data - Dados completos do evento
+ */
+async function sendToServer(eventName, data) {
+  const serverUrl = '/api/track'; // ou URL configurada
+
+  await fetch(serverUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      event_name: eventName,
+      platform: 'reddit',
+      ...data
+    })
+  });
+}
+
+export default {
+  sendRedditApi,
+  reinitRedditWithUserData,
+  trackRedditLead,
+  trackRedditPurchase,
+  trackRedditInitiateCheckout
+};

package/templates/reddit/event-mappings.json

@@ -0,0 +1,56 @@
+{
+  "platform": "reddit",
+  "version": "v2.0",
+  "event_mappings": {
+    "pixel_to_native": {
+      "PageView":             "PageVisit",
+      "ViewContent":          "ViewContent",
+      "Lead":                 "Lead",
+      "Purchase":             "Purchase",
+      "AddToCart":            "AddToCart",
+      "AddToWishlist":        "AddToWishlist",
+      "InitiateCheckout":      "Purchase", // com conversionType: BEGIN_CHECKOUT
+      "CompleteRegistration": "SignUp",
+      "Search":               "Search"
+    },
+    "native_names": {
+      "PageVisit": "Visualização de página",
+      "ViewContent": "Visualizar produto/conteúdo",
+      "Lead": "Formulário de lead",
+      "Purchase": "Compra confirmada",
+      "AddToCart": "Adicionar ao carrinho",
+      "AddToWishlist": "Adicionar à lista de desejos",
+      "SignUp": "Cadastro",
+      "Search": "Busca"
+    }
+  },
+  "required_parameters": {
+    "PageVisit": [],
+    "ViewContent": ["value", "currency", "itemCount"],
+    "Lead": [],
+    "Purchase": ["value", "currency", "itemCount", "transactionId"],
+    "AddToCart": ["value", "currency", "itemCount"],
+    "AddToWishlist": ["value", "currency", "itemCount"],
+    "InitiateCheckout": ["value", "currency"],
+    "SignUp": [],
+    "Search": []
+  },
+  "optional_parameters": {
+    "PageVisit": [],
+    "ViewContent": ["customData"],
+    "Lead": ["customData"],
+    "Purchase": ["customData"],
+    "AddToCart": ["customData"],
+    "AddToWishlist": ["customData"],
+    "InitiateCheckout": ["customData"],
+    "SignUp": ["customData"],
+    "Search": ["customData"]
+  },
+  "advanced_matching_fields": {
+    "email": "email",
+    "phoneNumber": "phoneNumber",
+    "externalId": "externalId",
+    "ipAddress": "ipAddress",
+    "userAgent": "userAgent"
+  }
+}

package/templates/reddit/pixel-template.js

@@ -0,0 +1,19 @@
+/**
+ * Reddit Pixel Browser Template — CDP Edge Quantum Tier
+ *
+ * Este template contém o código de inicialização do Reddit Pixel
+ * Uso: Incluir no tracking.js gerado pelo Browser Tracking Agent
+ */
+
+export const REDDIT_PIXEL_TEMPLATE = `
+<!-- Reddit Pixel Base Code -->
+<script>
+!function(w,d){if(!w.rdt){var p=w.rdt=function(){p.sendEvent?p.sendEvent.apply(p,arguments):p.callQueue.push(arguments);p.callQueue=[];var t=d.createElement('script');t.src='https://www.redditstatic.com/ads/v2.js',t.async=!0;var s=d.getElementsByTagName('script')[0];s.parentNode.insertBefore(t,s)}}(window,document);
+rdt('init', '{REDDIT_PIXEL_ID}', {
+  optOut:      false,
+  useDecimalCurrencyValues: true,
+  email:       '', // preencher após captura (hashed automaticamente pelo pixel)
+});
+rdt('track', 'PageVisit');
+</script>
+`;