whale-code 6.5.10 → 6.6.0

package/dist/server/handlers/google-ads.js

@@ -17,6 +17,7 @@
  *   create_audience, list_audiences, pause, enable
  */
 
+import { createHash } from "crypto";
 import { createLogger } from "../lib/logger.js";
 const log = createLogger("google-ads");
 
@@ -356,6 +357,173 @@ async function getResource(int, resourceName) {
   return await res.json();
 }
 
+// ============================================================================
+// CUSTOMER MATCH — HASHING + UPLOAD
+// ============================================================================
+
+/** SHA-256 hash a value for Google Customer Match (lowercase + trim first). */
+function hashForCustomerMatch(value) {
+  return createHash("sha256").update(value.trim().toLowerCase()).digest("hex");
+}
+
+/** Normalize phone to E.164 format for Google Customer Match. */
+function normalizePhone(phone) {
+  const digits = phone.replace(/\D/g, "");
+  if (digits.length === 10) return `+1${digits}`;
+  if (digits.length === 11 && digits.startsWith("1")) return `+${digits}`;
+  return `+${digits}`;
+}
+
+/**
+ * Upload segment members to a Google Ads Customer Match user list.
+ * Fetches all segment members, hashes PII, and uploads via OfflineUserDataJob.
+ */
+async function uploadSegmentToGoogleAudience(sb, int, storeId, segmentId, userListResourceName) {
+  const cid = int.customerId;
+
+  // 1. Fetch all segment members
+  const {
+    data: members,
+    error: memErr
+  } = await sb.rpc("get_segment_members_for_export", {
+    p_store_id: storeId,
+    p_segment_id: segmentId
+  });
+
+  // Fallback: direct query via customer_segment_memberships → v_store_customers
+  let customerRows;
+  if (memErr || !members) {
+    const {
+      data: memberships
+    } = await sb.from("customer_segment_memberships").select("customer_id").eq("segment_id", segmentId);
+    if (!memberships || memberships.length === 0) {
+      return {
+        membersUploaded: 0,
+        jobResourceName: "",
+        status: "NO_MEMBERS"
+      };
+    }
+    const customerIds = memberships.map(m => m.customer_id);
+    // Batch fetch in chunks of 500 — use v_store_customers (joins ucr → platform_users)
+    customerRows = [];
+    for (let i = 0; i < customerIds.length; i += 500) {
+      const chunk = customerIds.slice(i, i + 500);
+      const {
+        data: customers
+      } = await sb.from("v_store_customers").select("email, phone, first_name, last_name").in("id", chunk);
+      if (customers) customerRows.push(...customers);
+    }
+  } else {
+    customerRows = members;
+  }
+  if (customerRows.length === 0) {
+    return {
+      membersUploaded: 0,
+      jobResourceName: "",
+      status: "NO_MEMBERS"
+    };
+  }
+
+  // 2. Build hashed user identifiers (one entry per identifier type)
+  const userDataOps = [];
+  for (const c of customerRows) {
+    const identifiers = [];
+    if (c.email) identifiers.push({
+      hashedEmail: hashForCustomerMatch(c.email)
+    });
+    if (c.phone) identifiers.push({
+      hashedPhoneNumber: hashForCustomerMatch(normalizePhone(c.phone))
+    });
+    if (c.first_name && c.last_name) {
+      identifiers.push({
+        addressInfo: {
+          hashedFirstName: hashForCustomerMatch(c.first_name),
+          hashedLastName: hashForCustomerMatch(c.last_name)
+        }
+      });
+    }
+
+    // Need at least email or phone
+    if (identifiers.length > 0 && identifiers.some(id => id.hashedEmail || id.hashedPhoneNumber)) {
+      userDataOps.push({
+        userIdentifiers: identifiers
+      });
+    }
+  }
+  if (userDataOps.length === 0) {
+    return {
+      membersUploaded: 0,
+      jobResourceName: "",
+      status: "NO_IDENTIFIERS"
+    };
+  }
+
+  // 3. Create OfflineUserDataJob
+  const createJobRes = await fetch(`${GOOGLE_ADS_BASE}/customers/${cid}/offlineUserDataJobs:create`, {
+    method: "POST",
+    headers: authHeaders(int),
+    body: JSON.stringify({
+      job: {
+        type: "CUSTOMER_MATCH_USER_LIST",
+        customerMatchUserListMetadata: {
+          userList: userListResourceName
+        }
+      }
+    })
+  });
+  if (!createJobRes.ok) {
+    const errBody = await createJobRes.text();
+    throw new Error(`Failed to create OfflineUserDataJob: ${parseGoogleError(errBody, createJobRes.status)}`);
+  }
+  const jobResult = await createJobRes.json();
+  const jobResourceName = jobResult.resourceName;
+
+  // 4. Add operations in batches of 1000
+  const batchSize = 1000;
+  for (let i = 0; i < userDataOps.length; i += batchSize) {
+    const batch = userDataOps.slice(i, i + batchSize);
+    const addRes = await fetch(`${GOOGLE_ADS_BASE}/${jobResourceName}:addOperations`, {
+      method: "POST",
+      headers: authHeaders(int),
+      body: JSON.stringify({
+        enablePartialFailure: true,
+        operations: batch.map(u => ({
+          create: u
+        }))
+      })
+    });
+    if (!addRes.ok) {
+      const errBody = await addRes.text();
+      log.warn({
+        batch: i / batchSize,
+        err: parseGoogleError(errBody, addRes.status)
+      }, "Partial failure adding user data");
+    }
+  }
+
+  // 5. Run the job
+  const runRes = await fetch(`${GOOGLE_ADS_BASE}/${jobResourceName}:run`, {
+    method: "POST",
+    headers: authHeaders(int),
+    body: "{}"
+  });
+  if (!runRes.ok) {
+    const errBody = await runRes.text();
+    throw new Error(`Failed to run OfflineUserDataJob: ${parseGoogleError(errBody, runRes.status)}`);
+  }
+  log.info({
+    segmentId,
+    userListResourceName,
+    members: userDataOps.length,
+    jobResourceName
+  }, "Google Customer Match upload completed");
+  return {
+    membersUploaded: userDataOps.length,
+    jobResourceName,
+    status: "RUNNING"
+  };
+}
+
 // ============================================================================
 // ID HELPERS
 // ============================================================================
