@phygitallabs/tapquest-core 6.6.0 → 6.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phygitallabs/tapquest-core",
-  "version": "6.6.0",
+  "version": "6.7.1",
   "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,46 +1,70 @@
 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(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[];
+  });
+  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}`
   ? `${T}${Capitalize<SnakeToCamelCase<U>>}`
@@ -49,52 +73,44 @@ type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}`
 type ConvertSnakeToCamel<T> = T extends (infer U)[]
   ? ConvertSnakeToCamel<U>[]
   : T extends Record<string, unknown>
-  ? {
-      [K in keyof T as K extends string
-        ? SnakeToCamelCase<K>
-        : K]: ConvertSnakeToCamel<T[K]>;
-    }
-  : T;
+    ? {
+        [K in keyof T as K extends string ? SnakeToCamelCase<K> : K]: ConvertSnakeToCamel<T[K]>;
+      }
+    : T;
 
 /**
  * Converts snake_case keys to camelCase keys in an object or array of objects
  */
 export function convertSnakeToCamel<T>(obj: T): ConvertSnakeToCamel<T> {
-    if (obj === null || obj === undefined) {
-      return obj as ConvertSnakeToCamel<T>;
-    }
-  
-    if (Array.isArray(obj)) {
-      return obj.map((item) =>
-        convertSnakeToCamel(item)
-      ) as ConvertSnakeToCamel<T>;
-    }
-  
-    if (typeof obj === "object" && obj.constructor === Object) {
-      const converted: Record<string, unknown> = {};
-  
-      for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
-          const camelKey = key.replace(/_([a-z])/g, (_, letter) =>
-            letter.toUpperCase()
-          );
-          converted[camelKey] = convertSnakeToCamel(
-            (obj as Record<string, unknown>)[key]
-          );
-        }
+  if (obj === null || obj === undefined) {
+    return obj as ConvertSnakeToCamel<T>;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => convertSnakeToCamel(item)) as ConvertSnakeToCamel<T>;
+  }
+
+  if (typeof obj === "object" && obj.constructor === Object) {
+    const converted: Record<string, unknown> = {};
+
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+        converted[camelKey] = convertSnakeToCamel((obj as Record<string, unknown>)[key]);
       }
-  
-      return converted as ConvertSnakeToCamel<T>;
     }
-  
-    return obj as ConvertSnakeToCamel<T>;
+
+    return converted as ConvertSnakeToCamel<T>;
   }
-  
 
-export {
-    getLocationIdsFromAchievementRule,
-    getActionsFromAchievementRule,
-    isAchievementCompleted
+  return obj as ConvertSnakeToCamel<T>;
 }
 
-export { useClearAchievementProgressCache } from './useClearAchievementProgressCache';
+export {
+  getLocationIdsFromAchievementRule,
+  getActionsFromAchievementRule,
+  getSurveyIdsFromAchievementRule,
+  isAchievementCompleted,
+};
+
+export { useClearAchievementProgressCache } from "./useClearAchievementProgressCache";

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

@@ -5,29 +5,25 @@ export function useClearAchievementProgressCache() {
   const queryClient = useQueryClient();
 
   const clearCache = useCallback(
-    (options?: {
-      refetchActive?: boolean;
-      refetchInactive?: boolean;
-    }) => {
+    (options?: { refetchActive?: boolean; refetchInactive?: boolean }) => {
       const { refetchActive = true, refetchInactive = false } = options || {};
 
-      // Clear all achievement progress related queries
-      // Query keys from packages/achievement/src/hooks/useAchievement.ts
-      const queryKeyPatterns = [
-        ["deviceUidAchievementProgressMany"], // Device UID progress (line 69)
-        ["achievementProgressMany"], // All achievements (line 39)
-      ];
+      // 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', ...]
 
-      queryKeyPatterns.forEach((queryKey) => {
-        // Invalidate the queries to mark them as stale
-        queryClient.invalidateQueries({
-          queryKey,
-          refetchType: refetchActive
-            ? refetchInactive
-              ? "all"
-              : "active"
-            : "none",
-        });
+      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");

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,138 @@
+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";

package/tsup.config.ts

@@ -8,6 +8,7 @@ export default defineConfig((options: Options) => ({
   },
   format: ["esm", "cjs"],
   outExtension: ({ format }) => ({ js: format === "cjs" ? ".cjs" : ".js" }),
+  target: "es2019", // Transpile optional chaining (?.) and nullish coalescing (??) for CJS Node.js SSR compatibility
   dts: true,
   clean: true,
   external: [