@vue-skuilder/db 0.1.11 → 0.1.12

package/dist/impl/static/index.mjs

@@ -279,7 +279,9 @@ var init_updateQueue = __esm({
       async applyUpdates(id) {
         logger.debug(`Applying updates on doc: ${id}`);
         if (this.inprogressUpdates[id]) {
-          await this.readDB.info();
+          while (this.inprogressUpdates[id]) {
+            await new Promise((resolve) => setTimeout(resolve, Math.random() * 50));
+          }
           return this.applyUpdates(id);
         } else {
           if (this.pendingUpdates[id] && this.pendingUpdates[id].length > 0) {
@@ -315,6 +317,9 @@ var init_updateQueue = __esm({
                 if (e.name === "conflict" && i < MAX_RETRIES - 1) {
                   logger.warn(`Conflict on update for doc ${id}, retry #${i + 1}`);
                   await new Promise((res) => setTimeout(res, 50 * Math.random()));
+                } else if (e.name === "not_found" && i === 0) {
+                  logger.warn(`Update failed for ${id} - does not exist. Throwing to caller.`);
+                  throw e;
                 } else {
                   delete this.inprogressUpdates[id];
                   if (this.pendingUpdates[id]) {
@@ -510,12 +515,74 @@ var init_elo = __esm({
   }
 });
 
+// src/core/navigators/hardcodedOrder.ts
+var hardcodedOrder_exports = {};
+__export(hardcodedOrder_exports, {
+  default: () => HardcodedOrderNavigator
+});
+var HardcodedOrderNavigator;
+var init_hardcodedOrder = __esm({
+  "src/core/navigators/hardcodedOrder.ts"() {
+    "use strict";
+    init_navigators();
+    init_logger();
+    HardcodedOrderNavigator = class extends ContentNavigator {
+      orderedCardIds = [];
+      user;
+      course;
+      constructor(user, course, strategyData) {
+        super();
+        this.user = user;
+        this.course = course;
+        if (strategyData.serializedData) {
+          try {
+            this.orderedCardIds = JSON.parse(strategyData.serializedData);
+          } catch (e) {
+            logger.error("Failed to parse serializedData for HardcodedOrderNavigator", e);
+          }
+        }
+      }
+      async getPendingReviews() {
+        const reviews = await this.user.getPendingReviews(this.course.getCourseID());
+        return reviews.map((r) => {
+          return {
+            ...r,
+            contentSourceType: "course",
+            contentSourceID: this.course.getCourseID(),
+            cardID: r.cardId,
+            courseID: r.courseId,
+            reviewID: r._id,
+            status: "review"
+          };
+        });
+      }
+      async getNewCards(limit = 99) {
+        const activeCardIds = (await this.user.getActiveCards()).map((c) => c.cardID);
+        const newCardIds = this.orderedCardIds.filter(
+          (cardId) => !activeCardIds.includes(cardId)
+        );
+        const cardsToReturn = newCardIds.slice(0, limit);
+        return cardsToReturn.map((cardId) => {
+          return {
+            cardID: cardId,
+            courseID: this.course.getCourseID(),
+            contentSourceType: "course",
+            contentSourceID: this.course.getCourseID(),
+            status: "new"
+          };
+        });
+      }
+    };
+  }
+});
+
 // import("./**/*") in src/core/navigators/index.ts
 var globImport;
 var init_ = __esm({
   'import("./**/*") in src/core/navigators/index.ts'() {
     globImport = __glob({
       "./elo.ts": () => Promise.resolve().then(() => (init_elo(), elo_exports)),
+      "./hardcodedOrder.ts": () => Promise.resolve().then(() => (init_hardcodedOrder(), hardcodedOrder_exports)),
       "./index.ts": () => Promise.resolve().then(() => (init_navigators(), navigators_exports))
     });
   }
@@ -535,6 +602,7 @@ var init_navigators = __esm({
     init_();
     Navigators = /* @__PURE__ */ ((Navigators2) => {
       Navigators2["ELO"] = "elo";
+      Navigators2["HARDCODED"] = "hardcodedOrder";
       return Navigators2;
     })(Navigators || {});
     ContentNavigator = class {
@@ -1369,17 +1437,21 @@ Currently logged-in as ${this._username}.`
         } catch (e) {
           const reason = e;
           if (reason.status === 404) {
-            const initCardHistory = {
-              _id: cardHistoryID,
-              cardID: record.cardID,
-              courseID: record.courseID,
-              records: [record],
-              lapses: 0,
-              streak: 0,
-              bestInterval: 0
-            };
-            const putResult = await this.writeDB.put(initCardHistory);
-            return { ...initCardHistory, _rev: putResult.rev };
+            try {
+              const initCardHistory = {
+                _id: cardHistoryID,
+                cardID: record.cardID,
+                courseID: record.courseID,
+                records: [record],
+                lapses: 0,
+                streak: 0,
+                bestInterval: 0
+              };
+              const putResult = await this.writeDB.put(initCardHistory);
+              return { ...initCardHistory, _rev: putResult.rev };
+            } catch (creationError) {
+              throw new Error(`Failed to create CardHistory for ${cardHistoryID}. Reason: ${creationError}`);
+            }
           } else {
             throw new Error(`putCardRecord failed because of:
   name:${reason.name}
@@ -2167,16 +2239,20 @@ var init_courseDB3 = __esm({
       async updateCardElo(cardId, _elo) {
         return { ok: true, id: cardId, rev: "1-static" };
       }
-      async getNewCards(limit) {
-        const cardIds = await this.unpacker.queryByElo(1e3, limit || 10);
-        return cardIds.map((cardId) => ({
-          status: "new",
-          qualifiedID: `${this.courseId}-${cardId}`,
-          cardID: cardId,
-          contentSourceType: "course",
-          contentSourceID: this.courseId,
-          courseID: this.courseId
-        }));
+      async getNewCards(limit = 99) {
+        const activeCards = await this.userDB.getActiveCards();
+        return (await this.getCardsCenteredAtELO({ limit, elo: "user" }, (c) => {
+          if (activeCards.some((ac) => c.cardID === ac.cardID)) {
+            return false;
+          } else {
+            return true;
+          }
+        })).map((c) => {
+          return {
+            ...c,
+            status: "new"
+          };
+        });
       }
       async getCardsCenteredAtELO(options, filter) {
         let targetElo = typeof options.elo === "number" ? options.elo : 1e3;
@@ -2357,7 +2433,7 @@ var init_courseDB3 = __esm({
       // Navigation Strategy Manager implementation
       async getNavigationStrategy(_id) {
         return {
-          id: "ELO",
+          _id: "NAVIGATION_STRATEGY-ELO",
           docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
           name: "ELO",
           description: "ELO-based navigation strategy",
@@ -2422,11 +2498,17 @@ var init_coursesDB = __esm({
         this.manifests = manifests;
       }
       async getCourseConfig(courseId) {
-        if (!this.manifests[courseId]) {
-          logger.warn(`Course ${courseId} not found`);
-          return {};
+        const manifest = this.manifests[courseId];
+        if (!manifest) {
+          logger.warn(`Course manifest for ${courseId} not found`);
+          throw new Error(`Course ${courseId} not found`);
+        }
+        if (manifest.courseConfig) {
+          return manifest.courseConfig;
+        } else {
+          logger.warn(`Course config not found in manifest for course ${courseId}`);
+          throw new Error(`Course config not found for course ${courseId}`);
         }
-        return {};
       }
       async getCourseList() {
         return Object.keys(this.manifests).map(
@@ -2514,23 +2596,49 @@ var init_StaticDataLayerProvider = __esm({
       config;
       initialized = false;
       courseUnpackers = /* @__PURE__ */ new Map();
+      manifests = {};
       constructor(config) {
         this.config = {
-          staticContentPath: config.staticContentPath || "/static-courses",
           localStoragePrefix: config.localStoragePrefix || "skuilder-static",
-          manifests: config.manifests || {}
+          rootManifest: config.rootManifest || { dependencies: {} },
+          rootManifestUrl: config.rootManifestUrl || "/"
         };
       }
+      async resolveCourseDependencies() {
+        logger.info("[StaticDataLayerProvider] Starting course dependency resolution...");
+        const rootManifest = this.config.rootManifest;
+        for (const [courseName, courseUrl] of Object.entries(rootManifest.dependencies || {})) {
+          try {
+            logger.debug(`[StaticDataLayerProvider] Resolving dependency: ${courseName} from ${courseUrl}`);
+            const courseManifestUrl = new URL(courseUrl, this.config.rootManifestUrl).href;
+            const courseJsonResponse = await fetch(courseManifestUrl);
+            if (!courseJsonResponse.ok) {
+              throw new Error(`Failed to fetch course manifest for ${courseName}`);
+            }
+            const courseJson = await courseJsonResponse.json();
+            if (courseJson.content && courseJson.content.manifest) {
+              const baseUrl = new URL(".", courseManifestUrl).href;
+              const finalManifestUrl = new URL(courseJson.content.manifest, courseManifestUrl).href;
+              const finalManifestResponse = await fetch(finalManifestUrl);
+              if (!finalManifestResponse.ok) {
+                throw new Error(`Failed to fetch final content manifest for ${courseName} at ${finalManifestUrl}`);
+              }
+              const finalManifest = await finalManifestResponse.json();
+              this.manifests[courseName] = finalManifest;
+              const unpacker = new StaticDataUnpacker(finalManifest, baseUrl);
+              this.courseUnpackers.set(courseName, unpacker);
+              logger.info(`[StaticDataLayerProvider] Successfully resolved and prepared course: ${courseName}`);
+            }
+          } catch (e) {
+            logger.error(`[StaticDataLayerProvider] Failed to resolve dependency ${courseName}:`, e);
+          }
+        }
+        logger.info("[StaticDataLayerProvider] Course dependency resolution complete.");
+      }
       async initialize() {
         if (this.initialized) return;
         logger.info("Initializing static data layer provider");
-        for (const [courseId, manifest] of Object.entries(this.config.manifests)) {
-          const unpacker = new StaticDataUnpacker(
-            manifest,
-            `${this.config.staticContentPath}/${courseId}`
-          );
-          this.courseUnpackers.set(courseId, unpacker);
-        }
+        await this.resolveCourseDependencies();
         this.initialized = true;
       }
       async teardown() {
@@ -2544,13 +2652,13 @@ var init_StaticDataLayerProvider = __esm({
       getCourseDB(courseId) {
         const unpacker = this.courseUnpackers.get(courseId);
         if (!unpacker) {
-          throw new Error(`Course ${courseId} not found in static data`);
+          throw new Error(`Course ${courseId} not found or failed to initialize in static data layer.`);
         }
-        const manifest = this.config.manifests[courseId];
+        const manifest = this.manifests[courseId];
         return new StaticCourseDB(courseId, unpacker, this.getUserDB(), manifest);
       }
       getCoursesDB() {
-        return new StaticCoursesDB(this.config.manifests);
+        return new StaticCoursesDB(this.manifests);
       }
       async getClassroomDB(_classId, _type) {
         throw new Error("Classrooms not supported in static mode");