@vue-skuilder/db 0.1.11-7 → 0.1.11

package/src/impl/couch/courseDB.ts

@@ -18,7 +18,14 @@ import {
   StudySessionNewItem,
   StudySessionReviewItem,
 } from '../../core/interfaces/contentSource';
-import { CardData, DocType, SkuilderCourseData, Tag, TagStub } from '../../core/types/types-legacy';
+import {
+  CardData,
+  DocType,
+  QualifiedCardID,
+  SkuilderCourseData,
+  Tag,
+  TagStub,
+} from '../../core/types/types-legacy';
 import { logger } from '../../util/logger';
 import { GET_CACHED } from './clientCache';
 import { addNote55, addTagToCard, getCredentialledCourseConfig, getTagID } from './courseAPI';
@@ -263,7 +270,7 @@ export class CourseDB implements StudyContentSource, CourseDBInterface {
       limit: aboveLimit,
       startkey: elo + 1,
     });
-    // console.log(JSON.stringify(below));
+    // logger.log(JSON.stringify(below));
 
     let cards = below.rows;
     cards = cards.concat(above.rows);
@@ -277,7 +284,13 @@ export class CourseDB implements StudyContentSource, CourseDBInterface {
           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:\n${below.rows.map((r) => `\t${r.id}-${r.key}\n`)}
 
@@ -342,7 +355,13 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
     tagId: string,
     updateELO?: boolean
   ): Promise<PouchDB.Core.Response> {
-    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: string, tagId: string): Promise<PouchDB.Core.Response> {
@@ -535,7 +554,7 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
       limit: 99,
       elo: 'user',
     },
-    filter?: (a: string) => boolean
+    filter?: (a: QualifiedCardID) => boolean
   ): Promise<StudySessionItem[]> {
     let targetElo: number;
 
@@ -554,12 +573,12 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
     } else if (options.elo === 'random') {
       const bounds = await GET_CACHED(`elo-bounds-${this.id}`, () => this.getELOBounds());
       targetElo = Math.round(bounds.low + Math.random() * (bounds.high - bounds.low));
-      // console.log(`Picked ${targetElo} from [${bounds.low}, ${bounds.high}]`);
+      // logger.log(`Picked ${targetElo} from [${bounds.low}, ${bounds.high}]`);
     } else {
       targetElo = options.elo;
     }
 
-    let cards: string[] = [];
+    let cards: (QualifiedCardID & { elo?: number })[] = [];
     let mult: number = 4;
     let previousCount: number = -1;
     let newCount: number = 0;
@@ -579,7 +598,11 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
       mult *= 2;
     }
 
