@phygitallabs/tapquest-core 6.5.0 → 6.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phygitallabs/tapquest-core",
-  "version": "6.5.0",
+  "version": "6.7.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -25,7 +25,7 @@
   "dependencies": {
     "@openreplay/tracker": "^16.4.10",
     "@phygitallabs/achievement": "latest",
-    "@phygitallabs/api-core": "latest",
+    "@phygitallabs/api-core": "^6.3.0",
     "@phygitallabs/authentication": "latest",
     "@phygitallabs/generate-certificate": "latest",
     "@phygitallabs/helpers": "latest",

package/src/index.ts

@@ -1,5 +1,6 @@
 // Export all modules
 export * from "./modules/achievement";
+export * from "./modules/achievement-tracking";
 export * from "./modules/reward";
 export * from "./modules/notification";
 export * from "./modules/memory";
@@ -24,8 +25,10 @@ export * from "./modules/achivementWithReward";
 
 export * from "./modules/send-email";
 
+export * from "./modules/session-replay";
+
 export * from "./helper";
 
 export * from "./modules/session-replay";
 
-export type { APIVersionType, EnvironmentType } from "./types/common";
+export * from "./modules/action-logs";

package/src/modules/achievement/helpers/index.ts

@@ -1,45 +1,69 @@
 import { Achievement, UserAchievementProgress } from "../types";
 
 const getLocationIdsFromAchievementRule = (achievement: Achievement) => {
-    if (!achievement.rule) return [];
-    const locationIds: string[] = [];
-    Object.values(achievement.rule).forEach((ruleList) => {
-        if (!ruleList.rules) return;
-        ruleList.rules.forEach((rule) => {
-            if (!rule.filter) return;
-            Object.values(rule.filter).forEach((filterList) => {
-                if (!filterList.filters) return;
-                filterList.filters.forEach((filter) => {
-                    if (filter.label === "location_id" && filter.value) {
-                        if (Array.isArray(filter.value)) {
-                            locationIds.push(...filter.value);
-                        } else {
-                            locationIds.push(filter.value);
-                        }
-                    }
-                });
-            });
+  if (!achievement.rule) return [];
+  const locationIds: string[] = [];
+  Object.values(achievement.rule).forEach((ruleList) => {
+    if (!ruleList.rules) return;
+    ruleList.rules.forEach((rule) => {
+      if (!rule.filter) return;
+      Object.values(rule.filter).forEach((filterList) => {
+        if (!filterList.filters) return;
+        filterList.filters.forEach((filter) => {
+          if (filter.label === "location_id" && filter.value) {
+            if (Array.isArray(filter.value)) {
+              locationIds.push(...filter.value);
+            } else {
+              locationIds.push(filter.value);
+            }
+          }
         });
+      });
     });
-    return Array.from(new Set(locationIds)) as string[];
+  });
+  return Array.from(new Set(locationIds)) as string[];
 };
 
-const getActionsFromAchievementRule = (achievement: Achievement) => {
-    if (!achievement.rule) return [];
-    const actions: string[] = [];
-    Object.values(achievement.rule).forEach((ruleList) => {
-        if (!ruleList.rules) return;
-        ruleList.rules.forEach((rule) => {
-            if (rule.action) {
-                actions.push(rule.action)
+const getSurveyIdsFromAchievementRule = (achievement: Achievement) => {
+  if (!achievement.rule) return [];
+  const surveyIds: string[] = [];
+  Object.values(achievement.rule).forEach((ruleList) => {
+    if (!ruleList.rules) return;
+    ruleList.rules.forEach((rule) => {
+      if (!rule.filter) return;
+      Object.values(rule.filter).forEach((filterList) => {
+        if (!filterList.filters) return;
+        filterList.filters.forEach((filter) => {
+          if (filter.label === "survey_id" && filter.value) {
+            if (Array.isArray(filter.value)) {
+              surveyIds.push(...filter.value);
+            } else {
+              surveyIds.push(filter.value);
             }
+          }
         });
+      });
     });
-    return Array.from(new Set(actions)) as string[];
+  });
+  return Array.from(new Set(surveyIds)) as string[];
+};
+
+const getActionsFromAchievementRule = (achievement: Achievement) => {
+  if (!achievement?.rule) return [];
+  const actions: string[] = [];
+  Object.values(achievement?.rule || {}).forEach((ruleList) => {
+    if (!ruleList?.rules) return;
+    ruleList?.rules?.forEach((rule) => {
+      if (rule?.action) {
+        actions.push(rule?.action)
+      }
+    });
+  });
+  return Array.from(new Set(actions)) as string[];
 };
 
 const isAchievementCompleted = (achievement: UserAchievementProgress) => {
-    return achievement.isCompleted || achievement.overallPercentage === 100;
+  return achievement.isCompleted || achievement.overallPercentage === 100;
 }
 
 type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}`
@@ -92,7 +116,10 @@ export function convertSnakeToCamel<T>(obj: T): ConvertSnakeToCamel<T> {
   
 
 export {
-    getLocationIdsFromAchievementRule,
-    getActionsFromAchievementRule,
-    isAchievementCompleted
-}
+  getLocationIdsFromAchievementRule,
+  getActionsFromAchievementRule,
+  getSurveyIdsFromAchievementRule,
+  isAchievementCompleted
+}
+
+export { useClearAchievementProgressCache } from './useClearAchievementProgressCache';

package/src/modules/achievement/helpers/useClearAchievementProgressCache.tsx

@@ -0,0 +1,43 @@
+import { useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+
+export function useClearAchievementProgressCache() {
+  const queryClient = useQueryClient();
+
+  const clearCache = useCallback(
+    (options?: {
+      refetchActive?: boolean;
+      refetchInactive?: boolean;
+    }) => {
+      const { refetchActive = true, refetchInactive = false } = options || {};
+
+      // Clear all achievement progress related queries using predicate
+      // Query keys from different packages:
+      // 1. @phygitallabs/achievement (logged in): ['users', 'userAchievements', 'achievementProgressMany', ...]
+      // 2. @phygitallabs/api-core (device UID): ['userAchievements', 'achievementProgress', deviceId, ...]
+      // 3. @phygitallabs/achievement (device UID alt): ['deviceUidAchievementProgressMany', ...]
+
+      queryClient.invalidateQueries({
+        predicate: (query) => {
+          const queryKey = query.queryKey as string[];
+          return (
+            queryKey.includes("achievementProgressMany") ||      // For logged in users
+            queryKey.includes("achievementProgress") ||          // For device UID (api-core)
+            queryKey.includes("deviceUidAchievementProgressMany") // For device UID (achievement pkg)
+          );
+        },
+        refetchType: refetchActive
+          ? refetchInactive
+            ? "all"
+            : "active"
+          : "none",
+      });
+
+      console.log("🔄 Achievement progress cache cleared");
+    },
+    [queryClient]
+  );
+  return {
+    clearCache,
+  };
+}

package/src/modules/achievement-tracking/hooks/index.ts

@@ -0,0 +1 @@
+export { useAchievementTracking } from "../providers";

package/src/modules/achievement-tracking/index.ts

@@ -0,0 +1,3 @@
+export * from "./providers";
+export * from "./hooks";
+export * from "./types";

package/src/modules/achievement-tracking/providers/AchievementTrackingProvider.tsx

@@ -0,0 +1,153 @@
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useCallback,
+  useRef,
+} from "react";
+import { useDataTracking } from "../../data-tracking";
+import { useNotificationStore } from "../../notification";
+import {
+  getActionsFromAchievementRule,
+  AchievementType,
+} from "../../achievement";
+import type {
+  AchievementTrackingContextValue,
+  AchievementTrackingProviderProps,
+  AchievementActionType,
+} from "../types";
+import type { Achievement } from "../../achievement/types";
+
+const AchievementTrackingContext = createContext<
+  AchievementTrackingContextValue | undefined
+>(undefined);
+
+export function AchievementTrackingProvider({
+  children,
+  achievements,
+}: AchievementTrackingProviderProps) {
+  const { trackEvent } = useDataTracking();
+  const trackedNotificationIds = useRef(new Set<string>());
+
+  const { challenges, quests } = useMemo(() => {
+    const challengesList: Achievement[] = [];
+    const questsList: Achievement[] = [];
+
+    achievements.forEach((achievement) => {
+      if (achievement.type === AchievementType.GROUP_MISSION) {
+        questsList.push(achievement);
+      } else {
+        challengesList.push(achievement);
+      }
+    });
+
+    return {
+      challenges: challengesList,
+      quests: questsList,
+    };
+  }, [achievements]);
+
+  useEffect(() => {
+    const unsubscribe = useNotificationStore.subscribe((state) => {
+
+      const notifications = state.notifications;
+      if (notifications.length === 0) return;
+
+      const latestNotification = notifications[notifications.length - 1];
+
+      if (!latestNotification?.data?.achievement) return;
+
+      const notificationId = `${latestNotification.data.achievement.id}_${Date.now()}`;
+
+      if (trackedNotificationIds.current.has(notificationId)) return;
+
+      trackedNotificationIds.current.add(notificationId);
+
+      const achievement = latestNotification.data.achievement;
+
+      if (achievement.type === AchievementType.GROUP_MISSION) {
+        trackEvent("quest_complete", {
+          quest_id: achievement.id,
+          quest_name: achievement.name,
+        });
+      } else {
+        const actions = getActionsFromAchievementRule(achievement);
+        const challengeType = actions[0] || "unknown";
+
+        trackEvent("challenge_complete", {
+          challenge_id: achievement.id,
+          challenge_name: achievement.name,
+          challenge_type: challengeType,
+        });
+      }
+    });
+
+    return () => {
+      unsubscribe();
+    };
+  }, [trackEvent]);
+
+  const trackChallengeStart = useCallback(
+    (actionType: AchievementActionType) => {
+      const matchingAchievements = challenges.filter((achievement) => {
+        const actions = getActionsFromAchievementRule(achievement);
+        return actions.includes(actionType);
+      });
+
+      if (matchingAchievements.length === 0) {
+        console.error(
+          `[AchievementTracking] No achievement found for action: ${actionType}`
+        );
+        return;
+      }
+
+      matchingAchievements.forEach((achievement) => {
+        trackEvent("challenge_start", {
+          challenge_id: achievement.id,
+          challenge_name: achievement.name,
+          challenge_type: actionType,
+        });
+      });
+    },
+    [challenges, trackEvent]
+  );
+
+  const trackQuestStart = useCallback(() => {
+    if (quests.length === 0) {
+      console.error(`[AchievementTracking] No quests found`);
+      return;
+    }
+
+    quests.forEach((quest) => {
+      trackEvent("quest_start", {
+        quest_id: quest.id,
+        quest_name: quest.name,
+      });
+    });
+  }, [quests, trackEvent]);
+
+  const isReady = achievements.length > 0;
+
+  const contextValue: AchievementTrackingContextValue = {
+    trackChallengeStart,
+    trackQuestStart,
+    isReady,
+  };
+
+  return (
+    <AchievementTrackingContext.Provider value={contextValue}>
+      {children}
+    </AchievementTrackingContext.Provider>
+  );
+}
+
+export function useAchievementTracking(): AchievementTrackingContextValue {
+  const context = useContext(AchievementTrackingContext);
+  if (!context) {
+    throw new Error(
+      "useAchievementTracking must be used within AchievementTrackingProvider"
+    );
+  }
+  return context;
+}

package/src/modules/achievement-tracking/providers/index.ts

@@ -0,0 +1 @@
+export { AchievementTrackingProvider, useAchievementTracking } from "./AchievementTrackingProvider";

package/src/modules/achievement-tracking/types/index.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from "react";
+import type { Achievement } from "../../achievement/types";
+
+export type TrackingEventName =
+  | "challenge_start"
+  | "quest_start"
+  | "challenge_complete"
+  | "quest_complete";
+
+export type AchievementActionType = "tap_chip" | "create_memory" | "take_survey";
+
+export interface AchievementTrackingContextValue {
+  trackChallengeStart: (actionType: AchievementActionType) => void;
+  trackQuestStart: () => void;
+  isReady: boolean;
+}
+
+export interface AchievementTrackingProviderProps {
+  children: ReactNode;
+  achievements: Achievement[];
+}

package/src/modules/action-logs/hooks/index.ts

@@ -0,0 +1,3 @@
+import { useCreateClickButtonActionLog } from "@phygitallabs/api-core";
+
+export { useCreateClickButtonActionLog };

package/src/modules/action-logs/index.ts

@@ -0,0 +1 @@
+export * from "./hooks";