@vue-skuilder/db 0.1.11-9 → 0.1.12

package/dist/impl/static/index.js

@@ -146,9 +146,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;
   }
@@ -302,42 +302,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`);
           }
@@ -425,7 +441,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;
@@ -503,13 +519,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"
@@ -520,12 +539,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))
     });
   }
@@ -545,6 +626,7 @@ var init_navigators = __esm({
     init_();
     Navigators = /* @__PURE__ */ ((Navigators2) => {
       Navigators2["ELO"] = "elo";
+      Navigators2["HARDCODED"] = "hardcodedOrder";
       return Navigators2;
     })(Navigators || {});
     ContentNavigator = class {
@@ -557,7 +639,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}`);
@@ -649,6 +731,25 @@ 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;
+}
 var import_cross_fetch2, import_moment4, import_process, isBrowser, GUEST_LOCAL_DB, localUserDB, pouchDBincludeCredentialsConfig;
 var init_couch = __esm({
   "src/impl/couch/index.ts"() {
@@ -911,6 +1012,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);
       }
@@ -957,7 +1061,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 {
@@ -1237,8 +1346,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 = [
@@ -1256,10 +1375,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);
@@ -1336,17 +1460,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}
@@ -1358,8 +1486,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) => {
@@ -1394,6 +1527,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)}`);
+          }
         }
       }
       /**
@@ -2098,7 +2242,10 @@ var init_courseDB3 = __esm({
         };
       }
       async getCardsByELO(elo, limit) {
-        return this.unpacker.queryByElo(elo, limit || 25);
+        return (await this.unpacker.queryByElo(elo, limit || 25)).map((card) => {
+          const [courseID, cardID, elo2] = card.split("-");
+          return { courseID, cardID, elo: elo2 ? parseInt(elo2) : void 0 };
+        });
       }
       async getCardEloData(cardIds) {
         const results = await Promise.all(
@@ -2116,16 +2263,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;
@@ -2142,14 +2293,19 @@ var init_courseDB3 = __esm({
         } else if (options.elo === "random") {
           targetElo = 800 + Math.random() * 400;
         }
-        let cardIds = await this.unpacker.queryByElo(targetElo, options.limit * 2);
+        let cardIds = (await this.unpacker.queryByElo(targetElo, options.limit * 2)).map((c) => {
+          return {
+            cardID: c,
+            courseID: this.courseId
+          };
+        });
         if (filter) {
           cardIds = cardIds.filter(filter);
         }
-        return cardIds.slice(0, options.limit).map((cardId) => ({
+        return cardIds.slice(0, options.limit).map((card) => ({
           status: "new",
-          qualifiedID: `${this.courseId}-${cardId}`,
-          cardID: cardId,
+          // qualifiedID: `${this.courseId}-${cardId}`,
+          cardID: card.cardID,
           contentSourceType: "course",
           contentSourceID: this.courseId,
           courseID: this.courseId
@@ -2301,7 +2457,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",
@@ -2341,6 +2497,16 @@ var init_courseDB3 = __esm({
       async getAttachmentBlob(docId, attachmentName) {
         return this.unpacker.getAttachmentBlob(docId, attachmentName);
       }
+      // Admin search methods
+      async searchCards(_query) {
+        return [];
+      }
+      async find(_request) {
+        return {
+          docs: [],
+          warning: "Find operations not supported in static mode"
+        };
+      }
     };
   }
 });
@@ -2356,11 +2522,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(
@@ -2448,23 +2620,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() {
@@ -2478,13 +2676,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");
@@ -2492,6 +2690,12 @@ var init_StaticDataLayerProvider = __esm({
       getAdminDB() {
         throw new Error("Admin functions not supported in static mode");
       }
+      async createUserReaderForUser(targetUsername) {
+        logger.warn(`StaticDataLayerProvider: Multi-user access not supported in static mode`);
+        logger.warn(`Request: trying to access data for ${targetUsername}`);
+        logger.warn(`Returning current user's data instead`);
+        return this.getUserDB();
+      }
       isReadOnly() {
         return true;
       }