whale-code 6.4.0 → 6.5.0

package/dist/server/handlers/crm.js

@@ -1,21 +1,32 @@
 import { sanitizeFilterValue } from "../lib/utils.js";
+import { handleEmail } from "./comms.js";
+/** Strip internal infrastructure fields that stores should never see */
+function stripInternal(row) {
+    if (!row)
+        return null;
+    const { platform_user_id, store_id, password_hash, ...clean } = row;
+    return clean;
+}
+function stripInternalArray(rows) {
+    return (rows || []).map(r => stripInternal(r));
+}
 export async function handleCustomers(sb, args, storeId) {
     const sid = storeId;
     switch (args.action) {
-        // ---- FIND: search customers via v_store_customers view ----
+        // ---- FIND: search customers via v_segment_customers view ----
         case "find": {
-            let q = sb.from("v_store_customers")
-                .select("id, platform_user_id, first_name, last_name, email, phone, loyalty_points, loyalty_tier, total_spent, total_orders, lifetime_value, is_active, created_at")
+            const sortField = args.sort_by || "created_at";
+            const sortAsc = args.sort_order === "asc";
+            let q = sb.from("v_segment_customers")
+                .select("id, first_name, last_name, email, phone, loyalty_points, loyalty_tier, total_spent, total_orders, lifetime_value, is_active, rfm_segment, is_vip_customer, is_at_risk, is_churned, reorder_due, ai_churn_risk, days_since_last_order, engagement_score, age_bracket, created_at")
                 .eq("store_id", sid)
-                .order("created_at", { ascending: false });
+                .order(sortField, { ascending: sortAsc });
             if (args.limit)
                 q = q.limit(args.limit);
             if (args.query) {
                 const raw = sanitizeFilterValue(String(args.query).trim());
-                // Split multi-word queries so "Hannah Spivey" matches first_name=Hannah OR last_name=Spivey
                 const words = raw.split(/\s+/).filter(Boolean);
                 if (words.length > 1) {
-                    // Multi-word: each word matches any field
                     const clauses = words.map(w => { const sw = sanitizeFilterValue(w); return `first_name.ilike.%${sw}%,last_name.ilike.%${sw}%`; }).join(",");
                     q = q.or(`${clauses},email.ilike.%${raw}%,phone.ilike.%${raw}%`);
                 }
@@ -30,79 +41,147 @@ export async function handleCustomers(sb, args, storeId) {
                 q = q.eq("is_active", false);
             if (args.loyalty_tier)
                 q = q.eq("loyalty_tier", args.loyalty_tier);
+            if (args.rfm_segment)
+                q = q.eq("rfm_segment", args.rfm_segment);
+            if (args.is_vip !== undefined)
+                q = q.eq("is_vip_customer", args.is_vip);
+            if (args.is_at_risk !== undefined)
+                q = q.eq("is_at_risk", args.is_at_risk);
+            if (args.is_churned !== undefined)
+                q = q.eq("is_churned", args.is_churned);
+            if (args.reorder_due !== undefined)
+                q = q.eq("reorder_due", args.reorder_due);
+            if (args.age_bracket)
+                q = q.eq("age_bracket", args.age_bracket);
+            if (args.min_orders !== undefined)
+                q = q.gte("total_orders", args.min_orders);
+            if (args.max_orders !== undefined)
+                q = q.lte("total_orders", args.max_orders);
+            if (args.min_spent !== undefined)
+                q = q.gte("total_spent", args.min_spent);
+            if (args.max_spent !== undefined)
+                q = q.lte("total_spent", args.max_spent);
             const { data, error } = await q;
             return error ? { success: false, error: error.message } : { success: true, count: data?.length, data };
         }
-        // ---- GET: full customer detail with orders, activity, notes ----
+        // ---- GET: full 360° customer detail with orders, activity, notes, loyalty, segments ----
         case "get": {
             const custId = args.customer_id;
-            const { data: customer, error: custErr } = await sb.from("v_store_customers")
+            const { data: customer, error: custErr } = await sb.from("v_segment_customers")
                 .select("*").eq("id", custId).eq("store_id", sid).single();
             if (custErr)
                 return { success: false, error: custErr.message };
-            const { data: orders } = await sb.from("orders")
-                .select("id, order_number, status, total_amount, payment_status, fulfillment_status, created_at")
-                .eq("customer_id", custId).eq("store_id", sid)
-                .order("created_at", { ascending: false })
-                .limit(args.orders_limit || 10);
-            const { data: notes } = await sb.from("customer_notes")
-                .select("id, note, created_by, created_at")
-                .eq("customer_id", custId)
-                .order("created_at", { ascending: false }).limit(10);
-            const { data: activity } = await sb.from("customer_activity")
-                .select("id, activity_type, description, created_at")
-                .eq("customer_id", custId)
-                .order("created_at", { ascending: false }).limit(10);
-            const { data: profile } = await sb.from("store_customer_profiles")
-                .select("*").eq("relationship_id", custId).maybeSingle();
-            // Flatten profile into customer object so all fields are visible
-            // (formatter drops nested objects that aren't arrays)
+            const [{ data: orders }, { data: notes }, { data: activity }, { data: profile }, { data: loyaltyHistory }, { data: segmentRows }] = await Promise.all([
+                sb.from("orders")
+                    .select("id, order_number, status, total_amount, payment_status, fulfillment_status, created_at")
+                    .eq("customer_id", custId).eq("store_id", sid)
+                    .order("created_at", { ascending: false })
+                    .limit(args.orders_limit || 10),
+                sb.from("customer_notes")
+                    .select("id, note, created_by, created_at")
+                    .eq("customer_id", custId)
+                    .order("created_at", { ascending: false }).limit(10),
+                sb.from("customer_activity")
+                    .select("id, activity_type, description, created_at")
+                    .eq("customer_id", custId)
+                    .order("created_at", { ascending: false }).limit(10),
+                sb.from("store_customer_profiles")
+                    .select("*").eq("relationship_id", custId).maybeSingle(),
+                sb.from("loyalty_transactions")
+                    .select("id, points, transaction_type, reference_type, reference_id, description, balance_before, balance_after, expires_at, created_at")
+                    .eq("customer_id", custId)
+                    .order("created_at", { ascending: false }).limit(20),
+                sb.from("customer_segment_memberships")
+                    .select("added_at, segment:customer_segments(id, name, type)")
+                    .eq("customer_id", custId),
+            ]);
+            // Flatten profile fields into customer object (skip sensitive + computed-only fields)
             const prof = profile;
-            const profileFields = prof ? {
-                street_address: prof.street_address || null,
-                city: prof.city || null,
-                state: prof.state || null,
-                postal_code: prof.postal_code || null,
-                drivers_license_number: prof.drivers_license_number || null,
-                id_verified: prof.id_verified || false,
-                medical_card_number: prof.medical_card_number || null,
-                medical_card_expiry: prof.medical_card_expiry || null,
-                is_wholesale_approved: prof.is_wholesale_approved || false,
-                wholesale_tier: prof.wholesale_tier || null,
-            } : {};
-            return { success: true, data: { ...customer, ...profileFields, orders, notes, activity } };
+            const profileFields = {};
+            if (prof) {
+                const skip = new Set([
+                    "id", "relationship_id", "created_at", "updated_at",
+                    "password_hash", // never expose
+                    // These are recomputed by refresh_metrics — read from the view instead
+                    "total_spent", "total_orders", "lifetime_value", "average_order_value",
+                    "first_order_at", "last_order_at",
+                ]);
+                for (const [k, v] of Object.entries(prof)) {
+                    if (!skip.has(k))
+                        profileFields[k] = v ?? null;
+                }
+            }
+            // Flatten segment memberships
+            const segments = (segmentRows || []).map((r) => ({
+                segment_id: r.segment?.id, name: r.segment?.name, type: r.segment?.type, added_at: r.added_at,
+            }));
+            return { success: true, data: stripInternal({ ...customer, ...profileFields, orders, notes, activity, loyalty_history: loyaltyHistory || [], segments }) };
         }
         // ---- CREATE: new customer (platform_user + relationship + profile) ----
+        // Matching priority: email → phone → drivers_license → name+DOB → create new
         case "create": {
             const email = args.email;
             const phone = args.phone;
             const firstName = args.first_name;
             const lastName = args.last_name;
+            const dob = args.date_of_birth;
+            const dl = args.drivers_license_number;
             if (!firstName && !lastName)
                 return { success: false, error: "first_name or last_name is required" };
-            // Check for existing platform_user by email or phone
+            // Multi-tier matching to find existing platform_user (mirrors POS verify flow)
             let platformUserId = null;
-            if (email) {
+            let matchedVia = null;
+            // Tier 1: email
+            if (!platformUserId && email) {
                 const { data: existing } = await sb.from("platform_users")
                     .select("id").eq("email", email).maybeSingle();
-                if (existing)
+                if (existing) {
                     platformUserId = existing.id;
+                    matchedVia = "email";
+                }
             }
+            // Tier 2: phone
             if (!platformUserId && phone) {
                 const { data: existing } = await sb.from("platform_users")
                     .select("id").eq("phone", phone).maybeSingle();
-                if (existing)
+                if (existing) {
                     platformUserId = existing.id;
+                    matchedVia = "phone";
+                }
             }
-            // Create platform_user if not found
+            // Tier 3: drivers license (look up via store_customer_profiles → relationship → platform_user)
+            if (!platformUserId && dl) {
+                const { data: profMatch } = await sb.from("store_customer_profiles")
+                    .select("relationship_id, relationship:user_creation_relationships!relationship_id(user_id, store_id)")
+                    .eq("drivers_license_number", dl).limit(1).maybeSingle();
+                if (profMatch) {
+                    const rel = profMatch.relationship;
+                    if (rel?.user_id) {
+                        platformUserId = rel.user_id;
+                        matchedVia = "drivers_license";
+                    }
+                }
+            }
+            // Tier 4: exact name + date of birth (only when all 3 are provided)
+            if (!platformUserId && firstName && lastName && dob) {
+                const { data: nameMatch } = await sb.from("platform_users")
+                    .select("id").ilike("first_name", firstName).ilike("last_name", lastName)
+                    .eq("date_of_birth", dob).limit(1).maybeSingle();
+                if (nameMatch) {
+                    platformUserId = nameMatch.id;
+                    matchedVia = "name+dob";
+                }
+            }
+            // Create platform_user if no match found
+            const isNameOnly = !email && !phone;
             if (!platformUserId) {
                 const puInsert = { first_name: firstName, last_name: lastName };
                 if (email)
                     puInsert.email = email;
                 if (phone)
                     puInsert.phone = phone;
-                if (args.date_of_birth)
-                    puInsert.date_of_birth = args.date_of_birth;
+                if (dob)
+                    puInsert.date_of_birth = dob;
                 const { data: newPu, error: puErr } = await sb.from("platform_users")
                     .insert(puInsert).select("id").single();
                 if (puErr)
@@ -115,7 +194,7 @@ export async function handleCustomers(sb, args, storeId) {
             if (existingRel) {
                 const { data: existing } = await sb.from("v_store_customers")
                     .select("*").eq("id", existingRel.id).single();
-                return { success: true, data: existing, note: "Customer already exists for this store" };
+                return { success: true, data: stripInternal(existing), note: `Customer already exists (matched via ${matchedVia || "existing record"})` };
             }
             // Create relationship
             const { data: rel, error: relErr } = await sb.from("user_creation_relationships")
@@ -137,44 +216,63 @@ export async function handleCustomers(sb, args, storeId) {
                 profileInsert.state = args.state;
             if (args.postal_code)
                 profileInsert.postal_code = args.postal_code;
-            if (args.drivers_license_number)
-                profileInsert.drivers_license_number = args.drivers_license_number;
+            if (dl)
+                profileInsert.drivers_license_number = dl;
             if (args.medical_card_number)
                 profileInsert.medical_card_number = args.medical_card_number;
             if (args.medical_card_expiry)
                 profileInsert.medical_card_expiry = args.medical_card_expiry;
+            if (args.gender)
+                profileInsert.gender = args.gender;
+            if (args.eye_color)
+                profileInsert.eye_color = args.eye_color;
+            if (args.hair_color)
+                profileInsert.hair_color = args.hair_color;
+            if (args.height_raw)
+                profileInsert.height_raw = args.height_raw;
+            if (args.weight)
+                profileInsert.weight = args.weight;
+            if (args.suffix)
+                profileInsert.suffix = args.suffix;
+            if (args.is_staff !== undefined)
+                profileInsert.is_staff = args.is_staff;
             await sb.from("store_customer_profiles").insert(profileInsert);
             const { data: created } = await sb.from("v_store_customers")
                 .select("*").eq("id", rel.id).single();
-            return { success: true, data: created };
+            return {
+                success: true,
+                data: stripInternal(created),
+                ...(matchedVia ? { note: `Linked to existing customer record (matched via ${matchedVia})` } : {}),
+                ...(isNameOnly ? { warning: "Created with no email or phone — add contact info to prevent duplicates." } : {}),
+            };
         }
-        // ---- UPDATE: modify customer identity or store profile ----
+        // ---- UPDATE: modify any customer fields ----
         case "update": {
             const custId = args.customer_id;
             const { data: rel, error: relErr } = await sb.from("user_creation_relationships")
                 .select("id, user_id").eq("id", custId).eq("store_id", sid).single();
             if (relErr)
                 return { success: false, error: `Customer not found: ${relErr.message}` };
-            // Update platform_users (identity fields)
-            const puUpdates = {};
+            // Customer identity (name, email, phone, DOB)
+            const identityUpdates = {};
             if (args.first_name !== undefined)
-                puUpdates.first_name = args.first_name;
+                identityUpdates.first_name = args.first_name;
             if (args.last_name !== undefined)
-                puUpdates.last_name = args.last_name;
+                identityUpdates.last_name = args.last_name;
             if (args.email !== undefined)
-                puUpdates.email = args.email;
+                identityUpdates.email = args.email;
             if (args.phone !== undefined)
-                puUpdates.phone = args.phone;
+                identityUpdates.phone = args.phone;
             if (args.date_of_birth !== undefined)
-                puUpdates.date_of_birth = args.date_of_birth;
-            if (Object.keys(puUpdates).length > 0) {
-                puUpdates.updated_at = new Date().toISOString();
+                identityUpdates.date_of_birth = args.date_of_birth;
+            if (Object.keys(identityUpdates).length > 0) {
+                identityUpdates.updated_at = new Date().toISOString();
                 const { error: puErr } = await sb.from("platform_users")
-                    .update(puUpdates).eq("id", rel.user_id);
+                    .update(identityUpdates).eq("id", rel.user_id);
                 if (puErr)
-                    return { success: false, error: `Failed to update user: ${puErr.message}` };
+                    return { success: false, error: `Failed to update customer: ${puErr.message}` };
             }
-            // Update relationship (consent, status)
+            // Consent & status
             const relUpdates = {};
             if (args.status !== undefined)
                 relUpdates.status = args.status;
@@ -188,7 +286,7 @@ export async function handleCustomers(sb, args, storeId) {
                 relUpdates.updated_at = new Date().toISOString();
                 await sb.from("user_creation_relationships").update(relUpdates).eq("id", custId);
             }
-            // Update store profile (loyalty, address, ID, wholesale)
+            // Profile fields
             const profUpdates = {};
             if (args.loyalty_points !== undefined)
                 profUpdates.loyalty_points = args.loyalty_points;
@@ -202,24 +300,65 @@ export async function handleCustomers(sb, args, storeId) {
                 profUpdates.state = args.state;
             if (args.postal_code !== undefined)
                 profUpdates.postal_code = args.postal_code;
+            if (args.billing_address !== undefined)
+                profUpdates.billing_address = args.billing_address;
+            if (args.shipping_addresses !== undefined)
+                profUpdates.shipping_addresses = args.shipping_addresses;
+            if (args.default_shipping_address_index !== undefined)
+                profUpdates.default_shipping_address_index = args.default_shipping_address_index;
             if (args.drivers_license_number !== undefined)
                 profUpdates.drivers_license_number = args.drivers_license_number;
-            if (args.id_verified !== undefined)
+            if (args.id_verified !== undefined) {
                 profUpdates.id_verified = args.id_verified;
+                if (args.id_verified === true)
+                    profUpdates.id_verified_at = new Date().toISOString();
+            }
+            if (args.license_expiration_date !== undefined)
+                profUpdates.license_expiration_date = args.license_expiration_date;
+            if (args.license_issue_date !== undefined)
+                profUpdates.license_issue_date = args.license_issue_date;
             if (args.medical_card_number !== undefined)
                 profUpdates.medical_card_number = args.medical_card_number;
             if (args.medical_card_expiry !== undefined)
                 profUpdates.medical_card_expiry = args.medical_card_expiry;
+            if (args.gender !== undefined)
+                profUpdates.gender = args.gender;
+            if (args.eye_color !== undefined)
+                profUpdates.eye_color = args.eye_color;
+            if (args.height_raw !== undefined)
+                profUpdates.height_raw = args.height_raw;
+            if (args.weight !== undefined)
+                profUpdates.weight = args.weight;
+            if (args.hair_color !== undefined)
+                profUpdates.hair_color = args.hair_color;
+            if (args.suffix !== undefined)
+                profUpdates.suffix = args.suffix;
+            if (args.is_staff !== undefined)
+                profUpdates.is_staff = args.is_staff;
+            if (args.has_wallet_pass !== undefined)
+                profUpdates.has_wallet_pass = args.has_wallet_pass;
             if (args.is_wholesale_approved !== undefined)
                 profUpdates.is_wholesale_approved = args.is_wholesale_approved;
             if (args.wholesale_tier !== undefined)
                 profUpdates.wholesale_tier = args.wholesale_tier;
             if (args.wholesale_business_name !== undefined)
                 profUpdates.wholesale_business_name = args.wholesale_business_name;
+            if (args.wholesale_business_type !== undefined)
+                profUpdates.wholesale_business_type = args.wholesale_business_type;
             if (args.wholesale_license_number !== undefined)
                 profUpdates.wholesale_license_number = args.wholesale_license_number;
             if (args.wholesale_tax_id !== undefined)
                 profUpdates.wholesale_tax_id = args.wholesale_tax_id;
+            if (args.wholesale_discount_percent !== undefined)
+                profUpdates.wholesale_discount_percent = args.wholesale_discount_percent;
+            if (args.wholesale_payment_terms !== undefined)
+                profUpdates.wholesale_payment_terms = args.wholesale_payment_terms;
+            if (args.wholesale_credit_limit !== undefined)
+                profUpdates.wholesale_credit_limit = args.wholesale_credit_limit;
+            if (args.wholesale_resale_certificate !== undefined)
+                profUpdates.wholesale_resale_certificate = args.wholesale_resale_certificate;
+            if (args.wholesale_notes !== undefined)
+                profUpdates.wholesale_notes = args.wholesale_notes;
             if (Object.keys(profUpdates).length > 0) {
                 profUpdates.updated_at = new Date().toISOString();
                 const { error: profErr } = await sb.from("store_customer_profiles")
@@ -227,9 +366,9 @@ export async function handleCustomers(sb, args, storeId) {
                 if (profErr)
                     return { success: false, error: `Failed to update profile: ${profErr.message}` };
             }
-            const { data: updated } = await sb.from("v_store_customers")
+            const { data: updated } = await sb.from("v_segment_customers")
                 .select("*").eq("id", custId).eq("store_id", sid).single();
-            return { success: true, data: updated };
+            return { success: true, data: stripInternal(updated) };
         }
         // ---- FIND_DUPLICATES: identify potential duplicate customer accounts ----
         case "find_duplicates": {
@@ -389,7 +528,7 @@ export async function handleCustomers(sb, args, storeId) {
                 }
             }
             const { data: merged } = await sb.from("v_store_customers").select("*").eq("id", primaryId).single();
-            return { success: true, data: { merged_customer: merged, reassign_results: reassignResults } };
+            return { success: true, data: { merged_customer: stripInternal(merged), reassign_results: reassignResults } };
         }
         // ---- ADD_NOTE ----
         case "add_note": {
@@ -469,8 +608,154 @@ export async function handleCustomers(sb, args, storeId) {
                 .order("last_seen_at", { ascending: false });
             return error ? { success: false, error: error.message } : { success: true, data };
         }
+        // ---- INVITE: create auth account for customer and send branded invite email ----
+        case "invite": {
+            const custId = args.customer_id;
+            if (!custId)
+                return { success: false, error: "customer_id is required" };
+            // Verify customer belongs to this store
+            const { data: rel, error: relErr } = await sb.from("user_creation_relationships")
+                .select("id, user_id, store_id")
+                .eq("id", custId).eq("store_id", sid).single();
+            if (relErr || !rel)
+                return { success: false, error: "Customer not found for this store" };
+            // Get platform user + store name in parallel
+            const [{ data: pu }, { data: store }] = await Promise.all([
+                sb.from("platform_users").select("id, auth_id, email, first_name, last_name").eq("id", rel.user_id).single(),
+                sb.from("stores").select("store_name").eq("id", sid).single(),
+            ]);
+            if (!pu)
+                return { success: false, error: "Platform user not found" };
+            if (!pu.email)
+                return { success: false, error: "Customer has no email address — add one first" };
+            const storeName = store?.store_name || "our platform";
+            const customerName = [pu.first_name, pu.last_name].filter(Boolean).join(" ") || "there";
+            const portalUrl = args.portal_url || args.redirect_to || null;
+            // If already has an auth account, just resend the email with a new magic link
+            let authId = pu.auth_id;
+            if (!authId) {
+                // Create auth account silently (no Supabase built-in email)
+                const { data: newUser, error: createErr } = await sb.auth.admin.createUser({
+                    email: pu.email,
+                    email_confirm: true, // skip verification — store is vouching for this email
+                    user_metadata: {
+                        first_name: pu.first_name,
+                        last_name: pu.last_name,
+                        invited_by_store: sid,
+                    },
+                });
+                if (createErr)
+                    return { success: false, error: `Account creation failed: ${createErr.message}` };
+                authId = newUser.user.id;
+                // Link auth account to platform user
+                await sb.from("platform_users").update({ auth_id: authId }).eq("id", pu.id);
+            }
+            // Generate a magic link for the customer to set up / log in
+            const { data: linkData, error: linkErr } = await sb.auth.admin.generateLink({
+                type: "magiclink",
+                email: pu.email,
+                options: {
+                    ...(portalUrl ? { redirectTo: portalUrl } : {}),
+                },
+            });
+            if (linkErr)
+                return { success: false, error: `Link generation failed: ${linkErr.message}` };
+            const magicLink = linkData?.properties?.action_link || "";
+            // Send branded invite email through our email system
+            const emailResult = await handleEmail(sb, {
+                action: "send_template",
+                to: pu.email,
+                template: "customer-portal-invite",
+                template_data: {
+                    customer_name: customerName,
+                    store_name: storeName,
+                    magic_link: magicLink,
+                    portal_url: portalUrl || magicLink,
+                },
+            }, sid);
+            return {
+                success: true,
+                data: {
+                    email: pu.email,
+                    name: customerName,
+                    invited: true,
+                    email_sent: emailResult.success,
+                    ...(emailResult.success ? {} : { email_error: emailResult.error }),
+                },
+            };
+        }
+        // ---- LOYALTY_HISTORY: transaction history for a customer ----
+        case "loyalty_history": {
+            const custId = args.customer_id;
+            if (!custId)
+                return { success: false, error: "customer_id is required" };
+            let q = sb.from("loyalty_transactions")
+                .select("id, points, transaction_type, reference_type, reference_id, description, balance_before, balance_after, expires_at, created_at")
+                .eq("customer_id", custId)
+                .order("created_at", { ascending: false });
+            if (args.transaction_type)
+                q = q.eq("transaction_type", args.transaction_type);
+            q = q.limit(args.limit || 50);
+            const { data, error } = await q;
+            return error ? { success: false, error: error.message } : { success: true, count: data?.length, data };
+        }
+        // ---- ADJUST_LOYALTY: award or deduct loyalty points via RPC ----
+        case "adjust_loyalty": {
+            const custId = args.customer_id;
+            const points = args.points;
+            const reason = args.reason;
+            if (!custId || points === undefined || !reason)
+                return { success: false, error: "customer_id, points, and reason are required" };
+            const { data, error } = await sb.rpc("adjust_customer_loyalty_points", {
+                p_customer_id: custId,
+                p_points_change: points,
+                p_reason: reason,
+            });
+            if (error)
+                return { success: false, error: error.message };
+            const { data: updated } = await sb.from("store_customer_profiles")
+                .select("loyalty_points, loyalty_tier, lifetime_points_earned")
+                .eq("relationship_id", custId).maybeSingle();
+            return { success: true, data: { rpc_result: data, ...updated } };
+        }
+        // ---- SEGMENTS: list all customer segments for the store ----
+        case "segments": {
+            let q = sb.from("customer_segments")
+                .select("id, name, ai_description, type, segment_rules, filter_criteria, customer_count, is_active, color, icon, targeting_tips, created_at")
+                .eq("store_id", sid)
+                .order("customer_count", { ascending: false });
+            if (args.limit)
+                q = q.limit(args.limit);
+            const { data, error } = await q;
+            return error ? { success: false, error: error.message } : { success: true, count: data?.length, data };
+        }
+        // ---- SEGMENT_MEMBERS: list customers in a specific segment ----
+        case "segment_members": {
+            const segId = args.segment_id;
+            if (!segId)
+                return { success: false, error: "segment_id is required" };
+            const { data, error } = await sb.from("customer_segment_memberships")
+                .select("added_at, customer:v_segment_customers!customer_id(*)")
+                .eq("segment_id", segId)
+                .order("added_at", { ascending: false })
+                .limit(args.limit || 50);
+            if (error)
+                return { success: false, error: error.message };
+            const members = (data || []).map((r) => ({ added_at: r.added_at, ...r.customer }))
+                .filter((m) => m.store_id === sid);
+            return { success: true, count: members.length, data: stripInternalArray(members) };
+        }
+        // ---- REFRESH_METRICS: recalculate all customer metrics for the store ----
+        case "refresh_metrics": {
+            const start = Date.now();
+            const { data, error } = await sb.rpc("refresh_customer_metrics", { p_store_id: sid });
+            const elapsed = Date.now() - start;
+            if (error)
+                return { success: false, error: error.message };
+            return { success: true, data: { result: data, elapsed_ms: elapsed, message: `Customer metrics refreshed in ${elapsed}ms` } };
+        }
         default:
-            return { success: false, error: `Unknown customers action: ${args.action}. Valid: find, get, create, update, find_duplicates, merge, add_note, notes, activity, orders, link_channel_identity, get_channel_identities` };
+            return { success: false, error: `Unknown customers action: ${args.action}. Valid: find, get, create, update, invite, find_duplicates, merge, add_note, notes, activity, orders, loyalty_history, adjust_loyalty, segments, segment_members, refresh_metrics, link_channel_identity, get_channel_identities` };
     }
 }
 export async function handleOrders(sb, args, storeId) {

package/dist/server/handlers/embeddings.js

@@ -45,8 +45,8 @@ function productToText(product) {
         parts.push(String(product.short_description));
     if (product.description)
         parts.push(String(product.description));
-    if (product.field_values && typeof product.field_values === "object") {
-        const fv = product.field_values;
+    if (product.custom_fields && typeof product.custom_fields === "object") {
+        const fv = product.custom_fields;
         for (const [key, val] of Object.entries(fv)) {
             if (val !== null && val !== undefined && val !== "") {
                 parts.push(`${key}: ${String(val)}`);
@@ -117,7 +117,7 @@ export async function handleEmbeddings(sb, args, storeId) {
         case "index_products": {
             const { data: products, error: fetchErr } = await sb
                 .from("products")
-                .select("id, name, description, short_description, field_values")
+                .select("id, name, description, short_description, custom_fields")
                 .eq("store_id", sid);
             if (fetchErr)
                 return { success: false, error: fetchErr.message };