@vue-skuilder/db 0.1.11 → 0.1.12

package/dist/impl/couch/index.mjs

@@ -150,7 +150,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) {
@@ -186,6 +188,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]) {
@@ -636,12 +641,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))
     });
   }
@@ -661,6 +728,7 @@ var init_navigators = __esm({
     init_();
     Navigators = /* @__PURE__ */ ((Navigators2) => {
       Navigators2["ELO"] = "elo";
+      Navigators2["HARDCODED"] = "hardcodedOrder";
       return Navigators2;
     })(Navigators || {});
     ContentNavigator = class {
@@ -977,6 +1045,23 @@ var init_courseDB = __esm({
         if (!doc.docType || !(doc.docType === "CARD" /* CARD */)) {
           throw new Error(`failed to remove ${id} from course ${this.id}. id does not point to a card`);
         }
+        try {
+          const appliedTags = await this.getAppliedTags(id);
+          const results = await Promise.allSettled(
+            appliedTags.rows.map(async (tagRow) => {
+              const tagId = tagRow.id;
+              await this.removeTagFromCard(id, tagId);
+            })
+          );
+          results.forEach((result, index) => {
+            if (result.status === "rejected") {
+              const tagId = appliedTags.rows[index].id;
+              logger.error(`Failed to remove card ${id} from tag ${tagId}: ${result.reason}`);
+            }
+          });
+        } catch (error) {
+          logger.error(`Error removing card ${id} from tags: ${error}`);
+        }
         return this.db.remove(doc);
       }
       async getCardDisplayableDataIDs(id) {
@@ -1160,23 +1245,9 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
       ////////////////////////////////////
       getNavigationStrategy(id) {
         logger.debug(`[courseDB] Getting navigation strategy: ${id}`);
-        const strategy = {
-          id: "ELO",
-          docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
-          name: "ELO",
-          description: "ELO-based navigation strategy for ordering content by difficulty",
-          implementingClass: "elo" /* ELO */,
-          course: this.id,
-          serializedData: ""
-          // serde is a noop for ELO navigator.
-        };
-        return Promise.resolve(strategy);
-      }
-      getAllNavigationStrategies() {
-        logger.debug("[courseDB] Returning hard-coded navigation strategies");
-        const strategies = [
-          {
-            id: "ELO",
+        if (id == "") {
+          const strategy = {
+            _id: "NAVIGATION_STRATEGY-ELO",
             docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
             name: "ELO",
             description: "ELO-based navigation strategy for ordering content by difficulty",
@@ -1184,14 +1255,25 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
             course: this.id,
             serializedData: ""
             // serde is a noop for ELO navigator.
-          }
-        ];
-        return Promise.resolve(strategies);
+          };
+          return Promise.resolve(strategy);
+        } else {
+          return this.db.get(id);
+        }
       }
-      addNavigationStrategy(data) {
-        logger.debug(`[courseDB] Adding navigation strategy: ${data.id}`);
-        logger.debug(JSON.stringify(data));
-        return Promise.resolve();
+      async getAllNavigationStrategies() {
+        const prefix = DocTypePrefixes["NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */];
+        const result = await this.db.allDocs({
+          startkey: prefix,
+          endkey: `${prefix}\uFFF0`,
+          include_docs: true
+        });
+        return result.rows.map((row) => row.doc);
+      }
+      async addNavigationStrategy(data) {
+        logger.debug(`[courseDB] Adding navigation strategy: ${data._id}`);
+        return this.db.put(data).then(() => {
+        });
       }
       updateNavigationStrategy(id, data) {
         logger.debug(`[courseDB] Updating navigation strategy: ${id}`);
@@ -1199,9 +1281,32 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
         return Promise.resolve();
       }
       async surfaceNavigationStrategy() {
+        try {
+          const config = await this.getCourseConfig();
+          if (config.defaultNavigationStrategyId) {
+            try {
+              const strategy = await this.getNavigationStrategy(config.defaultNavigationStrategyId);
+              if (strategy) {
+                logger.debug(`Surfacing strategy ${strategy.name} from course config`);
+                return strategy;
+              }
+            } catch (e) {
+              logger.warn(
+                // @ts-expect-error tmp: defaultNavigationStrategyId property does not yet exist
+                `Failed to load strategy '${config.defaultNavigationStrategyId}' specified in course config. Falling back to ELO.`,
+                e
+              );
+            }
+          }
+        } catch (e) {
+          logger.warn(
+            "Could not retrieve course config to determine navigation strategy. Falling back to ELO.",
+            e
+          );
+        }
         logger.warn(`Returning hard-coded default ELO navigator`);
         const ret = {
-          id: "ELO",
+          _id: "NAVIGATION_STRATEGY-ELO",
           docType: "NAVIGATION_STRATEGY" /* NAVIGATION_STRATEGY */,
           name: "ELO",
           description: "ELO-based navigation strategy",
@@ -2576,17 +2681,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}