@playcademy/sdk 0.9.0 → 0.9.1-beta.2

package/dist/index.js

@@ -1953,17 +1953,21 @@ function createTimebackActivityTracker(client) {
     }
   }
   return {
+    currentRunId() {
+      return currentActivity?.runId;
+    },
     startActivity(metadata, options) {
       if (options?.runId !== undefined && !isValidUUID(options.runId)) {
         throw new Error(`startActivity: \`runId\` must be a UUID (received \`${JSON.stringify(options.runId)}\`). Use crypto.randomUUID() or persist a previously-generated UUID.`);
       }
       cleanupListeners();
       const now = Date.now();
+      const runId = options?.runId ?? crypto.randomUUID();
       const heartbeatIntervalMs = normalizeDelayMs(options?.heartbeatIntervalMs, DEFAULT_HEARTBEAT_INTERVAL_MS, false);
       const pausedHeartbeatTimeoutMs = normalizeDelayMs(options?.pausedHeartbeatTimeoutMs ?? options?.hiddenTimeoutMs, DEFAULT_PAUSED_HEARTBEAT_TIMEOUT_MS, false);
       const inactivityTimeoutMs = normalizeDelayMs(options?.inactivityTimeoutMs, DEFAULT_INACTIVITY_TIMEOUT_MS, false);
       currentActivity = {
-        runId: options?.runId ?? crypto.randomUUID(),
+        runId,
         resumeId: crypto.randomUUID(),
         startTime: now,
         metadata,
@@ -2006,6 +2010,7 @@ function createTimebackActivityTracker(client) {
       messaging.listen("PLAYCADEMY_PAUSE" /* PAUSE */, boundShellPauseHandler);
       messaging.listen("PLAYCADEMY_RESUME" /* RESUME */, boundShellResumeHandler);
       syncInactivityTracking();
+      return { runId };
     },
     pauseActivity() {
       if (!currentActivity) {
@@ -2095,6 +2100,15 @@ function createTimebackUserStore(client) {
         enrollments: response.enrollments,
         organizations: response.organizations
       };
+    },
+    setEnrollments(enrollments) {
+      const base = override ?? client["initPayload"]?.timeback;
+      override = base ? { ...base, enrollments } : {
+        id: undefined,
+        role: undefined,
+        enrollments,
+        organizations: []
+      };
     }
   };
 }
@@ -2110,20 +2124,50 @@ function createTimebackEngine(client) {
     ttl: 5000,
     keyPrefix: "game.timeback.xp"
   });
+  const enrollmentsCache = createTTLCache({
+    ttl: 5 * 60 * 1000,
+    keyPrefix: "game.timeback.enrollments"
+  });
   async function applyPromotion(promotion) {
     if (promotion.status !== "promoted" && promotion.status !== "already-promoted") {
       return;
     }
     userCache.clear("current");
+    enrollmentsCache.clear("current");
     try {
       await userStore.refresh();
     } catch {}
   }
   const activityTracker = createTimebackActivityTracker(client);
+  async function refreshUserContext() {
+    const context = await userStore.refresh();
+    enrollmentsCache.clear("current");
+    return context;
+  }
+  async function refreshEnrollmentSlice(options) {
+    const enrollments = await enrollmentsCache.get("current", async () => {
+      const response = await client["request"]("/timeback/user/enrollments", "GET");
+      userStore.setEnrollments(response);
+      userCache.clear("current");
+      return response;
+    }, options);
+    userStore.setEnrollments(enrollments);
+    return userStore.snapshot();
+  }
   return {
     user: {
       snapshot: () => userStore.snapshot(),
-      fetch: (options) => userCache.get("current", () => userStore.refresh(), options),
+      fetch: (options) => userCache.get("current", refreshUserContext, options),
+      refresh: (options) => {
+        if (!options?.only.includes("enrollments")) {
+          throw new Error("At least one TimeBack user refresh field must be selected");
+        }
+        return refreshEnrollmentSlice({
+          force: options.force,
+          skipCache: options.skipCache,
+          ttl: options.ttl
+        });
+      },
       xp: {
         fetch: (options) => {
           const cacheKey = [
@@ -2150,6 +2194,7 @@ function createTimebackEngine(client) {
       }
     },
     activity: {
+      currentRunId: activityTracker.currentRunId,
       start: activityTracker.startActivity,
       pause: activityTracker.pauseActivity,
       resume: activityTracker.resumeActivity,
@@ -2184,6 +2229,7 @@ function createTimebackNamespace(client) {
           return engine.user.snapshot()?.organizations ?? [];
         },
         fetch: (options) => engine.user.fetch(options),
+        refresh: (options) => engine.user.refresh(options),
         xp: {
           fetch: async (options = {}) => {
             const hasGrade = options.grade !== undefined;
@@ -2209,9 +2255,13 @@ function createTimebackNamespace(client) {
         }
       };
     },
+    get currentRunId() {
+      assertPlatformMode(client, "timeback.currentRunId");
+      return engine.activity.currentRunId();
+    },
     startActivity: (metadata, options) => {
       assertPlatformMode(client, "timeback.startActivity()");
-      engine.activity.start(metadata, options);
+      return engine.activity.start(metadata, options);
     },
     pauseActivity: () => {
       assertPlatformMode(client, "timeback.pauseActivity()");