@vue-skuilder/db 0.1.11-9 → 0.1.12

package/dist/core/index.js

@@ -187,9 +187,9 @@ var init_pouchdb_setup = __esm({
     import_pouchdb.default.plugin(import_pouchdb_find.default);
     import_pouchdb.default.plugin(import_pouchdb_authentication.default);
     import_pouchdb.default.defaults({
-      ajax: {
-        timeout: 6e4
-      }
+      // ajax: {
+      //   timeout: 60000,
+      // },
     });
     pouchdb_setup_default = import_pouchdb.default;
   }
@@ -343,42 +343,58 @@ 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) {
             this.inprogressUpdates[id] = true;
-            try {
-              let doc = await this.readDB.get(id);
-              logger.debug(`Retrieved doc: ${id}`);
-              while (this.pendingUpdates[id].length !== 0) {
-                const update = this.pendingUpdates[id].splice(0, 1)[0];
-                if (typeof update === "function") {
-                  doc = { ...doc, ...update(doc) };
+            const MAX_RETRIES = 5;
+            for (let i = 0; i < MAX_RETRIES; i++) {
+              try {
+                const doc = await this.readDB.get(id);
+                logger.debug(`Retrieved doc: ${id}`);
+                let updatedDoc = { ...doc };
+                const updatesToApply = [...this.pendingUpdates[id]];
+                for (const update of updatesToApply) {
+                  if (typeof update === "function") {
+                    updatedDoc = { ...updatedDoc, ...update(updatedDoc) };
+                  } else {
+                    updatedDoc = {
+                      ...updatedDoc,
+                      ...update
+                    };
+                  }
+                }
+                await this.writeDB.put(updatedDoc);
+                logger.debug(`Put doc: ${id}`);
+                this.pendingUpdates[id].splice(0, updatesToApply.length);
+                if (this.pendingUpdates[id].length === 0) {
+                  this.inprogressUpdates[id] = false;
+                  delete this.inprogressUpdates[id];
                 } else {
-                  doc = {
-                    ...doc,
-                    ...update
-                  };
+                  return this.applyUpdates(id);
+                }
+                return updatedDoc;
+              } catch (e) {
+                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]) {
+                    delete this.pendingUpdates[id];
+                  }
+                  logger.error(`Error on attemped update (retry ${i}): ${JSON.stringify(e)}`);
+                  throw e;
                 }
               }
-              await this.writeDB.put(doc);
-              logger.debug(`Put doc: ${id}`);
-              if (this.pendingUpdates[id].length === 0) {
-                this.inprogressUpdates[id] = false;
-                delete this.inprogressUpdates[id];
-              } else {
-                return this.applyUpdates(id);
-              }
-              return doc;
-            } catch (e) {
-              delete this.inprogressUpdates[id];
-              if (this.pendingUpdates[id]) {
-                delete this.pendingUpdates[id];
-              }
-              logger.error(`Error on attemped update: ${JSON.stringify(e)}`);
-              throw e;
             }
+            throw new Error(`UpdateQueue failed for doc ${id} after ${MAX_RETRIES} retries.`);
           } else {
             throw new Error(`Empty Updates Queue Triggered`);
           }
@@ -629,7 +645,7 @@ function getCourseDB(courseID) {
   const dbName = `coursedb-${courseID}`;
   return new pouchdb_setup_default(
     ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
-    pouchDBincludeCredentialsConfig
+    createPouchDBConfig()
   );
 }
 var import_common, import_common2, import_common3, import_uuid, AlreadyTaggedErr;