-    const selectedCards: string[] = [];
+    const selectedCards: {
+      courseID: string;
+      cardID: string;
+      elo?: number;
+    }[] = [];
 
     while (selectedCards.length < options.limit && cards.length > 0) {
       const index = randIntWeightedTowardZero(cards.length);
@@ -588,17 +611,113 @@ above:\n${above.rows.map((r) => `\t${r.id}-${r.key}\n`)}`;
     }
 
     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
+  public async searchCards(query: string): Promise<any[]> {
+    logger.log(`[CourseDB ${this.id}] Searching for: "${query}"`);
+
+    // Try multiple search approaches
+    let displayableData;
+
+    try {
+      // Try regex search on the correct data structure: data[0].data
+      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
+      );
+
+      // Fallback: get all displayable data and filter manually
+      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) => {
+          // Search entire document as JSON string - inclusive approach for admin tool
+          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) {
+      // Debug: Let's see what displayable data exists
+      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 as any).docType,
+          dataStructure: (d as any).data ? Object.keys((d as any).data) : 'no data field',
+          dataContent: (d as any).data,
+          fullDoc: d,
+        }))
+      );
+    }
+
+    const allResults: any[] = [];
+
+    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;
+  }
+
+  public async find(
+    request: PouchDB.Find.FindRequest<any>
+  ): Promise<PouchDB.Find.FindResponse<any>> {
+    return this.db.find(request);
+  }
 }
 
 /**

package/src/impl/couch/courseLookupDB.ts

@@ -105,15 +105,15 @@ export default class CourseLookup {
    * @returns Promise<void>
    */
   static async addWithId(
-    courseId: string, 
-    courseName: string, 
+    courseId: string,
+    courseName: string,
     disambiguator?: string
   ): Promise<void> {
     const doc: Omit<CourseLookupDoc, '_rev'> = {
       _id: courseId,
       name: courseName,
     };
-    
+
     if (disambiguator) {
       doc.disambiguator = disambiguator;
     }
@@ -130,6 +130,7 @@ export default class CourseLookup {
     return await CourseLookup._db.remove(doc);
   }
 
+  // [ ] rename to allCourses()
   static async allCourseWare(): Promise<CourseLookupDoc[]> {
     const resp = await CourseLookup._db.allDocs<CourseLookupDoc>({
       include_docs: true,

package/src/impl/couch/index.ts

@@ -38,7 +38,7 @@ export function hexEncode(str: string): string {
 
   return returnStr;
 }
-export const pouchDBincludeCredentialsConfig: PouchDB.Configuration.RemoteDatabaseConfiguration = {
+const pouchDBincludeCredentialsConfig: PouchDB.Configuration.RemoteDatabaseConfiguration = {
   fetch(url: string | Request, opts: RequestInit): Promise<Response> {
     opts.credentials = 'include';
 
@@ -46,10 +46,42 @@ export const pouchDBincludeCredentialsConfig: PouchDB.Configuration.RemoteDataba
   },
 } as PouchDB.Configuration.RemoteDatabaseConfiguration;
 
+/**
+ * Creates PouchDB configuration with appropriate authentication method
+ * - Uses HTTP Basic Auth when credentials are available (Node.js/MCP)
+ * - Falls back to cookie auth for browser environments
+ */
+export function createPouchDBConfig(): PouchDB.Configuration.RemoteDatabaseConfiguration {
+  // Check if running in Node.js with explicit credentials
+  const hasExplicitCredentials = ENV.COUCHDB_USERNAME && ENV.COUCHDB_PASSWORD;
+  const isNodeEnvironment = typeof window === 'undefined';
+  
+  if (hasExplicitCredentials && isNodeEnvironment) {
+    // Use HTTP Basic Auth for Node.js environments (MCP server)
+    return {
+      fetch(url: string | Request, opts: RequestInit = {}): Promise<Response> {
+        const basicAuth = btoa(`${ENV.COUCHDB_USERNAME}:${ENV.COUCHDB_PASSWORD}`);
+        const headers = new Headers(opts.headers || {});
+        headers.set('Authorization', `Basic ${basicAuth}`);
+        
+        const newOpts = {
+          ...opts,
+          headers: headers
+        };
+        
+        return (pouch as any).fetch(url, newOpts);
+      }
+    } as PouchDB.Configuration.RemoteDatabaseConfiguration;
+  }
+  
+  // Use cookie-based auth for browser environments or when no explicit credentials
+  return pouchDBincludeCredentialsConfig;
+}
+
 function getCouchDB(dbName: string): PouchDB.Database {
   return new pouch(
     ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + dbName,
-    pouchDBincludeCredentialsConfig
+    createPouchDBConfig()
   );
 }
 
@@ -57,7 +89,7 @@ export function getCourseDB(courseID: string): PouchDB.Database {
   // todo: keep a cache of opened courseDBs? need to benchmark this somehow
   return new pouch(
     ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + 'coursedb-' + courseID,
-    pouchDBincludeCredentialsConfig
+    createPouchDBConfig()
   );
 }
 
@@ -188,7 +220,7 @@ export function getCouchUserDB(username: string): PouchDB.Database {
   // see: https://github.com/pouchdb-community/pouchdb-authentication/issues/239
   const ret = new pouch(
     ENV.COUCHDB_SERVER_PROTOCOL + '://' + ENV.COUCHDB_SERVER_URL + dbName,
-    pouchDBincludeCredentialsConfig
+    createPouchDBConfig()
   );
   if (guestAccount) {
     updateGuestAccountExpirationDate(ret);

package/src/impl/couch/pouchdb-setup.ts

@@ -8,9 +8,9 @@ PouchDB.plugin(PouchDBAuth);
 
 // Configure PouchDB globally
 PouchDB.defaults({
-  ajax: {
-    timeout: 60000,
-  },
+  // ajax: {
+  //   timeout: 60000,
+  // },
 });
 
 export default PouchDB;

package/src/impl/couch/updateQueue.ts

@@ -52,43 +52,61 @@ export default class UpdateQueue extends Loggable {
       if (this.pendingUpdates[id] && this.pendingUpdates[id].length > 0) {
         this.inprogressUpdates[id] = true;
 
-        try {
-          let doc = await this.readDB.get<T>(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) };
-            } else {
-              doc = {
-                ...doc,
-                ...update,
-              };
+        const MAX_RETRIES = 5;
+        for (let i = 0; i < MAX_RETRIES; i++) {
+          try {
+            const doc = await this.readDB.get<T>(id);
+            logger.debug(`Retrieved doc: ${id}`);
+
+            // Create a new doc object to apply updates to for this attempt
+            let updatedDoc = { ...doc };
+
+            // Note: This loop is not fully safe if updates are functions that depend on a specific doc state
+            // that might change between retries. But for simple object merges, it's okay.
+            const updatesToApply = [...this.pendingUpdates[id]];
+            for (const update of updatesToApply) {
+              if (typeof update === 'function') {
+                updatedDoc = { ...updatedDoc, ...update(updatedDoc) };
+              } else {
+                updatedDoc = {
+                  ...updatedDoc,
+                  ...update,
+                };
+              }
             }
-          }
-          // for (const k in doc) {
-          //   console.log(`${k}: ${typeof k}`);
-          // }
-          // console.log(`Applied updates to doc: ${JSON.stringify(doc)}`);
-          await this.writeDB.put<T>(doc);
-          logger.debug(`Put doc: ${id}`);
 
-          if (this.pendingUpdates[id].length === 0) {
-            this.inprogressUpdates[id] = false;
-            delete this.inprogressUpdates[id];
-          } else {
-            return this.applyUpdates<T>(id);
-          }
-          return doc;
-        } catch (e) {
-          // Clean up queue state before re-throwing
-          delete this.inprogressUpdates[id];
-          if (this.pendingUpdates[id]) {
-            delete this.pendingUpdates[id];
+            await this.writeDB.put<T>(updatedDoc);
+            logger.debug(`Put doc: ${id}`);
+
+            // Success! Remove the updates we just applied.
+            this.pendingUpdates[id].splice(0, updatesToApply.length);
+
+            if (this.pendingUpdates[id].length === 0) {
+              this.inprogressUpdates[id] = false;
+              delete this.inprogressUpdates[id];
+            } else {
+              // More updates came in, run again.
+              return this.applyUpdates<T>(id);
+            }
+            return updatedDoc as any; // success, exit loop and function
+          } catch (e: any) {
+            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()));
+              // continue to next iteration of the loop
+            } else {
+              // Max retries reached or a non-conflict error
+              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; // Let caller handle
+            }
           }
-          logger.error(`Error on attemped update: ${JSON.stringify(e)}`);
-          throw e; // Let caller handle (e.g., putCardRecord's 404 handling)
         }
+        // This should be unreachable, but it satisfies the compiler that a value is always returned or an error thrown.
+        throw new Error(`UpdateQueue failed for doc ${id} after ${MAX_RETRIES} retries.`);
       } else {
         throw new Error(`Empty Updates Queue Triggered`);
       }

package/src/impl/static/StaticDataLayerProvider.ts

@@ -7,6 +7,7 @@ import {
   CourseDBInterface,
   DataLayerProvider,
   UserDBInterface,
+  UserDBReader,
 } from '../../core/interfaces';
 import { logger } from '../../util/logger';
 import { StaticCourseManifest } from '../../util/packer/types';
@@ -87,6 +88,16 @@ export class StaticDataLayerProvider implements DataLayerProvider {
     throw new Error('Admin functions not supported in static mode');
   }
 
+  async createUserReaderForUser(targetUsername: string): Promise<UserDBReader> {
+    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`);
+    
+    // In static mode, just return the current user's DB as a reader
+    // This is safe since static mode is typically for development/testing
+    return this.getUserDB() as UserDBReader;
+  }
+
   isReadOnly(): boolean {
     return true;
   }