@@ -1963,17 +2131,82 @@ export async function handleGoogleAds(sb, args, storeId) {
             success: false,
             error: "name required"
           };
-          const row = {
-            store_id: storeId,
-            name,
-            audience_type: args.audience_type || "CUSTOM",
-            description: args.description || null,
-            status: "DRAFT"
-          };
+          const audienceType = args.audience_type || "REMARKETING";
+          const description = args.description || null;
+          if (audienceType === "CUSTOMER_MATCH") {
+            // Create user list in Google Ads + upload segment members
+            const int = await getIntegration(sb, storeId);
+            int.accessToken = await refreshAccessToken(sb, storeId, int.refreshToken, int.clientId, int.clientSecret);
+
+            // 1. Create the user list in Google Ads
+            const createResult = await mutate(int, "userLists", [{
+              create: {
+                name,
+                description: description || name,
+                membershipLifeSpan: 540,
+                // 18 months max
+                crmBasedUserList: {
+                  uploadKeyType: "CONTACT_INFO",
+                  dataSourceType: "FIRST_PARTY"
+                }
+              }
+            }], sb, storeId);
+            const results = createResult.results || [];
+            const resourceName = results[0]?.resourceName || null;
+            const googleAudienceId = resourceName ? resourceName.split("/").pop() : null;
+
+            // 2. Save locally
+            const {
+              data,
+              error
+            } = await sb.from("google_audiences").insert({
+              store_id: storeId,
+              name,
+              audience_type: audienceType,
+              description,
+              google_audience_id: googleAudienceId,
+              status: googleAudienceId ? "OPEN" : "DRAFT"
+            }).select().single();
+            if (error) return {
+              success: false,
+              error: error.message
+            };
+
+            // 3. If a segment_id was provided, upload members immediately
+            const segmentId = args.segment_id;
+            if (segmentId && googleAudienceId) {
+              const uploadResult = await uploadSegmentToGoogleAudience(sb, int, storeId, segmentId, resourceName);
+              return {
+                success: true,
+                data: {
+                  ...data,
+                  google_audience_id: googleAudienceId,
+                  resource_name: resourceName,
+                  upload: uploadResult
+                }
+              };
+            }
+            return {
+              success: true,
+              data: {
+                ...data,
+                google_audience_id: googleAudienceId,
+                resource_name: resourceName
+              }
+            };
+          }
+
+          // Non-Customer Match: just save locally
           const {
             data,
             error
-          } = await sb.from("google_audiences").insert(row).select().single();
+          } = await sb.from("google_audiences").insert({
+            store_id: storeId,
+            name,
+            audience_type: audienceType,
+            description,
+            status: "DRAFT"
+          }).select().single();
           if (error) return {
             success: false,
             error: error.message
@@ -1983,6 +2216,45 @@ export async function handleGoogleAds(sb, args, storeId) {
             data
           };
         }
+      case "sync_audience":
+        {
+          // Upload/refresh segment members to an existing Google Customer Match audience
+          const audienceId = args.audience_id || args.id;
+          const segmentId = args.segment_id;
+          if (!audienceId) return {
+            success: false,
+            error: "audience_id required"
+          };
+          if (!segmentId) return {
+            success: false,
+            error: "segment_id required"
+          };
+          const {
+            data: aud
+          } = await sb.from("google_audiences").select("*").eq("id", audienceId).single();
+          if (!aud) return {
+            success: false,
+            error: "Audience not found"
+          };
+          if (!aud.google_audience_id) return {
+            success: false,
+            error: "Audience not yet published to Google — use create_audience with CUSTOMER_MATCH type"
+          };
+          const int = await getIntegration(sb, storeId);
+          int.accessToken = await refreshAccessToken(sb, storeId, int.refreshToken, int.clientId, int.clientSecret);
+          const resourceName = `customers/${int.customerId}/userLists/${aud.google_audience_id}`;
+          const result = await uploadSegmentToGoogleAudience(sb, int, storeId, segmentId, resourceName);
+
+          // Update member count
+          await sb.from("google_audiences").update({
+            member_count: result.membersUploaded,
+            updated_at: new Date().toISOString()
+          }).eq("id", audienceId);
+          return {
+            success: true,
+            data: result
+          };
+        }
       case "list_audiences":
         {
           const {