@pack/hydrogen 2.0.0 → 2.0.1

package/dist/index.js

@@ -5027,6 +5027,18 @@ var LocalTestResolver = class {
   hasRules() {
     return this.testRules.length > 0;
   }
+  /**
+   * Check if a specific test is still active in the current rules
+   */
+  isTestActive(testId) {
+    return this.testRules.some((test) => test.id === testId);
+  }
+  /**
+   * Get fresh test data by ID from current rules
+   */
+  getTestById(testId) {
+    return this.testRules.find((test) => test.id === testId) || null;
+  }
   /**
    * Get random number for test assignment
    */
@@ -5228,11 +5240,6 @@ var LocalTestResolver = class {
 // src/tests/test.ts
 var import_debug3 = __toESM(require_browser(), 1);
 var debug3 = (0, import_debug3.default)("pack:ab-testing:test");
-var QUERY_TEST_VARIANT_IS_RUNNING = `#graphql
-  query TestVariantIsRunning($handle: String!, $testId: ID!) {
-    testVariantIsRunning(handle: $handle, testId: $testId)
-  }
-`;
 var QUERY_TESTS_BY_RULES = `#graphql
   query TestsByRules($status: String) {
     testsByRulesV2(status: $status) {
@@ -5415,14 +5422,15 @@ async function fetchTestRulesShared(packClient, withCache, token) {
     }
   );
 }
-async function packClientFetchTestByRules(packClient, testTargetAudienceAttributes, testSession, request, withCache, token) {
+async function packClientFetchTestByRules(packClient, testTargetAudienceAttributes, testSession, request, withCache, token, exposedTest, validateOnly) {
   try {
     debug3(
       "[Pack Test] Starting test assignment process:",
       JSON.stringify({
         storeId: packClient.storeId,
         targetingAttributes: testTargetAudienceAttributes,
-        requestUrl: request.url
+        requestUrl: request.url,
+        validateOnly
       })
     );
     if (!packClient.storeId) {
@@ -5448,6 +5456,65 @@ async function packClientFetchTestByRules(packClient, testTargetAudienceAttribut
         debug3(
           "[Pack Test] Updated local resolver with rules from shared cache"
         );
+        const currentTestData = testSession.getTestData();
+        let needsNewTest = false;
+        if (currentTestData?.id) {
+          const freshTestData = localTestResolver.getTestById(currentTestData.id);
+          if (!freshTestData) {
+            debug3(
+              "[Pack Test] Current session test is no longer active (paused/stopped), clearing session:",
+              JSON.stringify({
+                testId: currentTestData.id,
+                testHandle: currentTestData.handle
+              })
+            );
+            testSession.clearTestData();
+            needsNewTest = true;
+          } else {
+            debug3(
+              "[Pack Test] Current session test is still active in rules, updating with fresh data:",
+              JSON.stringify({
+                testId: freshTestData.id,
+                testHandle: freshTestData.handle,
+                variantsCount: freshTestData.testVariants?.length
+              })
+            );
+            if (currentTestData.testVariant?.id) {
+              const currentVariant = freshTestData.testVariants?.find(
+                (v) => v.id === currentTestData.testVariant.id
+              );
+              if (currentVariant) {
+                const refreshedTest = {
+                  id: freshTestData.id,
+                  handle: freshTestData.handle,
+                  testVariant: {
+                    id: currentVariant.id,
+                    handle: currentVariant.handle
+                  },
+                  isFirstExposure: void 0
+                };
+                const { isFirstExposure: isFirstExposure2, ...testDataWithoutFlag2 } = refreshedTest;
+                testSession.setTestData(testDataWithoutFlag2);
+                testSession.setExpireAt(getExpireAtDate().toISOString());
+                return refreshedTest;
+              } else {
+                debug3(
+                  "[Pack Test] Current variant no longer exists in test, clearing session:",
+                  JSON.stringify({
+                    testId: currentTestData.id,
+                    variantId: currentTestData.testVariant.id
+                  })
+                );
+                testSession.clearTestData();
+                needsNewTest = true;
+              }
+            }
+          }
+        }
+        if (validateOnly && !needsNewTest) {
+          debug3("[Pack Test] Validation complete, no new test needed");
+          return void 0;
+        }
       } catch (error) {
         debug3(
           "[Pack Test] Failed to fetch test rules:",
@@ -5460,6 +5527,51 @@ async function packClientFetchTestByRules(packClient, testTargetAudienceAttribut
         "[Pack Test] No withCache or token available - cannot fetch test rules"
       );
     }
+    if (exposedTest) {
+      const freshTestData = localTestResolver.getTestById(exposedTest.id);
+      if (freshTestData) {
+        debug3(
+          "[Pack Test] Exposed test is still active in rules, restoring with fresh data:",
+          JSON.stringify({
+            testId: freshTestData.id,
+            testHandle: freshTestData.handle
+          })
+        );
+        const exposedVariant = freshTestData.testVariants?.find(
+          (v) => v.id === exposedTest.testVariant?.id
+        );
+        if (exposedVariant) {
+          const result2 = {
+            id: freshTestData.id,
+            handle: freshTestData.handle,
+            testVariant: {
+              id: exposedVariant.id,
+              handle: exposedVariant.handle
+            },
+            isFirstExposure: void 0
+          };
+          const { isFirstExposure: isFirstExposure2, ...testDataWithoutFlag2 } = result2;
+          testSession.setTestData(testDataWithoutFlag2);
+          testSession.setExpireAt(getExpireAtDate().toISOString());
+          return result2;
+        } else {
+          debug3(
+            "[Pack Test] Exposed test variant no longer exists in fresh data:",
+            JSON.stringify({
+              testId: exposedTest.id,
+              variantId: exposedTest.testVariant?.id
+            })
+          );
+        }
+      } else {
+        debug3(
+          "[Pack Test] Exposed test is no longer active in rules:",
+          JSON.stringify({
+            testId: exposedTest.id
+          })
+        );
+      }
+    }
     const sessionId = packClient.storeId;
     debug3("[Pack Test] Assigning test with session ID:", sessionId);
     const assignedTest = await localTestResolver.assignTest(
@@ -5512,46 +5624,6 @@ async function packClientFetchTestByRules(packClient, testTargetAudienceAttribut
     return void 0;
   }
 }
-async function packClientCheckTestIsRunning(packClient, testSession) {
-  debug3(
-    "[Pack Test] Checking if test variant is running:",
-    JSON.stringify({
-      testId: testSession.id,
-      testHandle: testSession.handle,
-      variantId: testSession.testVariant.id,
-      variantHandle: testSession.testVariant.handle
-    })
-  );
-  try {
-    const resp = await packClient.fetch(QUERY_TEST_VARIANT_IS_RUNNING, {
-      variables: {
-        handle: testSession.testVariant.handle,
-        testId: testSession.id
-      }
-    });
-    const isRunning = !!resp.data.testVariantIsRunning;
-    debug3(
-      "[Pack Test] Test variant running check result:",
-      JSON.stringify({
-        testId: testSession.id,
-        variantHandle: testSession.testVariant.handle,
-        isRunning,
-        responseData: resp.data
-      })
-    );
-    return isRunning;
-  } catch (e) {
-    debug3(
-      "[Pack Test] Error checking test variant status:",
-      JSON.stringify({
-        testId: testSession.id,
-        variantHandle: testSession.testVariant.handle,
-        error: e instanceof Error ? e.message : e
-      })
-    );
-  }
-  return false;
-}
 function getExpireAtDate() {
   const expireAt = /* @__PURE__ */ new Date();
   expireAt.setHours(expireAt.getHours() + 4);
@@ -5606,63 +5678,68 @@ async function getTestInfo({
     debug3("[Pack Test] Found existing test data in session");
     if (!testSessionExpireAt || new Date(testSessionExpireAt) >= /* @__PURE__ */ new Date()) {
       debug3(
-        "[Pack Test] Test session not expired, checking if test is still running"
+        "[Pack Test] Test session not expired by time, fetching rules to validate if test is still active"
       );
       try {
-        const testStillRunning = await packClientCheckTestIsRunning(
+        const validationResult = await packClientFetchTestByRules(
           packClient,
-          testSessionData
-        );
-        debug3(
-          "[Pack Test] Test running check result:",
-          JSON.stringify({
-            testId: testSessionData.id,
-            isRunning: testStillRunning
-          })
+          testTargetAudienceAttributes,
+          testSession,
+          request,
+          withCache,
+          token,
+          null,
+          true
+          // validateOnly - but will assign new test if current is inactive
         );
-        if (testStillRunning) {
-          debug3(
-            "[Pack Test] Using existing valid test session data",
-            JSON.stringify({
-              testId: testSessionData.id,
-              hasIsFirstExposure: "isFirstExposure" in testSessionData,
-              isFirstExposure: testSessionData.isFirstExposure
-            })
-          );
-          const cleanTestInfo = {
-            ...testSessionData,
-            isFirstExposure: void 0
-          };
-          debug3(
-            "[Pack Test] Returning cleaned test info:",
-            JSON.stringify({
-              testId: cleanTestInfo.id,
-              hasIsFirstExposure: "isFirstExposure" in cleanTestInfo,
-              isFirstExposure: cleanTestInfo.isFirstExposure
-            })
-          );
-          return cleanTestInfo;
+        if (validationResult) {
+          if (validationResult.id === testSessionData.id) {
+            debug3(
+              "[Pack Test] Test is still active, using refreshed data",
+              JSON.stringify({
+                testId: validationResult.id,
+                testHandle: validationResult.handle,
+                variantId: validationResult.testVariant.id,
+                variantHandle: validationResult.testVariant.handle
+              })
+            );
+            return validationResult;
+          } else {
+            debug3(
+              "[Pack Test] Original test no longer active, new test assigned",
+              JSON.stringify({
+                oldTestId: testSessionData.id,
+                newTestId: validationResult.id,
+                newTestHandle: validationResult.handle,
+                newVariantId: validationResult.testVariant.id,
+                newVariantHandle: validationResult.testVariant.handle
+              })
+            );
+            return {
+              ...validationResult,
+              isFirstExposure: true
+            };
+          }
         } else {
-          debug3(
-            "[Pack Test] Test is no longer running, will fetch new test"
-          );
+          debug3("[Pack Test] Test is no longer active and no new test was assigned");
+          return void 0;
         }
       } catch (error) {
         debug3(
-          "[Pack Test] Error checking if test is running, using cached data:",
+          "[Pack Test] Error validating test, using cached data:",
           JSON.stringify(error)
         );
         console.error(
-          "[Pack Test] Error checking if test is running, using cached data:",
+          "[Pack Test] Error validating test, using cached data:",
           error
         );
         return { ...testSessionData, isFirstExposure: void 0 };
       }
     } else {
-      debug3("[Pack Test] Test session has expired");
+      debug3("[Pack Test] Test session has expired by time");
+      debug3("[Pack Test] Clearing expired test session data");
+      testSession.clearTestData();
     }
-    debug3("[Pack Test] Clearing expired/invalid test session data");
-    testSession.clearTestData();
   }
   if (exposedTestCookieString) {
     try {
@@ -5686,72 +5763,47 @@ async function getTestInfo({
   }
   if (exposedTest && !testSessionData) {
     debug3(
-      "[Pack Test] Found exposed test cookie with no session data - checking if test is still running"
+      "[Pack Test] Found exposed test cookie with no session data - will fetch rules and validate"
     );
-    let testVariantIsRunning = false;
     try {
-      testVariantIsRunning = await packClientCheckTestIsRunning(
+      testInfo = await packClientFetchTestByRules(
         packClient,
-        exposedTest
+        testTargetAudienceAttributes,
+        testSession,
+        request,
+        withCache,
+        token,
+        exposedTest,
+        false
+        // Not validateOnly - allow assigning new tests
       );
+      if (testInfo?.id === exposedTest.id) {
+        debug3(
+          "[Pack Test] Exposed test was restored (still active)"
+        );
+      } else if (testInfo) {
+        debug3(
+          "[Pack Test] Exposed test is no longer active, using newly assigned test:",
+          JSON.stringify({
+            exposedTestId: exposedTest.id,
+            newTestId: testInfo.id
+          })
+        );
+      } else {
+        debug3(
+          "[Pack Test] Exposed test is no longer active and no new test was assigned"
+        );
+      }
     } catch (error) {
       debug3(
-        "[Pack Test] Error checking if test is still running:",
+        "[Pack Test] Error processing exposed test:",
         JSON.stringify(error)
       );
       console.error(
-        "[Pack Test] Error checking if test is still running, assuming not running:",
+        "[Pack Test] Error processing exposed test, continuing without test:",
         error
       );
-      testVariantIsRunning = false;
-    }
-    debug3(
-      "[Pack Test] Exposed test running check:",
-      JSON.stringify({
-        testId: exposedTest.id,
-        isRunning: testVariantIsRunning
-      })
-    );
-    if (testVariantIsRunning) {
-      const { id, handle, testVariant } = exposedTest;
-      testInfo = {
-        id,
-        handle,
-        testVariant,
-        isFirstExposure: void 0
-      };
-      debug3(
-        "[Pack Test] Restoring test from cookie to session:",
-        JSON.stringify(testInfo)
-      );
-      const { isFirstExposure, ...testDataWithoutFlag } = testInfo;
-      testSession.setTestData(testDataWithoutFlag);
-      testSession.setExpireAt(getExpireAtDate().toISOString());
-    } else {
-      debug3(
-        "[Pack Test] Exposed test is no longer running, clearing session and fetching new test"
-      );
-      testSession.clearTestData();
-      try {
-        testInfo = await packClientFetchTestByRules(
-          packClient,
-          testTargetAudienceAttributes,
-          testSession,
-          request,
-          withCache,
-          token
-        );
-      } catch (error) {
-        debug3(
-          "[Pack Test] Error fetching new test after exposed test expired:",
-          JSON.stringify(error)
-        );
-        console.error(
-          "[Pack Test] Error fetching new test, continuing without test:",
-          error
-        );
-        testInfo = void 0;
-      }
+      testInfo = void 0;
     }
   } else if (testSessionData) {
     debug3(
@@ -5765,7 +5817,10 @@ async function getTestInfo({
         testSession,
         request,
         withCache,
-        token
+        token,
+        null,
+        false
+        // Not validateOnly - allow assigning new tests
       );
     } catch (error) {
       debug3(
@@ -5789,7 +5844,10 @@ async function getTestInfo({
         testSession,
         request,
         withCache,
-        token
+        token,
+        null,
+        false
+        // Not validateOnly - allow assigning new tests
       );
     } catch (error) {
       debug3(