@@ -713,13 +729,16 @@ var init_elo = __esm({
       }
       async getNewCards(limit = 99) {
         const activeCards = await this.user.getActiveCards();
-        return (await this.course.getCardsCenteredAtELO({ limit, elo: "user" }, (c) => {
-          if (activeCards.some((ac) => c.includes(ac))) {
-            return false;
-          } else {
-            return true;
+        return (await this.course.getCardsCenteredAtELO(
+          { limit, elo: "user" },
+          (c) => {
+            if (activeCards.some((ac) => c.cardID === ac.cardID)) {
+              return false;
+            } else {
+              return true;
+            }
           }
-        })).map((c) => {
+        )).map((c) => {
           return {
             ...c,
             status: "new"
@@ -730,12 +749,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))
     });
   }
@@ -755,6 +836,7 @@ var init_navigators = __esm({
     init_();
     Navigators = /* @__PURE__ */ ((Navigators2) => {
       Navigators2["ELO"] = "elo";
+      Navigators2["HARDCODED"] = "hardcodedOrder";
       return Navigators2;
     })(Navigators || {});
     ContentNavigator = class {
@@ -767,7 +849,7 @@ var init_navigators = __esm({
       static async create(user, course, strategyData) {
         const implementingClass = strategyData.implementingClass;
         let NavigatorImpl;
-        const variations = ["", ".js", ".ts"];
+        const variations = [".ts", ".js", ""];
         for (const ext of variations) {
           try {
             const module2 = await globImport(`./${implementingClass}${ext}`);
@@ -979,6 +1061,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) {
@@ -1026,7 +1125,13 @@ var init_courseDB = __esm({
           } else {
             return s;
           }
-        }).map((c) => `${this.id}-${c.id}-${c.key}`);
+        }).map((c) => {
+          return {
+            courseID: this.id,
+            cardID: c.id,
+            elo: c.key
+          };
+        });
         const str = `below:
 ${below.rows.map((r) => `	${r.id}-${r.key}
 `)}
@@ -1081,7 +1186,13 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
         }
       }
       async addTagToCard(cardId, tagId, updateELO) {
-        return await addTagToCard(this.id, cardId, tagId, (await this._getCurrentUser()).getUsername(), updateELO);
+        return await addTagToCard(
+          this.id,
+          cardId,
+          tagId,
+          (await this._getCurrentUser()).getUsername(),
+          updateELO
+        );
       }
       async removeTagFromCard(cardId, tagId) {
         return await removeTagFromCard(this.id, cardId, tagId);
@@ -1150,23 +1261,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",
@@ -1174,14 +1271,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}`);
@@ -1189,9 +1297,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",
@@ -1274,17 +1405,93 @@ ${above.rows.map((r) => `	${r.id}-${r.key}
           selectedCards.push(card);
         }
         return selectedCards.map((c) => {
-          const split = c.split("-");
           return {
             courseID: this.id,
-            cardID: split[1],
-            qualifiedID: `${split[0]}-${split[1]}`,
+            cardID: c.cardID,
             contentSourceType: "course",
             contentSourceID: this.id,
+            elo: c.elo,
             status: "new"
           };
         });
       }
+      // Admin search methods
+      async searchCards(query) {
+        logger.log(`[CourseDB ${this.id}] Searching for: "${query}"`);
+        let displayableData;
+        try {
+          displayableData = await this.db.find({
+            selector: {
+              docType: "DISPLAYABLE_DATA",
+              "data.0.data": { $regex: `.*${query}.*` }
+            }
+          });
+          logger.log(`[CourseDB ${this.id}] Regex search on data[0].data successful`);
+        } catch (regexError) {
+          logger.log(
+            `[CourseDB ${this.id}] Regex search failed, falling back to manual search:`,
+            regexError
+          );
+          const allDisplayable = await this.db.find({
+            selector: {
+              docType: "DISPLAYABLE_DATA"
+            }
+          });
+          logger.log(
+            `[CourseDB ${this.id}] Retrieved ${allDisplayable.docs.length} documents for manual filtering`
+          );
+          displayableData = {
+            docs: allDisplayable.docs.filter((doc) => {
+              const docString = JSON.stringify(doc).toLowerCase();
+              const match = docString.includes(query.toLowerCase());
+              if (match) {
+                logger.log(`[CourseDB ${this.id}] Manual match found in document: ${doc._id}`);
+              }
+              return match;
+            })
+          };
+        }
+        logger.log(
+          `[CourseDB ${this.id}] Found ${displayableData.docs.length} displayable data documents`
+        );
+        if (displayableData.docs.length === 0) {
+          const allDisplayableData = await this.db.find({
+            selector: {
+              docType: "DISPLAYABLE_DATA"
+            },
+            limit: 5
+            // Just sample a few
+          });
+          logger.log(
+            `[CourseDB ${this.id}] Sample displayable data:`,
+            allDisplayableData.docs.map((d) => ({
+              id: d._id,
+              docType: d.docType,
+              dataStructure: d.data ? Object.keys(d.data) : "no data field",
+              dataContent: d.data,
+              fullDoc: d
+            }))
+          );
+        }
+        const allResults = [];
+        for (const dd of displayableData.docs) {
+          const cards = await this.db.find({
+            selector: {
+              docType: "CARD",
+              id_displayable_data: { $in: [dd._id] }
+            }
+          });
+          logger.log(
+            `[CourseDB ${this.id}] Displayable data ${dd._id} linked to ${cards.docs.length} cards`
+          );
+          allResults.push(...cards.docs);
+        }
+        logger.log(`[CourseDB ${this.id}] Total cards found: ${allResults.length}`);
+        return allResults;
+      }
+      async find(request) {
+        return this.db.find(request);
+      }
     };
   }
 });
@@ -1349,7 +1556,7 @@ var init_classroomDB2 = __esm({
         const dbName = `classdb-student-${this._id}`;
         this._db = new pouchdb_setup_default(
           ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + dbName,
-          pouchDBincludeCredentialsConfig
+          createPouchDBConfig()
         );
         try {
           const cfg = await this._db.get(CLASSROOM_CONFIG);
@@ -1418,9 +1625,11 @@ var init_classroomDB2 = __esm({
             ret.push(await getCourseDB2(content.courseID).get(content.cardID));
           }
         }
-        logger.info(`New Cards from classroom ${this._cfg.name}: ${ret.map((c) => c.qualifiedID)}`);
+        logger.info(
+          `New Cards from classroom ${this._cfg.name}: ${ret.map((c) => `${c.courseID}-${c.cardID}`)}`
+        );
         return ret.filter((c) => {
-          if (activeCards.some((ac) => c.qualifiedID.includes(ac))) {
+          if (activeCards.some((ac) => c.cardID === ac.cardID)) {
             return false;
           } else {
             return true;
@@ -1473,10 +1682,29 @@ var init_CouchDBSyncStrategy = __esm({
 });
 
 // src/impl/couch/index.ts
+function createPouchDBConfig() {
+  const hasExplicitCredentials = ENV.COUCHDB_USERNAME && ENV.COUCHDB_PASSWORD;
+  const isNodeEnvironment = typeof window === "undefined";
+  if (hasExplicitCredentials && isNodeEnvironment) {
+    return {
+      fetch(url, opts = {}) {
+        const basicAuth = btoa(`${ENV.COUCHDB_USERNAME}:${ENV.COUCHDB_PASSWORD}`);
+        const headers = new Headers(opts.headers || {});
+        headers.set("Authorization", `Basic ${basicAuth}`);
+        const newOpts = {
+          ...opts,
+          headers
+        };
+        return pouchdb_setup_default.fetch(url, newOpts);
+      }
+    };
+  }
+  return pouchDBincludeCredentialsConfig;
+}
 function getCourseDB2(courseID) {
   return new pouchdb_setup_default(
     ENV.COUCHDB_SERVER_PROTOCOL + "://" + ENV.COUCHDB_SERVER_URL + "coursedb-" + courseID,
-    pouchDBincludeCredentialsConfig
+    createPouchDBConfig()
   );
 }
 function getCourseDocs(courseID, docIDs, options = {}) {
@@ -1768,6 +1996,9 @@ Currently logged-in as ${this._username}.`
         await this.init();
         return ret;
       }
+      async get(id) {
+        return this.localDB.get(id);
+      }
       update(id, update) {
         return this.updateQueue.update(id, update);
       }
@@ -1814,7 +2045,12 @@ Currently logged-in as ${this._username}.`
           endkey: keys.endkey,
           include_docs: true
         });
-        return reviews.rows.map((r) => `${r.doc.courseId}-${r.doc.cardId}`);
+        return reviews.rows.map((r) => {
+          return {
+            courseID: r.doc.courseId,
+            cardID: r.doc.cardId
+          };
+        });
       }
       async getActivityRecords() {
         try {
@@ -2094,8 +2330,18 @@ Currently logged-in as ${this._username}.`
         }
         this.setDBandQ();
         this.syncStrategy.startSync(this.localDB, this.remoteDB);
-        void this.applyDesignDocs();
-        void this.deduplicateReviews();
+        this.applyDesignDocs().catch((error) => {
+          log3(`Error in applyDesignDocs background task: ${error}`);
+          if (error && typeof error === "object") {
+            log3(`Full error details in applyDesignDocs: ${JSON.stringify(error)}`);
+          }
+        });
+        this.deduplicateReviews().catch((error) => {
+          log3(`Error in deduplicateReviews background task: ${error}`);
+          if (error && typeof error === "object") {
+            log3(`Full error details in background task: ${JSON.stringify(error)}`);
+          }
+        });
         _BaseUser._initialized = true;
       }
       static designDocs = [
@@ -2113,10 +2359,15 @@ Currently logged-in as ${this._username}.`
         }
       ];
       async applyDesignDocs() {
+        log3(`Starting applyDesignDocs for user: ${this._username}`);
+        log3(`Remote DB name: ${this.remoteDB.name || "unknown"}`);
         if (this._username === "admin") {
+          log3("Skipping design docs for admin user");
           return;
         }
+        log3(`Applying ${_BaseUser.designDocs.length} design docs`);
         for (const doc of _BaseUser.designDocs) {
+          log3(`Applying design doc: ${doc._id}`);
           try {
             try {
               const existingDoc = await this.remoteDB.get(doc._id);
@@ -2193,17 +2444,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}
@@ -2215,8 +2470,13 @@ Currently logged-in as ${this._username}.`
       async deduplicateReviews() {
         try {
           log3("Starting deduplication of scheduled reviews...");
+          log3(`Remote DB name: ${this.remoteDB.name || "unknown"}`);
+          log3(`Write DB name: ${this.writeDB.name || "unknown"}`);
           const reviewsMap = {};
           const duplicateDocIds = [];
+          log3(
+            `Attempting to query remoteDB for reviewCards/reviewCards. Database: ${this.remoteDB.name || "unknown"}`
+          );
           const scheduledReviews = await this.remoteDB.query("reviewCards/reviewCards");
           log3(`Found ${scheduledReviews.rows.length} scheduled reviews to process`);
           scheduledReviews.rows.forEach((r) => {
@@ -2251,6 +2511,17 @@ Currently logged-in as ${this._username}.`
           }
         } catch (error) {
           log3(`Error during review deduplication: ${error}`);
+          if (error && typeof error === "object" && "status" in error && error.status === 404) {
+            log3(
+              `Database not found (404) during review deduplication. Database: ${this.remoteDB.name || "unknown"}`
+            );
+            log3(
+              `This might indicate the user database doesn't exist or the reviewCards view isn't available`
+            );
+          }
+          if (error && typeof error === "object") {
+            log3(`Full error details: ${JSON.stringify(error)}`);
+          }
         }
       }
       /**