@vue-skuilder/db 0.1.11-7 → 0.1.11

package/dist/impl/static/index.d.mts

@@ -1,8 +1,8 @@
-import { U as UserDBInterface, C as CourseDBInterface, a as CoursesDBInterface, b as ClassroomDBInterface, A as AdminDBInterface, c as CourseInfo, S as StudySessionNewItem, D as DataLayerResult, d as ContentNavigationStrategyData, e as StudySessionReviewItem, f as ScheduledCard } from '../../userDB-C33Hzjgn.mjs';
-import { D as DataLayerProvider } from '../../dataLayerProvider-BInqI_RF.mjs';
-import { S as StaticCourseManifest } from '../../types-DC-ckZug.mjs';
+import { U as UserDBInterface, C as CourseDBInterface, b as CoursesDBInterface, c as ClassroomDBInterface, A as AdminDBInterface, a as UserDBReader, d as CourseInfo, S as StudySessionNewItem, D as DataLayerResult, e as ContentNavigationStrategyData, f as StudySessionReviewItem, g as ScheduledCard } from '../../userDB-DJ8HMw83.mjs';
+import { D as DataLayerProvider } from '../../dataLayerProvider-VieuAAkV.mjs';
+import { S as StaticCourseManifest } from '../../types-Che4wTwA.mjs';
 import { CourseConfig, CourseElo, DataShape } from '@vue-skuilder/common';
-import { S as SkuilderCourseData, T as TagStub, a as Tag } from '../../types-legacy-Birv-Jx6.mjs';
+import { S as SkuilderCourseData, Q as QualifiedCardID, T as TagStub, a as Tag } from '../../types-legacy-B8ahaCbj.mjs';
 import { S as SyncStrategy, A as AccountCreationResult, a as AuthenticationResult } from '../../SyncStrategy-CyATpyLQ.mjs';
 import 'moment';
 
@@ -23,6 +23,7 @@ declare class StaticDataLayerProvider implements DataLayerProvider {
     getCoursesDB(): CoursesDBInterface;
     getClassroomDB(_classId: string, _type: 'student' | 'teacher'): Promise<ClassroomDBInterface>;
     getAdminDB(): AdminDBInterface;
+    createUserReaderForUser(targetUsername: string): Promise<UserDBReader>;
     isReadOnly(): boolean;
 }
 
@@ -118,14 +119,18 @@ declare class StaticCourseDB implements CourseDBInterface {
     getCourseInfo(): Promise<CourseInfo>;
     getCourseDoc<T extends SkuilderCourseData>(id: string, _options?: PouchDB.Core.GetOptions): Promise<T>;
     getCourseDocs<T extends SkuilderCourseData>(ids: string[], _options?: PouchDB.Core.AllDocsOptions): Promise<PouchDB.Core.AllDocsWithKeysResponse<{} & T>>;
-    getCardsByELO(elo: number, limit?: number): Promise<string[]>;
+    getCardsByELO(elo: number, limit?: number): Promise<{
+        courseID: string;
+        cardID: string;
+        elo?: number;
+    }[]>;
     getCardEloData(cardIds: string[]): Promise<CourseElo[]>;
     updateCardElo(cardId: string, _elo: CourseElo): Promise<PouchDB.Core.Response>;
     getNewCards(limit?: number): Promise<StudySessionNewItem[]>;
     getCardsCenteredAtELO(options: {
         limit: number;
         elo: 'user' | 'random' | number;
-    }, filter?: (id: string) => boolean): Promise<StudySessionNewItem[]>;
+    }, filter?: (id: QualifiedCardID) => boolean): Promise<StudySessionNewItem[]>;
     getAppliedTags(cardId: string): Promise<PouchDB.Query.Response<TagStub>>;
     addTagToCard(_cardId: string, _tagId: string): Promise<PouchDB.Core.Response>;
     removeTagFromCard(_cardId: string, _tagId: string): Promise<PouchDB.Core.Response>;
