@cascayd/experiment 0.3.9 → 0.3.11

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import { InitOptions, ExperimentConfigResponse, EventType, RecordOptions, VariantStatusResponse } from './types';
 export declare function initCascayd(opts: InitOptions): void;
 export declare function getVariantStatus(experimentId: string, variantId: string): Promise<VariantStatusResponse>;
-export declare function assignVariant(experimentId: string): Promise<{
+export declare function assignVariant(experimentId: string, detectedVariants?: string[], route?: string, shop?: string): Promise<{
     variantId: string;
     config: ExperimentConfigResponse;
 }>;

package/dist/client.js

@@ -41,7 +41,9 @@ function seededRandom(seed) {
     return seed / m;
 }
 function chooseByWeight(variants, experimentId) {
+    console.log('[cascayd-sdk] chooseByWeight called with variants:', variants);
     const total = variants.reduce((s, v) => s + v.weight, 0);
+    console.log('[cascayd-sdk] chooseByWeight total weight:', total);
     // Create a seed based on current time (milliseconds) and experiment ID
     // This makes it change over time while being deterministic for the same millisecond
     const now = Date.now();
@@ -55,19 +57,79 @@ function chooseByWeight(variants, experimentId) {
     }
     // Use seeded random instead of Math.random()
     const r = seededRandom(Math.abs(hash)) * total;
+    console.log('[cascayd-sdk] chooseByWeight seed:', seedString, 'hash:', Math.abs(hash), 'random value:', r, 'total:', total);
     let acc = 0;
     for (const v of variants) {
         acc += v.weight;
-        if (r <= acc)
+        console.log('[cascayd-sdk] chooseByWeight checking variant:', v.id, 'weight:', v.weight, 'acc:', acc, 'r <= acc?', r <= acc);
+        if (r <= acc) {
+            console.log('[cascayd-sdk] chooseByWeight selected:', v.id);
             return v.id;
+        }
     }
-    return variants[variants.length - 1]?.id ?? 'control';
+    const fallback = variants[variants.length - 1]?.id ?? 'control';
+    console.log('[cascayd-sdk] chooseByWeight fallback to:', fallback);
+    return fallback;
 }
-export async function assignVariant(experimentId) {
+export async function assignVariant(experimentId, detectedVariants, route, shop) {
     const baseStatus = await getVariantStatus(experimentId, 'control');
-    const weights = baseStatus.weights || {};
+    let weights = baseStatus.weights || {};
+    console.log('[cascayd-sdk] assignVariant weights received:', weights);
+    // If we have detected variants, ensure they exist in the database
+    if (detectedVariants && detectedVariants.length > 0) {
+        // Check if all detected variants exist in weights
+        const missingVariants = detectedVariants.filter(vid => !(vid in weights));
+        if (missingVariants.length > 0) {
+            console.log('[cascayd-sdk] assignVariant: Missing variants detected, ensuring they exist:', missingVariants);
+            try {
+                // Call ensure endpoint to create missing variants
+                const ensureBody = {
+                    experiment_id: experimentId,
+                    variant_ids: detectedVariants,
+                    route: route || (typeof window !== 'undefined' ? window.location.pathname : "/"),
+                };
+                if (shop) {
+                    ensureBody.shop = shop;
+                }
+                const ensureRes = await fetch(`${BASE_URL}/experiments/ensure`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${API_KEY}`,
+                    },
+                    body: JSON.stringify(ensureBody),
+                });
+                if (ensureRes.ok) {
+                    console.log('[cascayd-sdk] assignVariant: Successfully ensured variants exist');
+                    // Fetch status again to get updated weights
+                    const updatedStatus = await getVariantStatus(experimentId, 'control');
+                    weights = updatedStatus.weights || {};
+                    console.log('[cascayd-sdk] assignVariant: Updated weights after ensuring:', weights);
+                }
+                else {
+                    console.warn('[cascayd-sdk] assignVariant: Failed to ensure variants, using fallback weights');
+                }
+            }
+            catch (error) {
+                console.error('[cascayd-sdk] assignVariant: Error ensuring variants:', error);
+            }
+        }
+    }
+    // If weights only has control and we have detected variants, use detected variants with equal weights (fallback)
+    if (Object.keys(weights).length === 1 && weights.control === 1 && detectedVariants && detectedVariants.length > 1) {
+        console.log('[cascayd-sdk] assignVariant: Only control in weights, using detected variants as fallback:', detectedVariants);
+        const equalWeight = 1 / detectedVariants.length;
+        weights = {};
+        detectedVariants.forEach(vid => {
+            weights[vid] = equalWeight;
+        });
+        console.log('[cascayd-sdk] assignVariant: Created equal weights from detected variants:', weights);
+    }
+    console.log('[cascayd-sdk] assignVariant weights entries:', Object.entries(weights));
     const variants = Object.entries(weights).map(([id, weight]) => ({ id, weight }));
+    console.log('[cascayd-sdk] assignVariant variants array:', variants);
     let candidate = chooseByWeight(variants.length > 0 ? variants : baseStatusToVariants(baseStatus), experimentId);
+    console.log('[cascayd-sdk] assignVariant candidate selected:', candidate);
     let finalStatus = null;
     if (candidate) {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascayd/experiment",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "A lightweight A/B testing SDK for React applications with server-side analytics integration",
   "keywords": [
     "ab-testing",