whale-code 6.5.6 → 6.5.7

package/dist/server/handlers/meta-ads.d.ts

@@ -34,6 +34,8 @@ export declare function handleMetaAds(sb: SupabaseClient, args: Record<string, u
     published?: undefined;
     count?: undefined;
     message?: undefined;
+    synced?: undefined;
+    meta_catalog_id?: undefined;
 } | {
     success: boolean;
     data: any;
@@ -41,6 +43,8 @@ export declare function handleMetaAds(sb: SupabaseClient, args: Record<string, u
     published?: undefined;
     count?: undefined;
     message?: undefined;
+    synced?: undefined;
+    meta_catalog_id?: undefined;
 } | {
     success: boolean;
     published: boolean;
@@ -61,6 +65,8 @@ export declare function handleMetaAds(sb: SupabaseClient, args: Record<string, u
     error?: undefined;
     count?: undefined;
     message?: undefined;
+    synced?: undefined;
+    meta_catalog_id?: undefined;
 } | {
     success: boolean;
     published: boolean;
@@ -74,6 +80,8 @@ export declare function handleMetaAds(sb: SupabaseClient, args: Record<string, u
     error?: undefined;
     count?: undefined;
     message?: undefined;
+    synced?: undefined;
+    meta_catalog_id?: undefined;
 } | {
     success: boolean;
     published: boolean;
@@ -87,6 +95,8 @@ export declare function handleMetaAds(sb: SupabaseClient, args: Record<string, u
     error?: undefined;
     count?: undefined;
     message?: undefined;
+    synced?: undefined;
+    meta_catalog_id?: undefined;
 } | {
     success: boolean;
     count: number;
@@ -94,6 +104,8 @@ export declare function handleMetaAds(sb: SupabaseClient, args: Record<string, u
     error?: undefined;
     published?: undefined;
     message?: undefined;
+    synced?: undefined;
+    meta_catalog_id?: undefined;
 } | {
     success: boolean;
     data: any;
@@ -101,6 +113,8 @@ export declare function handleMetaAds(sb: SupabaseClient, args: Record<string, u
     error?: undefined;
     published?: undefined;
     count?: undefined;
+    synced?: undefined;
+    meta_catalog_id?: undefined;
 } | {
     success: boolean;
     message: string;
@@ -108,4 +122,15 @@ export declare function handleMetaAds(sb: SupabaseClient, args: Record<string, u
     data?: undefined;
     published?: undefined;
     count?: undefined;
+    synced?: undefined;
+    meta_catalog_id?: undefined;
+} | {
+    success: boolean;
+    synced: number;
+    meta_catalog_id: any;
+    error?: undefined;
+    data?: undefined;
+    published?: undefined;
+    count?: undefined;
+    message?: undefined;
 }>;

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

@@ -43,7 +43,8 @@ const VALID_GOALS = {
   OUTCOME_ENGAGEMENT: ["THRUPLAY", "POST_ENGAGEMENT", "VIDEO_VIEWS", "REACH"],
   OUTCOME_LEADS: ["LEAD_GENERATION", "LINK_CLICKS", "QUALITY_LEAD", "REACH"],
   OUTCOME_APP_PROMOTION: ["APP_INSTALLS", "LINK_CLICKS", "APP_EVENTS", "VALUE"],
-  OUTCOME_SALES: ["OFFSITE_CONVERSIONS", "LINK_CLICKS", "VALUE", "REACH"]
+  OUTCOME_SALES: ["OFFSITE_CONVERSIONS", "LINK_CLICKS", "VALUE", "REACH"],
+  PRODUCT_CATALOG_SALES: ["OFFSITE_CONVERSIONS", "LINK_CLICKS", "VALUE", "REACH"]
 };
 
 /** Default optimization goal per objective. */
@@ -181,7 +182,7 @@ async function getIntegration(sb, storeId) {
   const {
     data,
     error
-  } = await sb.from("meta_integrations").select("access_token_encrypted, ad_account_id, page_id, pixel_id, instagram_business_id, token_expires_at, status").eq("store_id", storeId).limit(1).single();
+  } = await sb.from("meta_integrations").select("access_token_encrypted, ad_account_id, business_id, page_id, pixel_id, instagram_business_id, token_expires_at, status").eq("store_id", storeId).limit(1).single();
   if (error || !data?.access_token_encrypted || !data?.ad_account_id) {
     throw new Error("Meta not connected. Go to Settings → Meta Connection to link your account.");
   }
@@ -195,6 +196,7 @@ async function getIntegration(sb, storeId) {
   return {
     accessToken: data.access_token_encrypted,
     adAccountId: data.ad_account_id,
+    businessId: data.business_id || null,
     pageId: data.page_id || null,
     pixelId: data.pixel_id || null,
     instagramAccountId: data.instagram_business_id || null,
@@ -2838,6 +2840,393 @@ export async function handleMetaAds(sb, args, storeId) {
           };
         }
 
+      // ==================================================================
+      // PHASE 4: PRODUCT CATALOG, CANVAS, ATTRIBUTION
+      // ==================================================================
+
+      case "create_catalog":
+        {
+          const name = args.name || "Product Catalog";
+          const int = await getIntegration(sb, storeId);
+          const businessId = int.businessId;
+          const endpoint = businessId ? `/${businessId}/owned_product_catalogs` : `/${int.adAccountId}/product_catalogs`;
+          const res = await fetch(`${META_BASE}${endpoint}`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+              access_token: int.accessToken,
+              name,
+              vertical: "commerce"
+            }).toString()
+          });
+          const json = await res.json();
+          if (json.error) return {
+            success: false,
+            error: parseMetaError(JSON.stringify(json), "create_catalog", res.status)
+          };
+          const metaCatalogId = json.id;
+          const {
+            data,
+            error
+          } = await sb.from("meta_catalogs").insert({
+            store_id: storeId,
+            meta_catalog_id: metaCatalogId,
+            name,
+            sync_status: "pending"
+          }).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data: {
+              ...data,
+              meta_catalog_id: metaCatalogId
+            }
+          };
+        }
+      case "list_catalogs":
+        {
+          const {
+            data,
+            error
+          } = await sb.from("meta_catalogs").select("*").eq("store_id", storeId).order("created_at", {
+            ascending: false
+          });
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data: data || []
+          };
+        }
+      case "sync_catalog":
+        {
+          const catalogId = args.catalog_id;
+          if (!catalogId) return {
+            success: false,
+            error: "catalog_id required"
+          };
+          const {
+            data: catalog
+          } = await sb.from("meta_catalogs").select("*").eq("id", catalogId).single();
+          if (!catalog?.meta_catalog_id) return {
+            success: false,
+            error: "Catalog not found or not published"
+          };
+          const int = await getIntegration(sb, storeId);
+          await sb.from("meta_catalogs").update({
+            sync_status: "syncing",
+            updated_at: new Date().toISOString()
+          }).eq("id", catalogId);
+          const {
+            data: domainRow
+          } = await sb.from("store_domains").select("domain").eq("store_id", storeId).eq("is_primary", true).single();
+          const domain = domainRow?.domain || "example.com";
+          const {
+            data: products
+          } = await sb.from("products").select("id, name, slug, description, sku, featured_image, stock_status, product_variations(regular_price, sale_price)").eq("store_id", storeId).eq("status", "published").limit(5000);
+          if (!products?.length) {
+            await sb.from("meta_catalogs").update({
+              sync_status: "failed",
+              error: "No products"
+            }).eq("id", catalogId);
+            return {
+              success: false,
+              error: "No published products found"
+            };
+          }
+          const items = [];
+          for (const p of products) {
+            const vars = p.product_variations || [];
+            const price = vars[0]?.regular_price || 0;
+            if (price <= 0) continue;
+            items.push({
+              method: "UPDATE",
+              retailer_id: p.id,
+              data: {
+                id: p.id,
+                title: p.name || "Untitled",
+                description: (p.description || p.name || "").slice(0, 5000),
+                availability: p.stock_status === "instock" ? "in stock" : "out of stock",
+                condition: "new",
+                price: `${price.toFixed(2)} USD`,
+                link: `https://${domain}/products/${p.slug}`,
+                image_link: p.featured_image || `https://${domain}/placeholder.png`,
+                brand: domain.split(".")[0]
+              }
+            });
+          }
+          let synced = 0;
+          for (let i = 0; i < items.length; i += 500) {
+            const batch = items.slice(i, i + 500);
+            await fetch(`${META_BASE}/${catalog.meta_catalog_id}/batch`, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/x-www-form-urlencoded"
+              },
+              body: new URLSearchParams({
+                access_token: int.accessToken,
+                requests: JSON.stringify(batch)
+              }).toString()
+            });
+            synced += batch.length;
+          }
+          await sb.from("meta_catalogs").update({
+            sync_status: "synced",
+            product_count: synced,
+            last_synced_at: new Date().toISOString(),
+            error: null
+          }).eq("id", catalogId);
+          return {
+            success: true,
+            synced,
+            meta_catalog_id: catalog.meta_catalog_id
+          };
+        }
+      case "create_product_set":
+        {
+          const catalogId = args.catalog_id;
+          const name = args.name || "All Products";
+          const filter = args.filter || {
+            retailer_id: {
+              is_any: true
+            }
+          };
+          if (!catalogId) return {
+            success: false,
+            error: "catalog_id required"
+          };
+          const {
+            data: catalog
+          } = await sb.from("meta_catalogs").select("meta_catalog_id").eq("id", catalogId).single();
+          if (!catalog?.meta_catalog_id) return {
+            success: false,
+            error: "Catalog not found"
+          };
+          const int = await getIntegration(sb, storeId);
+          const res = await fetch(`${META_BASE}/${catalog.meta_catalog_id}/product_sets`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+              access_token: int.accessToken,
+              name,
+              filter: JSON.stringify(filter)
+            }).toString()
+          });
+          const json = await res.json();
+          if (json.error) return {
+            success: false,
+            error: parseMetaError(JSON.stringify(json), "product_set", res.status)
+          };
+          const {
+            data,
+            error
+          } = await sb.from("meta_product_sets").insert({
+            store_id: storeId,
+            catalog_id: catalogId,
+            meta_product_set_id: json.id,
+            name,
+            filter
+          }).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "list_product_sets":
+        {
+          const catalogId = args.catalog_id;
+          if (!catalogId) return {
+            success: false,
+            error: "catalog_id required"
+          };
+          const {
+            data,
+            error
+          } = await sb.from("meta_product_sets").select("*").eq("catalog_id", catalogId).order("created_at", {
+            ascending: false
+          });
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data: data || []
+          };
+        }
+      case "create_canvas":
+        {
+          const name = args.name || "Instant Experience";
+          const elements = args.elements || [];
+          const int = await getIntegration(sb, storeId);
+          const pageId = int.pageId;
+          if (!pageId) return {
+            success: false,
+            error: "No Facebook Page linked"
+          };
+          const bodyElements = elements.map(el => {
+            switch (el.type) {
+              case "header":
+                return {
+                  element_type: "HEADER",
+                  text: {
+                    text: el.text || "",
+                    font_size: "large"
+                  }
+                };
+              case "photo":
+                return {
+                  element_type: "PHOTO",
+                  photo: {
+                    url: el.url || ""
+                  }
+                };
+              case "video":
+                return {
+                  element_type: "VIDEO",
+                  video: {
+                    url: el.url || ""
+                  }
+                };
+              case "text":
+                return {
+                  element_type: "TEXT",
+                  text: {
+                    text: el.text || ""
+                  }
+                };
+              case "button":
+                return {
+                  element_type: "BUTTON",
+                  button: {
+                    title: el.title || "Shop Now",
+                    action: {
+                      type: "web_url",
+                      url: el.url || ""
+                    }
+                  }
+                };
+              case "product_set":
+                return {
+                  element_type: "PRODUCT_SET",
+                  product_set: {
+                    product_set_id: el.product_set_id || ""
+                  }
+                };
+              default:
+                return {
+                  element_type: "TEXT",
+                  text: {
+                    text: String(el.text || "")
+                  }
+                };
+            }
+          });
+          const res = await fetch(`${META_BASE}/${pageId}/canvas`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+              access_token: int.accessToken,
+              name,
+              body_element_ids: JSON.stringify(bodyElements),
+              is_published: "true"
+            }).toString()
+          });
+          const json = await res.json();
+          if (json.error) return {
+            success: false,
+            error: parseMetaError(JSON.stringify(json), "canvas", res.status)
+          };
+          const {
+            data,
+            error
+          } = await sb.from("meta_canvas").insert({
+            store_id: storeId,
+            meta_canvas_id: json.id,
+            name,
+            elements,
+            status: "published"
+          }).select().single();
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data
+          };
+        }
+      case "list_canvases":
+        {
+          const {
+            data,
+            error
+          } = await sb.from("meta_canvas").select("*").eq("store_id", storeId).order("created_at", {
+            ascending: false
+          });
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          return {
+            success: true,
+            data: data || []
+          };
+        }
+      case "attribution_report":
+        {
+          const campaignId = args.campaign_id;
+          let query = sb.from("marketing_campaign_events").select("id, campaign_id, channel, attributed_revenue, created_at, event_type").eq("store_id", storeId).eq("event_type", "converted").order("created_at", {
+            ascending: false
+          });
+          if (campaignId) query = query.eq("campaign_id", campaignId);
+          const {
+            data: events,
+            error
+          } = await query.limit(1000);
+          if (error) return {
+            success: false,
+            error: error.message
+          };
+          const conversions = events?.length || 0;
+          const totalRevenue = (events || []).reduce((s, e) => s + (e.attributed_revenue || 0), 0);
+          const byChannel = {};
+          for (const e of events || []) {
+            const ch = e.channel || "unknown";
+            if (!byChannel[ch]) byChannel[ch] = {
+              count: 0,
+              revenue: 0
+            };
+            byChannel[ch].count += 1;
+            byChannel[ch].revenue += e.attributed_revenue || 0;
+          }
+          return {
+            success: true,
+            data: {
+              conversions,
+              total_revenue: parseFloat(totalRevenue.toFixed(2)),
+              avg_order_value: conversions > 0 ? parseFloat((totalRevenue / conversions).toFixed(2)) : 0,
+              roas: 0,
+              by_channel: byChannel
+            }
+          };
+        }
+
       // ==================================================================
       // DEFAULT
       // ==================================================================