@@ -154,6 +159,8 @@ declare class StaticCourseDB implements CourseDBInterface {
      * Internal helper method for static attachment serving
      */
     getAttachmentBlob(docId: string, attachmentName: string): Promise<Blob | Buffer | null>;
+    searchCards(_query: string): Promise<any[]>;
+    find(_request: PouchDB.Find.FindRequest<any>): Promise<PouchDB.Find.FindResponse<any>>;
 }
 
 declare class StaticCoursesDB implements CoursesDBInterface {

package/dist/impl/static/index.d.ts

@@ -1,8 +1,8 @@
-import { U as UserDBInterface, C as CourseDBInterface, a as CoursesDBInterface, b as ClassroomDBInterface, A as AdminDBInterface, c as CourseInfo, S as StudySessionNewItem, D as DataLayerResult, d as ContentNavigationStrategyData, e as StudySessionReviewItem, f as ScheduledCard } from '../../userDB-DusL7OXe.js';
-import { D as DataLayerProvider } from '../../dataLayerProvider-DqtNroSh.js';
-import { S as StaticCourseManifest } from '../../types-BefDGkKa.js';
+import { U as UserDBInterface, C as CourseDBInterface, b as CoursesDBInterface, c as ClassroomDBInterface, A as AdminDBInterface, a as UserDBReader, d as CourseInfo, S as StudySessionNewItem, D as DataLayerResult, e as ContentNavigationStrategyData, f as StudySessionReviewItem, g as ScheduledCard } from '../../userDB-B7zTQ123.js';
+import { D as DataLayerProvider } from '../../dataLayerProvider-juuqUHOP.js';
+import { S as StaticCourseManifest } from '../../types-DtoI27Xh.js';
 import { CourseConfig, CourseElo, DataShape } from '@vue-skuilder/common';
-import { S as SkuilderCourseData, T as TagStub, a as Tag } from '../../types-legacy-Birv-Jx6.js';
+import { S as SkuilderCourseData, Q as QualifiedCardID, T as TagStub, a as Tag } from '../../types-legacy-B8ahaCbj.js';
 import { S as SyncStrategy, A as AccountCreationResult, a as AuthenticationResult } from '../../SyncStrategy-CyATpyLQ.js';
 import 'moment';
 
@@ -23,6 +23,7 @@ declare class StaticDataLayerProvider implements DataLayerProvider {
     getCoursesDB(): CoursesDBInterface;
     getClassroomDB(_classId: string, _type: 'student' | 'teacher'): Promise<ClassroomDBInterface>;
     getAdminDB(): AdminDBInterface;
+    createUserReaderForUser(targetUsername: string): Promise<UserDBReader>;
     isReadOnly(): boolean;
 }
 
@@ -118,14 +119,18 @@ declare class StaticCourseDB implements CourseDBInterface {
     getCourseInfo(): Promise<CourseInfo>;
     getCourseDoc<T extends SkuilderCourseData>(id: string, _options?: PouchDB.Core.GetOptions): Promise<T>;
     getCourseDocs<T extends SkuilderCourseData>(ids: string[], _options?: PouchDB.Core.AllDocsOptions): Promise<PouchDB.Core.AllDocsWithKeysResponse<{} & T>>;
-    getCardsByELO(elo: number, limit?: number): Promise<string[]>;
+    getCardsByELO(elo: number, limit?: number): Promise<{
+        courseID: string;
+        cardID: string;
+        elo?: number;
+    }[]>;
     getCardEloData(cardIds: string[]): Promise<CourseElo[]>;
     updateCardElo(cardId: string, _elo: CourseElo): Promise<PouchDB.Core.Response>;
     getNewCards(limit?: number): Promise<StudySessionNewItem[]>;
     getCardsCenteredAtELO(options: {
         limit: number;
         elo: 'user' | 'random' | number;
-    }, filter?: (id: string) => boolean): Promise<StudySessionNewItem[]>;
+    }, filter?: (id: QualifiedCardID) => boolean): Promise<StudySessionNewItem[]>;
     getAppliedTags(cardId: string): Promise<PouchDB.Query.Response<TagStub>>;
     addTagToCard(_cardId: string, _tagId: string): Promise<PouchDB.Core.Response>;
     removeTagFromCard(_cardId: string, _tagId: string): Promise<PouchDB.Core.Response>;
@@ -154,6 +159,8 @@ declare class StaticCourseDB implements CourseDBInterface {
      * Internal helper method for static attachment serving
      */
     getAttachmentBlob(docId: string, attachmentName: string): Promise<Blob | Buffer | null>;
+    searchCards(_query: string): Promise<any[]>;
+    find(_request: PouchDB.Find.FindRequest<any>): Promise<PouchDB.Find.FindResponse<any>>;
 }
 
 declare class StaticCoursesDB implements CoursesDBInterface {

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;
   }
@@ -307,37 +307,48 @@ var init_updateQueue = __esm({
         } 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 {
+                  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 +436,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 +514,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"
@@ -557,7 +571,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 +663,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 +944,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 +993,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 +1278,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 +1307,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);
@@ -1358,8 +1414,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 +1455,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 +2170,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(
@@ -2142,14 +2217,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
@@ -2341,6 +2421,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"
+        };
+      }
     };
   }
 });
@@ -2492,6 +2582,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;
       }