package/src/impl/static/courseDB.ts

@@ -10,7 +10,13 @@ import {
 import { StaticDataUnpacker } from './StaticDataUnpacker';
 import { StaticCourseManifest } from '../../util/packer/types';
 import { CourseConfig, CourseElo, DataShape, Status } from '@vue-skuilder/common';
-import { Tag, TagStub, DocType, SkuilderCourseData } from '../../core/types/types-legacy';
+import {
+  Tag,
+  TagStub,
+  DocType,
+  SkuilderCourseData,
+  QualifiedCardID,
+} from '../../core/types/types-legacy';
 import { DataLayerResult } from '../../core/types/db';
 import { ContentNavigationStrategyData } from '../../core/types/contentNavigationStrategy';
 import { ScheduledCard } from '../../core/types/user';
@@ -91,8 +97,20 @@ export class StaticCourseDB implements CourseDBInterface {
     };
   }
 
-  async getCardsByELO(elo: number, limit?: number): Promise<string[]> {
-    return this.unpacker.queryByElo(elo, limit || 25);
+  async getCardsByELO(
+    elo: number,
+    limit?: number
+  ): Promise<
+    {
+      courseID: string;
+      cardID: string;
+      elo?: number;
+    }[]
+  > {
+    return (await this.unpacker.queryByElo(elo, limit || 25)).map((card) => {
+      const [courseID, cardID, elo] = card.split('-');
+      return { courseID, cardID, elo: elo ? parseInt(elo) : undefined };
+    });
   }
 
   async getCardEloData(cardIds: string[]): Promise<CourseElo[]> {
@@ -129,7 +147,7 @@ export class StaticCourseDB implements CourseDBInterface {
 
   async getCardsCenteredAtELO(
     options: { limit: number; elo: 'user' | 'random' | number },
-    filter?: (id: string) => boolean
+    filter?: (id: QualifiedCardID) => boolean
   ): Promise<StudySessionNewItem[]> {
     let targetElo = typeof options.elo === 'number' ? options.elo : 1000;
 
@@ -148,16 +166,21 @@ export class StaticCourseDB implements CourseDBInterface {
       targetElo = 800 + Math.random() * 400; // Random between 800-1200
     }
 
-    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' as const,
-      qualifiedID: `${this.courseId}-${cardId}`,
-      cardID: cardId,
+      // qualifiedID: `${this.courseId}-${cardId}`,
+      cardID: card.cardID,
       contentSourceType: 'course' as const,
       contentSourceID: this.courseId,
       courseID: this.courseId,
@@ -390,4 +413,20 @@ export class StaticCourseDB implements CourseDBInterface {
   async getAttachmentBlob(docId: string, attachmentName: string): Promise<Blob | Buffer | null> {
     return this.unpacker.getAttachmentBlob(docId, attachmentName);
   }
+
+  // Admin search methods
+  async searchCards(_query: string): Promise<any[]> {
+    // In static mode, return empty results for now
+    // Could be implemented with local search if needed
+    return [];
+  }
+
+  async find(_request: PouchDB.Find.FindRequest<any>): Promise<PouchDB.Find.FindResponse<any>> {
+    // In static mode, return empty results for now
+    // Could be implemented with local search if needed
+    return {
+      docs: [],
+      warning: 'Find operations not supported in static mode',
+    } as any;
+  }
 }

package/src/pouch/index.ts

@@ -0,0 +1,2 @@
+// Export configured PouchDB instance
+export { default } from '../impl/couch/pouchdb-setup.js';