@kubuild/core 0.5.0 → 0.6.0

package/dist/index.js

@@ -2454,6 +2454,385 @@ function createRuntimeStore(initialState) {
   return new RuntimeStateStore(initialState);
 }
 
+// src/runtime/server-tracking.ts
+function normalizeEmail(email) {
+  return (email || "").trim().toLowerCase();
+}
+function normalizePhone(phone) {
+  return (phone || "").replace(/[^0-9]/g, "");
+}
+function normalizeText(text) {
+  return (text || "").trim().toLowerCase();
+}
+async function hashSha256(value) {
+  const normalized = (value || "").trim();
+  if (!normalized) return "";
+  if (typeof globalThis.crypto?.subtle?.digest === "function") {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(normalized);
+    const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  throw new Error("Web Crypto API (crypto.subtle) is not available in current runtime environment.");
+}
+function generateTrackingEventId(prefix = "evt") {
+  const timestamp = Date.now().toString(36);
+  const randomPart = Math.random().toString(36).substring(2, 10);
+  return `${prefix}_${timestamp}_${randomPart}`;
+}
+async function sendMetaCapiEvent(event, config, options) {
+  const fetcher = options?.fetchFn || globalThis.fetch;
+  if (!config.pixelId) {
+    return {
+      provider: "meta",
+      success: false,
+      error: "Meta Pixel ID is missing"
+    };
+  }
+  const rawUserData = event.userData || {};
+  const hashedUserData = {};
+  if (rawUserData.email) {
+    hashedUserData.em = [await hashSha256(normalizeEmail(String(rawUserData.email)))];
+  }
+  if (rawUserData.phone) {
+    hashedUserData.ph = [await hashSha256(normalizePhone(String(rawUserData.phone)))];
+  }
+  if (rawUserData.firstName) {
+    hashedUserData.fn = [await hashSha256(normalizeText(String(rawUserData.firstName)))];
+  }
+  if (rawUserData.lastName) {
+    hashedUserData.ln = [await hashSha256(normalizeText(String(rawUserData.lastName)))];
+  }
+  if (rawUserData.city) {
+    hashedUserData.ct = [await hashSha256(normalizeText(String(rawUserData.city)))];
+  }
+  if (rawUserData.state) {
+    hashedUserData.st = [await hashSha256(normalizeText(String(rawUserData.state)))];
+  }
+  if (rawUserData.zip) {
+    hashedUserData.zp = [await hashSha256(normalizeText(String(rawUserData.zip)))];
+  }
+  if (rawUserData.country) {
+    hashedUserData.country = [await hashSha256(normalizeText(String(rawUserData.country)))];
+  }
+  const clientIp = rawUserData.clientIp || options?.clientIp;
+  if (clientIp) hashedUserData.client_ip_address = clientIp;
+  const clientUserAgent = rawUserData.clientUserAgent || options?.clientUserAgent;
+  if (clientUserAgent) hashedUserData.client_user_agent = clientUserAgent;
+  if (rawUserData.fbp) hashedUserData.fbp = rawUserData.fbp;
+  if (rawUserData.fbc) hashedUserData.fbc = rawUserData.fbc;
+  if (rawUserData.externalId) {
+    hashedUserData.external_id = [await hashSha256(String(rawUserData.externalId))];
+  }
+  const eventTime = event.eventTime || Math.floor(Date.now() / 1e3);
+  const eventSourceUrl = event.eventSourceUrl || options?.sourceUrl;
+  const capiPayload = {
+    data: [
+      {
+        event_name: event.eventName,
+        event_time: eventTime,
+        event_id: event.eventId,
+        event_source_url: eventSourceUrl,
+        action_source: event.actionSource || "website",
+        user_data: hashedUserData,
+        custom_data: {
+          ...event.params || {},
+          ...event.customData || {}
+        }
+      }
+    ]
+  };
+  if (config.testEventCode) {
+    capiPayload.test_event_code = config.testEventCode;
+  }
+  if (options?.simulateInDebug) {
+    options.onLog?.("[Meta CAPI SIMULATED]", capiPayload);
+    return { provider: "meta", success: true, data: { simulated: true, payload: capiPayload } };
+  }
+  try {
+    const url = `https://graph.facebook.com/v19.0/${encodeURIComponent(config.pixelId)}/events`;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (config.capiAccessToken) {
+      headers["Authorization"] = `Bearer ${config.capiAccessToken}`;
+    }
+    const res = await fetcher(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(capiPayload)
+    });
+    const resJson = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      return {
+        provider: "meta",
+        success: false,
+        status: res.status,
+        error: resJson?.error?.message || `HTTP ${res.status}`,
+        data: resJson
+      };
+    }
+    return {
+      provider: "meta",
+      success: true,
+      status: res.status,
+      data: resJson
+    };
+  } catch (err) {
+    return {
+      provider: "meta",
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function sendTikTokEventsApi(event, config, options) {
+  const fetcher = options?.fetchFn || globalThis.fetch;
+  if (!config.pixelId) {
+    return { provider: "tiktok", success: false, error: "TikTok Pixel ID is missing" };
+  }
+  const rawUserData = event.userData || {};
+  const user = {};
+  if (rawUserData.email) {
+    user.email = await hashSha256(normalizeEmail(String(rawUserData.email)));
+  }
+  if (rawUserData.phone) {
+    user.phone_number = await hashSha256(normalizePhone(String(rawUserData.phone)));
+  }
+  if (rawUserData.clientIp || options?.clientIp) {
+    user.ip = rawUserData.clientIp || options?.clientIp;
+  }
+  if (rawUserData.clientUserAgent || options?.clientUserAgent) {
+    user.user_agent = rawUserData.clientUserAgent || options?.clientUserAgent;
+  }
+  const tiktokPayload = {
+    event_source: "web",
+    event_source_id: config.pixelId,
+    data: [
+      {
+        event: event.eventName,
+        event_id: event.eventId,
+        timestamp: new Date(event.eventTime ? event.eventTime * 1e3 : Date.now()).toISOString(),
+        user,
+        properties: {
+          ...event.params || {},
+          ...event.customData || {}
+        },
+        page: {
+          url: event.eventSourceUrl || options?.sourceUrl
+        }
+      }
+    ]
+  };
+  if (config.testEventCode) {
+    tiktokPayload.test_event_code = config.testEventCode;
+  }
+  if (options?.simulateInDebug) {
+    options.onLog?.("[TikTok Events API SIMULATED]", tiktokPayload);
+    return { provider: "tiktok", success: true, data: { simulated: true, payload: tiktokPayload } };
+  }
+  try {
+    const url = "https://business-api.tiktok.com/open_api/v1.3/event/track/";
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (config.accessToken) {
+      headers["Access-Token"] = config.accessToken;
+    }
+    const res = await fetcher(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(tiktokPayload)
+    });
+    const resJson = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      return {
+        provider: "tiktok",
+        success: false,
+        status: res.status,
+        error: resJson?.message || `HTTP ${res.status}`,
+        data: resJson
+      };
+    }
+    return { provider: "tiktok", success: true, status: res.status, data: resJson };
+  } catch (err) {
+    return {
+      provider: "tiktok",
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function sendGa4MeasurementEvent(event, config, options) {
+  const fetcher = options?.fetchFn || globalThis.fetch;
+  if (!config.measurementId) {
+    return { provider: "google", success: false, error: "GA4 Measurement ID is missing" };
+  }
+  const clientId = event.userData?.clientId || event.userData?.externalId || "anonymous_client";
+  const ga4Payload = {
+    client_id: clientId,
+    events: [
+      {
+        name: event.eventName.toLowerCase().replace(/[^a-z0-9_]/g, "_"),
+        params: {
+          ...event.params || {},
+          ...event.customData || {},
+          event_id: event.eventId
+        }
+      }
+    ]
+  };
+  if (options?.simulateInDebug) {
+    options.onLog?.("[GA4 Measurement Protocol SIMULATED]", ga4Payload);
+    return { provider: "google", success: true, data: { simulated: true, payload: ga4Payload } };
+  }
+  try {
+    let url = `https://www.google-analytics.com/mp/collect?measurement_id=${encodeURIComponent(
+      config.measurementId
+    )}`;
+    if (config.measurementProtocolSecret) {
+      url += `&api_secret=${encodeURIComponent(config.measurementProtocolSecret)}`;
+    }
+    const res = await fetcher(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(ga4Payload)
+    });
+    return {
+      provider: "google",
+      success: res.ok,
+      status: res.status,
+      data: { status: res.status }
+    };
+  } catch (err) {
+    return {
+      provider: "google",
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function sendCustomWebhookEvent(event, config, options) {
+  const fetcher = options?.fetchFn || globalThis.fetch;
+  if (!config.endpointUrl) {
+    return { provider: "custom", success: false, error: "Custom Webhook URL is missing" };
+  }
+  const webhookPayload = {
+    event: event.eventName,
+    eventId: event.eventId,
+    timestamp: event.eventTime ? event.eventTime * 1e3 : Date.now(),
+    userData: event.userData,
+    params: event.params,
+    customData: event.customData,
+    sourceUrl: event.eventSourceUrl || options?.sourceUrl
+  };
+  if (options?.simulateInDebug) {
+    options.onLog?.("[Custom Webhook SIMULATED]", webhookPayload);
+    return { provider: "custom", success: true, data: { simulated: true, payload: webhookPayload } };
+  }
+  try {
+    const res = await fetcher(config.endpointUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...config.headers || {}
+      },
+      body: JSON.stringify(webhookPayload)
+    });
+    const resJson = await res.json().catch(() => ({}));
+    return {
+      provider: "custom",
+      success: res.ok,
+      status: res.status,
+      data: resJson
+    };
+  } catch (err) {
+    return {
+      provider: "custom",
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function dispatchServerTracking(event, config, options) {
+  const eventId = event.eventId || generateTrackingEventId();
+  const eventWithId = { ...event, eventId };
+  if (!config || config.enabled === false) {
+    return {
+      success: true,
+      eventId,
+      skipped: true,
+      reason: "Tracking is disabled globally",
+      results: {}
+    };
+  }
+  const isDebug = Boolean(config.debugMode);
+  const simulate = isDebug && options?.simulateInDebug !== false;
+  const mergedOptions = {
+    ...options,
+    simulateInDebug: simulate,
+    onLog: (msg, data) => {
+      if (isDebug) {
+        console.log(`[KUBUILD Tracking] ${msg}`, data || "");
+      }
+      options?.onLog?.(msg, data);
+    }
+  };
+  const providers = config.providers || {};
+  const dispatchPromises = [];
+  if (providers.meta && providers.meta.enabled !== false && providers.meta.capiEnabled) {
+    dispatchPromises.push(
+      sendMetaCapiEvent(eventWithId, providers.meta, mergedOptions).then((result) => ({
+        key: "meta",
+        result
+      }))
+    );
+  }
+  if (providers.tiktok && providers.tiktok.enabled !== false && providers.tiktok.eventsApiEnabled) {
+    dispatchPromises.push(
+      sendTikTokEventsApi(eventWithId, providers.tiktok, mergedOptions).then((result) => ({
+        key: "tiktok",
+        result
+      }))
+    );
+  }
+  if (providers.google && providers.google.enabled !== false && providers.google.measurementId && providers.google.measurementProtocolSecret) {
+    dispatchPromises.push(
+      sendGa4MeasurementEvent(eventWithId, providers.google, mergedOptions).then((result) => ({
+        key: "google",
+        result
+      }))
+    );
+  }
+  if (providers.custom && providers.custom.enabled !== false && providers.custom.endpointUrl) {
+    dispatchPromises.push(
+      sendCustomWebhookEvent(eventWithId, providers.custom, mergedOptions).then((result) => ({
+        key: "custom",
+        result
+      }))
+    );
+  }
+  const settled = await Promise.allSettled(dispatchPromises);
+  const results = {};
+  let overallSuccess = true;
+  for (const item of settled) {
+    if (item.status === "fulfilled") {
+      results[item.value.key] = item.value.result;
+      if (!item.value.result.success) {
+        overallSuccess = false;
+      }
+    } else {
+      overallSuccess = false;
+    }
+  }
+  return {
+    success: overallSuccess,
+    eventId,
+    results
+  };
+}
+
 // src/io/exporter.ts
 import { zipSync, strToU8 } from "fflate";
 import {
@@ -5642,6 +6021,7 @@ export {
   defaultIdGenerator,
   defaultMigrationRegistry,
   defaultRenameAssetStrategy,
+  dispatchServerTracking,
   duplicateNode,
   evaluateActionCondition,
   evaluateCondition,
@@ -5661,6 +6041,7 @@ export {
   findMissingComponentNodes,
   findNodeById,
   findNodeLocation,
+  generateTrackingEventId,
   getActiveArtboard,
   getAncestorChain,
   getComponentArtboards,
@@ -5670,6 +6051,7 @@ export {
   getPageArtboards,
   getParentNodeId,
   hasTemplateExpressions,
+  hashSha256,
   importPackage,
   importStoraPackage,
   insertNode,
@@ -5687,6 +6069,9 @@ export {
   loadProjectDocument,
   migrateDocument,
   moveNode,
+  normalizeEmail,
+  normalizePhone,
+  normalizeText,
   preflightPackage,
   previewImportPackage,
   remapAssetReferences,
@@ -5702,6 +6087,10 @@ export {
   sanitizeHtml,
   sanitizeUrl,
   saveDraftAsTemplate,
+  sendCustomWebhookEvent,
+  sendGa4MeasurementEvent,
+  sendMetaCapiEvent,
+  sendTikTokEventsApi,
   setActiveArtboard,
   sha256Sync,
   ungroupNodeFrame,