@crimson-education/sdk 0.3.5 → 0.3.6

package/dist/react/hooks/useTasks.d.ts

@@ -14,6 +14,14 @@ export declare const taskKeys: {
 };
 export declare function useTasks(missionId: string | null, enabled: boolean): import("@tanstack/react-query").UseQueryResult<Task[], Error>;
 export declare function useTaskCreators(roadmapId: string | null, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<User[], Error>;
+export declare class ActivityLoader {
+    private client;
+    private queue;
+    private timeout;
+    constructor(client: any);
+    load(id: string, type: string): Promise<ActionItemActivityBrief[]>;
+    private flush;
+}
 export declare function useTaskActivities(actionItemIds: string[], type?: string, enabled?: boolean): {
     data: Record<string, ActionItemActivityBrief[]>;
     isLoading: boolean;

package/dist/react/hooks/useTasks.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.taskKeys = void 0;
+exports.ActivityLoader = exports.taskKeys = void 0;
 exports.useTasks = useTasks;
 exports.useTaskCreators = useTaskCreators;
 exports.useTaskActivities = useTaskActivities;
@@ -66,72 +66,70 @@ function useTaskCreators(roadmapId, enabled = true) {
         enabled: !!roadmapId && enabled,
     });
 }
-function useTaskActivities(actionItemIds, type = "duedate", enabled = true) {
-    const client = (0, provider_1.useCrimsonClient)();
-    const queryClient = (0, react_query_1.useQueryClient)();
-    const STALE_TIME = 5 * 60 * 1000;
-    // 1. Use useQueries to READ from cache.
-    // We disable them so they never trigger individual fetches.
-    // They effectively act as observers of the cache.
-    const queries = (0, react_query_1.useQueries)({
-        queries: actionItemIds.map((id) => ({
-            queryKey: exports.taskKeys.activity(id, type),
-            // No queryFn needed because we never enable it to fetch
-            enabled: false,
-        })),
-    });
-    // 2. Manage fetching via side-effect
-    (0, react_1.useEffect)(() => {
-        if (!enabled || actionItemIds.length === 0)
-            return;
-        const now = Date.now();
-        const idsToFetch = actionItemIds.filter((id) => {
-            const state = queryClient.getQueryState(exports.taskKeys.activity(id, type));
-            // If no data, need fetch
-            if (!state || !state.data)
-                return true;
-            // If data exists but is stale, need fetch
-            if (state.dataUpdatedAt && (now - state.dataUpdatedAt > STALE_TIME)) {
-                return true;
+class ActivityLoader {
+    constructor(client) {
+        this.queue = new Map();
+        this.timeout = new Map();
+        this.client = client;
+    }
+    load(id, type) {
+        const key = type;
+        if (!this.queue.has(key)) {
+            this.queue.set(key, []);
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.get(key).push({ id, type, resolve, reject });
+            if (!this.timeout.has(key)) {
+                const timeout = setTimeout(() => {
+                    this.timeout.delete(key);
+                    this.flush(key);
+                }, 50);
+                this.timeout.set(key, timeout);
             }
-            return false;
         });
-        if (idsToFetch.length === 0)
-            return;
-        // Deduplicate IDs just in case
-        const uniqueIdsToFetch = [...new Set(idsToFetch)];
-        // Perform batch fetch
-        const fetchBatch = () => __awaiter(this, void 0, void 0, function* () {
+    }
+    flush(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const items = this.queue.get(key);
+            this.queue.delete(key);
+            if (!items || items.length === 0)
+                return;
+            const uniqueIds = Array.from(new Set(items.map(i => i.id)));
+            const type = items[0].type; // All items in this queue have same type
             try {
-                const result = yield client.tasks.getActivities(uniqueIdsToFetch, type);
-                // Update cache for each ID
-                // Note: We update ALL requested IDs. If an ID is missing in result, 
-                // it implies no activities, so we set empty array to prevent infinite refetching.
-                uniqueIdsToFetch.forEach(id => {
-                    const activities = result[id] || [];
-                    queryClient.setQueryData(exports.taskKeys.activity(id, type), activities);
+                const result = yield this.client.tasks.getActivities(uniqueIds, type);
+                items.forEach(({ id, resolve }) => {
+                    resolve(result[id] || []);
                 });
             }
             catch (error) {
-                console.error("Failed to batch fetch activities", error);
+                items.forEach(({ reject }) => reject(error));
             }
         });
-        fetchBatch();
-        // We intentionally do not include queryClient deeply in deps if not needed, 
-        // but here it's stable. 
-        // We rely on actionItemIds changing (scroll) or enabled changing to trigger this.
-        // For periodic polling of staleness, one might need a timer, but for now 
-        // check-on-mount/update is sufficient.
-    }, [actionItemIds, type, enabled, client, queryClient]); // STALE_TIME constant
-    const isLoading = queries.some((q) => !q.data && enabled); // If enabled and no data, we are effectively loading
-    const data = {};
-    queries.forEach((q, index) => {
-        // q.data comes from cache
-        if (q.data) {
-            data[actionItemIds[index]] = q.data;
+    }
+}
+exports.ActivityLoader = ActivityLoader;
+function useTaskActivities(actionItemIds, type = "duedate", enabled = true) {
+    const client = (0, provider_1.useCrimsonClient)();
+    const loaderRef = (0, react_1.useMemo)(() => new ActivityLoader(client), [client]);
+    return (0, react_query_1.useQueries)({
+        queries: actionItemIds.map((id) => ({
+            queryKey: exports.taskKeys.activity(id, type),
+            queryFn: () => loaderRef.load(id, type),
+            enabled: enabled,
+            staleTime: Infinity, // Cache forever until invalidated
+        })),
+        combine: (results) => {
+            const data = {};
+            const isLoading = results.some((r) => r.isLoading);
+            results.forEach((r, index) => {
+                if (r.data) {
+                    data[actionItemIds[index]] = r.data;
+                }
+            });
+            return { data, isLoading };
         }
     });
-    return { data, isLoading };
 }
 function useAllUserTasks(missionLinkIds, enabled) {
     const client = (0, provider_1.useCrimsonClient)();
@@ -425,8 +423,12 @@ function useBulkUpdateTasks(options) {
                 queryClient.setQueryData(JSON.parse(keyStr), old);
             });
         },
-        onSettled: () => {
+        onSettled: (data, error, variables) => {
             queryClient.invalidateQueries({ queryKey: exports.taskKeys.all });
+            // Invalidate activities for all updated tasks
+            variables.ids.forEach(id => {
+                queryClient.invalidateQueries({ queryKey: exports.taskKeys.activitiesOfTask(id) });
+            });
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crimson-education/sdk",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Crimson SDK for accessing Crimson App APIs",
   "main": "dist/index.js",
   "module": "dist/index.js",