@@ -2845,7 +3234,7 @@ export async function handleMetaAds(sb, args, storeId) {
       default:
         return {
           success: false,
-          error: `Unknown action: ${action}. Valid: create_campaign, create_ad_set, create_ad, create_full, list_campaigns, list_ad_sets, list_ads, get_campaign, get_ad_set, get_ad, update_campaign, update_ad_set, update_ad, delete, publish, sync, search_targeting, insights_breakdown, ad_preview, create_audience, list_audiences, get_audience, delete_audience, create_lookalike, create_lead_form, list_lead_forms, get_leads, list_pixels, create_custom_conversion, list_custom_conversions, create_rule, list_rules, delete_rule, reach_estimate, audience_insights.`
+          error: `Unknown action: ${action}. Valid: create_campaign, create_ad_set, create_ad, create_full, list_campaigns, list_ad_sets, list_ads, get_campaign, get_ad_set, get_ad, update_campaign, update_ad_set, update_ad, delete, publish, sync, search_targeting, insights_breakdown, ad_preview, create_audience, list_audiences, get_audience, delete_audience, create_lookalike, create_lead_form, list_lead_forms, get_leads, list_pixels, create_custom_conversion, list_custom_conversions, create_rule, list_rules, delete_rule, reach_estimate, audience_insights, create_catalog, list_catalogs, sync_catalog, create_product_set, list_product_sets, create_canvas, list_canvases, attribution_report.`
         };
     }
   } catch (err) {